Use httpclient para implementar el método de carga y descarga de archivos

1 http

El protocolo HTTP es probablemente el protocolo más utilizado e importante en Internet ahora. Cada vez más aplicaciones Java deben acceder directamente a los recursos de red a través del protocolo HTTP.

Aunque la funcionalidad básica de acceder al protocolo HTTP se ha proporcionado en el paquete JDK java.net, la biblioteca JDK en sí no proporciona lo suficientemente rico y flexible para la mayoría de las aplicaciones. HTTPClient se utiliza para proporcionar kits de herramientas de programación de clientes eficientes y ricos en funciones que admiten el protocolo HTTP, y admite las últimas versiones y recomendaciones del protocolo HTTP.

En términos generales, usamos Chrome u otros navegadores para acceder a un servidor web, que se utiliza para navegar por páginas para ver información, enviar algunos datos, cargar archivos, etc. Algunas de las páginas visitadas son solo algunas páginas comunes, algunos requieren que los usuarios inicien sesión antes de usarlos, o requieren autenticación y otras se transmiten a través del cifrado, como HTTPS. Los navegadores que usamos actualmente para manejar estas situaciones no plantearán un problema. Pero, ¿qué pasa si tenemos la necesidad de no acceder a los recursos del servidor a través del navegador? Entonces, ¿qué debo hacer?

Llevemos al cliente local a cargar y descargar archivos como un ejemplo para hacer una pequeña demostración. Hay dos formas de httpclient, una está en org.apache.http y la otra es org.apache.commons.httpclient.httpclient.

2 Archivo Subido

La carga de archivos se puede implementar de dos maneras, una es el método Postmetod y el otro es el método HTTPPost. Los dos son similares. PostMethod usa FileBody para envolver la transmisión de envoltura de archivos, y HttpPost usa FilePart para envolver el flujo de archivos. Al pasar las transmisiones de archivo al servidor, se pueden pasar otros parámetros al mismo tiempo.

2.1 Procesamiento de clientes

2.1.1 Método postmetía

Encapsula el archivo en FilePart y póngalo en una matriz parcial. Al mismo tiempo, se pueden colocar otros parámetros en StringPart. No hay escritura aquí, sino simplemente establecer los parámetros en forma de setParameter. El httpclient aquí es org.apache.commons.httpclient.httpclient.

 public void upload (string localfile) {archivo file = nuevo archivo (localfile); Postmethod filepost = new Postmethod (URL_STR); HttpClient Client = new httpClient (); Pruebe {// Los siguientes métodos se pueden usar para simular el parámetro de la página FilePost.SetParameter ("Nombre de usuario", nombre de usuario); filepost.setParameter ("passwd", passwd); Parte [] Parts = {new FilePart (file.getName (), file)}; FilePost.SetRequestEntity (nueva multiprecutentidad (piezas, filepost.getParams ())); client.gethttpconnectionManager (). getParams (). setConnectionTimeOut (5000); int status = client.executemethod (filePost); if (status == httpstatus.sc_ok) {system.out.println ("cargado con éxito"); } else {system.out.println ("cargar fallido"); }} capt (excepción ex) {ex.printstackTrace (); } Finalmente {FilePost.ReleaseConnection (); }}

Recuerde liberar la conexión a través de Releaseconnection después de completarla.

2.1.2 método httppost

Este método es similar al anterior, pero se convierte en FileBody. La matriz de piezas anterior corresponde a httpentity aquí. El httpclient aquí está en org.apache.http.client.methods.

 Public void upload (string localfile) {closeableHttpClient httpClient = null; Respuesta ClosableHttPResponse = NULL; intente {httpclient = httpclients.createDefault (); // cargar un parámetro y archivo normales a la siguiente dirección es un servlet httppost httppost = new httppost (url_str); // convertir el archivo en una transmisión de objeto FileBody FileBody bin = new FileBody (nuevo archivo (LocalFile)); StringBody UserName = new StringBody ("Scott", ContentType.Create ("Text/Plain", consts.Utf_8)); StringBody Password = new StringBody ("123456", contentType.Create ("Text/Plain", consts.Utf_8)); Httpentity reqentity = multipartentityBuilder.create () // equivalente a <input type = "file" name = "file"/> .addpart ("file", bin) // equivalente a <input type = "text" name = "userName" valor = username> .addpart ("usame", usame) .AddPart ("passerniD). httppost.setEntity (reqentity); // inicia la solicitud y devuelve la respuesta de la respuesta de solicitud = httpclient.execute (httppost); System.out.println ("El valor de respuesta del token:" + respuesta.getFirstheader ("token")); // Obtener el objeto de respuesta httpentity resentity = respuesta.getEntity (); if (Resentity! = NULL) {// Imprima la longitud de respuesta System.out.println ("Longitud de contenido de respuesta:" + Resentity.getContentLength ()); // Imprimir contenido de respuesta System.out.println (EntityUtils.ToString (Resentity, Charset.forname ("UTF-8"))); } // destruir entityUtils.consume (resentidad); } catch (Exception e) {E.PrintStackTrace (); } finalmente {try {if (respuesta! = null) {respuesta.close (); }} catch (ioException e) {E.PrintStackTrace (); } try {if (httpclient! = null) {httpclient.close (); }} catch (ioException e) {E.PrintStackTrace (); }}}

2.2 Procesamiento del lado del servidor

No importa qué método de carga sea el cliente, el procesamiento en el servidor es el mismo. Después de obtener los parámetros a través de httpservletRequest, el elemento obtenido se clasifica en formularios ordinarios y formularios de archivo.

ServletFileUpload puede establecer el tamaño y el formato de codificación del archivo cargado.

En resumen, el procesamiento del lado del servidor trata los parámetros obtenidos como formularios HTML.

 Public void ProcessUpload (HttpServletRequest Solicitud, respuesta httpservletResponse) {archivo uploadFile = nuevo archivo (uploadPath); if (! uploadFile.Exists ()) {uploadFile.mkdirs (); } System.out.println ("Vamos, bebé ......"); request.setcharacterEncoding ("UTF-8"); respuesta.setcharacterEncoding ("UTF-8"); // Detección de si el archivo de carga existe boolean isMultipart = servletFileUpload.IsmultipartContent (solicitud); if (isMultipart) {diskFileItemFactory factory = new DiskFileItemFactory (); // Especificar el tamaño de los datos en caché en la memoria, la unidad es byte, aquí se establece en 1MB de fábrica. Setsizethreshold (1024*1024); // Establecer los datos se almacenan en el directorio de disco duro cuando el tamaño del archivo excede el valor de getSizethReshold () factory.setRepository (nuevo archivo ("d: // temp")); // Crear un nuevo controlador de carga de archivos ServletFileUpload upload = new ServletFileUpload (fábrica); // Especifique el tamaño máximo de un solo archivo cargado, unidad: bytes, establecido en 50mb upload.setFilesizeMax (50 * 1024 * 1024); // Especifique el tamaño total de múltiples archivos cargados a la vez, unidad: bytes, establecido en 50mb upload.setsizeMax (50 * 1024 * 1024); subir.setheaderEncoding ("UTF-8"); Lista <StilEitem> items = null; Pruebe {// Solicitud de solicitud Solicitar elementos = upload.parserequest (solicitud); } catch (FileUploadException e) {E.PrintStackTrace (); } if (items! = null) {// PARSE FORME item iterator <FileItem> iter = items.iterator (); while (iter.hasnext ()) {fileItem item = iter.next (); // Si es un atributo de formulario normal if (item.isformfield ()) {// El atributo de nombre equivalente a la entrada es <input type = "text" name = "content"> string name = item.getFieldName (); // El atributo de valor del valor de cadena de entrada = item.getString (); System.out.println ("Propiedad:" + nombre + "Valor de atributo:" + valor); } // Si está cargando archivo más {// Atribute Nombre String FieldName = item.getFieldName (); // cargar la ruta del archivo String filename = item.getName (); filename = filename.substring (filename.lastIndexof ("/") + 1); // Obtenga el nombre del archivo del archivo cargado intente {item.write (nuevo archivo (uploadPath, filename)); } catch (Exception e) {E.PrintStackTrace (); }}}}}} respuesta.addheader ("token", "hola"); }

Después del procesamiento, el servidor puede establecer información simple devuelta al cliente en el encabezado. Si el cliente de retorno es una secuencia, ¡el tamaño de la secuencia debe configurarse con anticipación!

respuesta.setContentLength ((int) file.length ());

3 descargas de archivos

La descarga de archivos se puede implementar utilizando el GetMethod de HttpClient, y el método Httpget y el método original de HttpurlConnection.

3.1 Procesamiento de clientes

3.1.1 Método GetMethod

El httpclient aquí es org.apache.commons.httpclient.httpclient.

 Descargar public void (String RemoteFileName, String LocalFileName) {httpClient Client = new httpClient (); GetMethod get = null; FileOutputStream output = null; intente {get = new getMethod (url_str); get.setRequestHeader ("Nombre de usuario", nombre de usuario); get.setRequestHeader ("passwd", passwd); get.setRequestHeader ("nombre de archivo", remotoFileName); int i = client.executemethod (get); if (éxito == i) {System.out.println ("El valor de respuesta del token:" + get.getResponseHeader ("token")); Archivo storeFile = nuevo archivo (localFileName); salida = nuevo FileOutputStream (StoreFile); // Obtenga la matriz de bytes de los recursos de red y escriba en el archivo output.write (get.getResponseBody ()); } else {System.out.println ("El archivo de descarga ocurre la excepción, el código de error es:" + i); }} catch (Exception e) {E.PrintStackTrace (); } finalmente {try {if (output! = null) {output.close (); }} catch (ioException e) {E.PrintStackTrace (); } get.RelEASECONNECTION (); client.gethttpconnectionManager (). CloseIdLeconnections (0); }}

3.1.2 método httpget

El httpclient aquí está en org.apache.http.client.methods.

 Descargar public void (String RemoteFileName, String LocalFileName) {DeFaulThttpClient httpClient = new DeFaUshttpClient (); OutputStream out = null; InputStream in = null; intente {httpget httpget = new httpget (url_str); httpget.addheader ("nombre de usuario", nombre de usuario); httpget.addheader ("passwd", passwd); httpget.addHeader ("nombre de archivo", remotoFileName); HttpResponse httpResponse = httpclient.execute (httpget); Httpentity entity = httpResponse.getEntity (); in = entity.getContent (); larga longitud = entity.getContentLength (); if (longitud <= 0) {System.out.println ("¡El archivo de descarga no existe!"); devolver; } System.out.println ("El valor de respuesta del token:" + httpesponse.getFirstheader ("token")); Archivo archivo = nuevo archivo (localFileName); if (! file.exists ()) {file.createenewfile (); } out = new FileOutputStream (archivo); byte [] buffer = new Byte [4096]; int readLength = 0; while ((readLength = in.read (buffer))> 0) {byte [] bytes = new byte [readLength]; System.arrayCopy (buffer, 0, bytes, 0, readLength); out.write (bytes); } out.flush (); } catch (ioException e) {E.PrintStackTrace (); } catch (Exception e) {E.PrintStackTrace (); } finalmente {try {if (in! = null) {in.close (); }} catch (ioException e) {E.PrintStackTrace (); } try {if (out! = null) {out.close (); }} catch (ioException e) {E.PrintStackTrace (); }}}

3.1.3 Método HttpurlConnection

 public void download3 (String RemoteFileName, String LocalFileName) {FileOutputStream out = null; InputStream in = null; intente {url url = new url (url_str); Urlconnection urlconnection = url.openconnection (); Httpurlconnection httpurlconnection = (httpurlconnection) urlconnection; // true - Establecerá parámetros httpurlconnection.setDoOutput (true); // true-permitirá leer desde httpurlconnection.setDoInput (true); // no usará cachés httpurlconnection.setUsecaches (falso); // Configuración de serializado httpurlconnection.setRequestProperty ("Content-type", "Application/x-java-serialized-object"); // El valor predeterminado es obtener httpurlconnection.setRequestMethod ("post"); httpurlconnection.setRequestProperty ("Connection", "Keep-Alive"); httpurlconnection.setRequestProperty ("charsert", "utf-8"); // 1 min httpurlconnection.setConnectTimeOut (60000); // 1 min httpurlconnection.SetReadTimeOut (60000); httpurlconnection.addrequestProperty ("nombre de usuario", nombre de usuario); httpurlconnection.addrequestProperty ("passwd", passwd); httpurlconnection.addrequestProperty ("nombre de archivo", remotoFileName); // conectarse al servidor (TCP) httpurlconnection.connect (); in = httpurlconnection.getInputStream (); // Enviar solicitud a // archivo de archivo de servidor = nuevo archivo (localFileName); if (! file.exists ()) {file.createenewfile (); } out = new FileOutputStream (archivo); byte [] buffer = new Byte [4096]; int readLength = 0; while ((readLength = in.read (buffer))> 0) {byte [] bytes = new byte [readLength]; System.arrayCopy (buffer, 0, bytes, 0, readLength); out.write (bytes); } out.flush (); } catch (Exception e) {E.PrintStackTrace (); } finalmente {try {if (in! = null) {in.close (); }} catch (ioException e) {E.PrintStackTrace (); } try {if (out! = null) {out.close (); }} catch (ioException e) {E.PrintStackTrace (); }}}

3.2 Procesamiento del lado del servidor

Aunque el cliente se maneja de manera diferente, el servidor es el mismo.

 Public void ProcessDownload (HTTPServletRequest Solicitud, respuesta httpservletResponse) {int buffer_size = 4096; InputStream in = null; OutputStream out = null; System.out.println ("Vamos, bebé ......"); intente {request.setcharacterEncoding ("UTF-8"); respuesta.setcharacterEncoding ("UTF-8"); respuesta.setContentType ("Application/Octet-stream"); String UserName = request.getheader ("nombre de usuario"); Cadena passwd = request.getheader ("passwd"); Cadena filename = request.getheader ("nombre de archivo"); System.out.println ("Nombre de usuario:" + nombre de usuario); System.out.println ("passwd:" + passwd); System.out.println ("FileName:" + FileName); // El procesamiento adicional se puede realizar en función del nombre de usuario aprobado y aprobado, como verificar si la solicitud es legal, etc. Archivo de archivo = nuevo archivo (descargarpath + "//" + nombre de archivo); respuesta.setContentLength ((int) file.length ()); respuesta.setheader ("Aceptar rangos", "bytes"); int readLength = 0; in = new BufferedInputStream (nuevo FileInputStream (archivo), buffer_size); out = new BufferedOutputStream (respuesta.getOutputStream ()); byte [] buffer = new Byte [buffer_size]; while ((readLength = in.read (buffer))> 0) {byte [] bytes = new byte [readLength]; System.arrayCopy (buffer, 0, bytes, 0, readLength); out.write (bytes); } out.flush (); Respuesta.AddHeader ("Token", "Hola 1"); } catch (Exception e) {E.PrintStackTrace (); Respuesta.AddHeader ("Token", "Hola 2"); } finalmente {if (in! = null) {try {in.close (); } catch (ioException e) {}} if (out! = null) {try {out.close (); } catch (ioexception e) {}}}}

4 Resumen

La función más básica de HTTPClient es ejecutar el método HTTP. La ejecución de un método HTTP implica la interacción de una o más solicitudes HTTP/respuestas HTTP. Por lo general, este proceso será procesado automáticamente por HTTPClient y es transparente para el usuario. El usuario solo necesita proporcionar el objeto de solicitud HTTP, y el HTTPClient enviará la solicitud HTTP al servidor de destino y recibirá la respuesta del servidor. Si la solicitud HTTP no se ejecuta con éxito, el httppclient lanzará una excepción. Así que preste atención a finalmente manejar al escribir código.

Todas las solicitudes HTTP tienen una línea de solicitud, incluido el nombre del método, el URI de solicitud y el número de versión HTTP. HTTPClient admite todos los métodos HTTP definidos en HTTP/1.1: Get, Head, Post, Put, Elimine, Trace y Opciones. La carga anterior usa POST, y la descarga es Get.

Actualmente, use org.apache.commons.httpclient.httpclient más. Depende de mi ~

Lo anterior es todo el contenido de los métodos de carga y descarga para usar httpclient para implementar archivos. Espero que todos puedan apoyar a Wulin.com más ~