Resumen: Este artículo presenta dos métodos para que JavaBean implemente la carga de múltiples archivos, utilizando el protocolo http y el protocolo ftp respectivamente. Primero, describe el formato básico de transferencia de múltiples archivos a través del protocolo http y el proceso detallado de carga. Luego, presenta brevemente el uso de la clase ftpclient para implementar la carga ftp y, finalmente, compara los dos métodos.
Palabras clave: JavaBean, http, ftp, ftpclient
JavaBean es un componente de software basado en Java. JSP proporciona soporte completo para integrar componentes JavaBean en aplicaciones web. Este soporte no solo acorta el tiempo de desarrollo (puede usar directamente componentes existentes que han sido probados y confiables, evitando desarrollos repetidos), sino que también brinda más escalabilidad a las aplicaciones JSP.
La función de carga de archivos es muy común en el modelo de desarrollo basado en B/S. En comparación con otras herramientas de desarrollo, el soporte de JSP para la carga de archivos no es perfecto. No requiere componentes para completarse como ASP, ni proporciona soporte directo para la carga de archivos como PHP. La forma en que JSP implementa la carga de archivos es la siguiente: use el método getInputStream () de la clase ServletRequest para obtener un flujo de datos enviado por el cliente al servidor, y luego procese este flujo de datos para analizar y obtener los diversos parámetros y parámetros pasados a el servidor durante la carga de datos del archivo y luego almacenar los datos del archivo en él como un archivo o insertarlo en una base de datos. Por lo general, las páginas JSP no manejan la función de carga de archivos, sino que colocan estas funciones en Servlets o JavaBeans para implementarlas. En algunos libros relacionados con JSP se presentan ejemplos del uso de Servlet para completar la carga de archivos. Aquí presentaré cómo usar JeanBean para completar la carga de archivos. Hay dos formas de cargar archivos en JSP, a saber, el protocolo HTTP y el protocolo FTP. Existen grandes diferencias en los principios de transmisión entre los dos. A continuación se dará una breve introducción a su implementación basada en el código fuente. Creo que los lectores obtendrán algo de ello. El siguiente programa ha sido depurado y aprobado. Entorno de depuración: servidor Windows 2000+Apache +tomcat4.0, entorno de depuración JavaBean: JDK1.4+Editplus.
El uso de JavaBean en JSP para implementar la función de carga de archivos basada en web generalmente requiere la combinación de tres tipos de archivos. Estos tres archivos son, respectivamente, el archivo de página HTML que proporciona la interfaz, el archivo JSP que completa la llamada para implementar la función de carga de JavaBean y el archivo de clase Java que implementa JavaBean. A continuación me centraré en la parte de JavaBean que utiliza el protocolo HTTP y el protocolo FTP para implementar la función de carga de archivos.
1 Utilice el protocolo HTTP para cargar varios archivos.
En el pasado, los formularios HTML no podían cargar archivos, lo que limitaba un poco las funciones de algunas páginas web. La especificación RFC1867 (es decir, carga de archivos basada en formularios en HTML) amplía el formulario y agrega un elemento de formulario <tipo de entrada=archivo>. Al utilizar este elemento, el navegador generará automáticamente un cuadro de entrada y un botón. El cuadro de entrada permite al usuario completar el nombre del archivo local y el nombre de la ruta, y el botón permite al navegador abrir un cuadro de selección de archivos para que el usuario lo haga. seleccione un archivo. La implementación del formulario específico es la siguiente:
<FORMMETHOD="POST" ACTION="*.jsp" ENCTYPE="multipart/form-data">
<TIPO DE ENTRADA="NOMBRE DE ARCHIVO"="FILE1" TAMAÑO="50"><BR>
<TIPO DE ENTRADA="ENVIAR" VALOR="Subir">
</FORM>
Cuando elija pegar el archivo, ingrese directamente la ruta absoluta del archivo local. El valor del atributo de acción del formulario es *.jsp, lo que significa que la solicitud (incluido el archivo cargado) se enviará al. *..archivo jsp. En este proceso, en realidad se implementa la carga de archivos a través de HTTP. La carga de archivos del cliente al servidor es compatible con la interfaz de puerta de enlace común (CGI) del protocolo HTTP. Este método de carga requiere que tanto el navegador como el servidor WEB admitan Rfc1867. JavaBean obtiene un flujo de datos enviado por el cliente al servidor a través del método getInputStream () de la clase ServletRequest, analiza el formato del archivo cargado y envía varios archivos al archivo de destino en el lado del servidor en secuencia según los resultados del análisis. La función de JavaBeande en este ejemplo está implementada específicamente por la clase testUpload. El marco de la clase TestUpload es el siguiente:
clase pública testUpload
{
prueba públicaCargar(){……}
inicialización de vacío final público (configuración de ServletConfig) lanza ServletException
{ m_application = config.getServletContext();
carga pública vacía () lanza testUploadException, IOException, ServletException
{…………}
getDataSection vacío privado(){………}
getDataHeader vacío privado(){………}
public int save (cadena destPathName)
lanza SmartUploadException, IOException, ServletException
{…………}
…
}
Inicialice el entorno de ejecución del Servlet mediante el método inicializar(). Utilice el método upload() para obtener el flujo de entrada, analizar el formato del archivo cargado y asignar los atributos de cada archivo cargado a múltiples instancias de clase File para su procesamiento. Estas instancias de clase File son administradas por la clase Files. La clase Archivo llama a su método save () de acuerdo con los atributos de cada archivo para enviar varios archivos al archivo de destino en el lado del servidor en secuencia. El método upload() es la clave y se utiliza para analizar el formato de los archivos transmitidos por el protocolo http1.1. Después de la prueba, obtenemos el formato del archivo de flujo de transporte, que es útil para comprender el método upload(). Por ejemplo, cargue el archivo Mis documentostt.txt. El formato es el siguiente:
//Separador de archivos
--------------------------7d226137250336
//encabezado de información del archivo
Disposición de contenido: formulario-datos; nombre="FILE1"; nombre de archivo="C:Documentos y configuracionesAdministrador.TIMBER-4O6B0ZZ0Mis documentostt.sql"
Tipo de contenido: texto/sin formato
//Contenido del archivo fuente
crear información de tabla (
imagen de contenido nula);
//Delimitador del siguiente archivo
--------------------------7d226137250336
Disposición de contenido: formulario-datos; nombre="FILE2";
Tipo de contenido: aplicación/flujo de octetos
--------------------------------7d226137250336
De los archivos anteriores podemos ver que al cargar varios archivos, el protocolo HTTP Todos se colocan en el flujo de entrada y se distinguen por ciertos delimitadores. De hecho, el método upload() consiste en analizar el archivo anterior y determinar el contenido del delimitador, el formato del contenido de cada archivo, el nombre de ruta completo del archivo y el principio y el final de los datos reales del archivo. Una cosa a tener en cuenta aquí es que el delimitador es aleatorio, son todos los caracteres antes del primer carácter de retorno de carro del archivo de flujo de transporte.
El proceso de implementación del método Upload () es: primero envíe el archivo de flujo de entrada a la matriz de bytes m_binArray, que se implementa mediante el siguiente código.
m_totalBytes=1024; lectura total=0;
para(; lectura total < m_totalBytes; lectura total += lecturaBytes)
intentar
{ m_request.getInputStream();
readBytes = m_request.getInputStream().read(m_binArray, totalRead, m_totalBytes - totalRead);
}catch(Exception e){ throw new SmartUploadException("No se puede cargar.");}
Aquí se utiliza el método de lectura de varios bytes en el bucle. El bucle anterior lee datos continuamente hasta que se llena la matriz. Si un archivo se puede recuperar por completo, también se pueden recuperar todos los bytes del archivo. Pero debido a que la velocidad de la red suele ser mucho más lenta que la de la CPU, es fácil para el programa borrar el búfer de la red antes de que lleguen todos los datos. De hecho, el método de lectura multibyte devolverá 0 cuando intente leer datos de un búfer de red temporalmente vacío pero abierto, lo que significa que no existen datos pero el flujo de red no se ha cerrado. En este caso, el método de un solo byte impedirá la ejecución del programa en ejecución, por lo que el comportamiento del método de varios bytes es mejor que el del método read() de un solo byte. A continuación se analizará la matriz de bytes m_binArray. Primero busque el delimitador; use el método getDataHeader() para devolver el valor del encabezado de información del archivo, a partir del cual se determina el nombre de ruta completo del archivo fuente, la extensión del archivo fuente y el formato del contenido del archivo fuente; use getDataSection(); Método para devolver los datos del contenido del archivo y registrarlos. Las posiciones inicial y final de los datos del archivo en la matriz de bytes. Luego genere una instancia de clase Archivo y coloque el nombre de ruta completo del archivo, la extensión del archivo fuente, el formato del contenido del archivo fuente y las posiciones inicial y final de los datos del contenido del archivo en los atributos de la instancia de clase Archivo. Encuentre el siguiente delimitador y continúe repitiendo el proceso anterior hasta que se complete el análisis.
2 Utilice el protocolo FTP para cargar varios archivos
El protocolo FTP es un protocolo utilizado para transferir archivos en Internet. Estipula los estándares para la transferencia mutua de archivos en Internet. La implementación de esta función en Java se logra con la ayuda de la clase FtpClient. Proceso de implementación específico: primero establezca una conexión con el servidor FTP; inicialice el método de transmisión del archivo, incluidos ASCII y BINARIO; envíe el archivo al flujo de entrada del archivo FileInputStream; lea los datos en FileInputStream en una matriz de bytes; los datos se escriben en el flujo de salida TelnetOutputStream (use el método de escritura para escribir los datos en un enlace de red). De esta forma, se copia al servidor un archivo con el mismo nombre que el archivo fuente. En este ejemplo, JavaBean completa el proceso de carga de archivos mediante tres métodos: connectServer(), upload() y closeConnect(). La implementación principal es la siguiente:
clase pública ftpUpload
{ Nombre de archivo de cadena;Nombre de archivo de cadena1;FtpClient ftpClient;
public void connectServer (servidor de cadena, usuario de cadena, contraseña de cadena, ruta de cadena)
{
//servidor: dirección IP del servidor FTP usuario: nombre de usuario para iniciar sesión en el servidor FTP;
//contraseña: la contraseña del nombre de usuario para iniciar sesión en el servidor FTP ruta: la ruta en el servidor FTP;
intentar{ ftpClient=nuevo FtpClient();
ftpClient.openServer(servidor);
ftpClient.login(usuario, contraseña);
System.out.println("¡Inicio de sesión exitoso!");
if (ruta.longitud()!=0) ftpClient.cd(ruta);
ftpClient.binary(); }catch (IOException ex) {System.out.println(ex);}
}
cierre público vacío ()
{intentar{ ftpClient.closeServer();
}catch (IOException ex) {System.out.println(ex);}
}
carga nula pública()
{ nombre de archivo1=buscarNombre de archivo(nombre de archivo);
//Analice el nombre del archivo a partir del nombre del archivo y utilícelo como el nombre del archivo de destino. No se proporciona el método específico.
intentar {
TelnetOutputStream os=ftpClient.put(nombre de archivo1);
java.io.File file_in=new java.io.File(nombre de archivo);
FileInputStream es = nuevo FileInputStream (file_in);
byte[] bytes=nuevo byte[1024];
intc;
mientras ((c=is.read(bytes))!=-1){ os.write(bytes,0,c });
es.cerrar(); os.cerrar();
} captura (IOException ex) {System.out.println(ex);}
}
}
connectServer () completa la función de establecer una conexión con el servidor FTP, utiliza el método openServer (servidor de cadena) de FtpClient para abrir el servidor FTP remoto y luego utiliza el método de inicio de sesión (usuario, contraseña) de FtpClient para iniciar sesión en el servidor. Hay dos formas de iniciar sesión en el servidor FTP remoto, una es iniciar sesión como usuario registrado y la otra es iniciar sesión de forma anónima. El primero requiere que el usuario se registre primero como cliente del servidor. El servidor le dará al usuario una cuenta de inicio de sesión y una contraseña, y se conectará al servidor según la cuenta y la contraseña. Este último requiere que los usuarios utilicen los nombres de usuario especiales "anónimo" e "invitado" sin registrarse para tener acceso restringido a archivos públicos en hosts remotos. Muchos sistemas ahora requieren que los usuarios utilicen su dirección de correo electrónico como contraseña. Por motivos de seguridad, la mayoría de los servidores FTP anónimos generalmente solo permiten a los usuarios remotos descargar archivos, pero no cargarlos. Esto dependerá de la configuración del servidor FTP. Los usuarios pueden optar por utilizar dos métodos según las condiciones reales. Después de iniciar sesión, utilice el método binario () de FtpClient para inicializar el modo de transmisión al modo byte. upload() completa la función de carga de archivos. Cree el flujo de entrada del archivo FileInputStream del archivo fuente, escriba el flujo de entrada en la matriz de bytes y utilice el método de escritura de TelnetOutputStream para escribir los datos de la matriz de bytes en un enlace de red. Dado que TelnetOutputStream abre un archivo en el servidor FTP, los datos se escriben en el archivo de destino, completando así la carga del archivo. closeConnect() requiere desconectarse del servidor.
Lo anterior es solo el proceso de cargar un solo archivo. Si hay varios archivos, este proceso de carga se puede llamar varias veces. De los dos métodos anteriores, podemos ver que usar el protocolo FTP para cargar varios archivos es relativamente simple y fácil de implementar. Usar el protocolo FTP para cargar archivos es generalmente un programa del lado del cliente y la configuración de seguridad del lado del servidor será más complicada, mientras que usar el protocolo HTTP para cargar archivos es una aplicación del lado del servidor y la configuración de seguridad será relativamente simple; . Y a través de las pruebas, se descubrió que el método de carga FTP es docenas o incluso cientos de veces más rápido que el método de carga HTTP cuando se transmiten archivos grandes, pero es un poco más lento que el método de carga HTTP cuando se transmiten archivos de menos de 1 M. Por lo tanto, ambos métodos de transmisión tienen sus propias ventajas. Se recomienda a los lectores que actúen según sus propias circunstancias. Si tiene alguna pregunta o necesita el código fuente de otras partes, ¡contácteme!