Apache HttpClient - Guía rápida

El Protocolo de transferencia de hipertexto (HTTP) es un protocolo a nivel de aplicación para sistemas de información hipermedia distribuidos y colaborativos. Esta es la base para la comunicación de datos para la World Wide Web (es decir, Internet) desde 1990. HTTP es un protocolo genérico y sin estado que se puede usar para otros fines, así como extensiones de sus métodos de solicitud, códigos de error y encabezados.

Básicamente, HTTP es un protocolo de comunicación basado en TCP / IP, que se utiliza para entregar datos (archivos HTML, archivos de imagen, resultados de consultas, etc.) en la World Wide Web. El puerto predeterminado es TCP 80, pero también se pueden usar otros puertos. Proporciona una forma estandarizada para que las computadoras se comuniquen entre sí. La especificación HTTP define cómo se construirán y enviarán los datos de solicitud de los clientes al servidor, y cómo los servidores responderán a estas solicitudes.

¿Qué es Http Client?

El cliente Http es una biblioteca de transferencia, reside en el lado del cliente, envía y recibe mensajes HTTP. Proporciona una implementación actualizada, rica en funciones y eficiente que cumple con los estándares HTTP recientes.

Además de esto, utilizando la biblioteca de cliente, se pueden crear aplicaciones basadas en HTTP como navegadores web, clientes de servicios web, etc.

Características del cliente Http

Las siguientes son las características destacadas del cliente Http:

• La biblioteca HttpClient implementa todos los métodos HTTP disponibles.

• La biblioteca HttpClient proporciona API para proteger las solicitudes mediante el protocolo Secure Socket Layer.

• Con HttpClient, puede establecer conexiones mediante proxies.

• Puede autenticar conexiones utilizando esquemas de autenticación como Basic, Digest, NTLMv1, NTLMv2, NTLM2 Session, etc.

• La biblioteca HttpClient admite el envío de solicitudes a través de varios subprocesos. Gestiona múltiples conexiones establecidas desde varios subprocesos utilizandoClientConnectionPoolManager.

• Con la biblioteca Apache HttpClient, puede establecer tiempos de espera de conexión.

En este capítulo, explicaremos cómo configurar un entorno para HttpClient en Eclipse IDE. Antes de continuar con la instalación, asegúrese de que ya tiene Eclipse instalado en su sistema. Si no es así, descargue e instale Eclipse.

Para obtener más información sobre Eclipse, consulte nuestro Tutorial de Eclipse .

Paso 1: descargue el archivo JAR de dependencia

Abra la página de inicio oficial del sitio web de HttpClient (componentes) y vaya a la página de descarga

Luego, descargue la última versión estable de HttpClient. Aquí, a lo largo del tutorial, estamos usando la versión 4.5.6, por lo tanto, descargue el archivo4.5.6.zip.

Dentro de la carpeta descargada, encontrará una carpeta llamada lib y esto contiene los archivos Jar necesarios que se agregarán en la ruta de clases de su proyecto, para trabajar con HttpClient.

Paso 2: crea un proyecto y establece la ruta de construcción

Abra eclipse y cree un proyecto de muestra. Haga clic derecho en el proyecto seleccione la opciónBuild Path → Configure Build Path Como se muestra abajo.

En el Java Build Path marco en el Libraries pestaña, haga clic en Add External JARs.

Y seleccione todos los archivos jar en la carpeta lib y haga clic en Apply and Close.

Ya está todo listo para trabajar con la biblioteca HttpClient en eclipse.

El método GET se usa para recuperar información del servidor dado usando un URI dado. Las solicitudes que utilizan GET solo deben recuperar datos y no deben tener ningún otro efecto en los datos.

La API de HttpClient proporciona una clase denominada HttpGet que representa el método de solicitud de obtención.

Siga los pasos que se indican a continuación para enviar una solicitud de obtención utilizando la biblioteca HttpClient

Paso 1: crea un objeto HttpClient

los createDefault() método del HttpClients la clase devuelve un CloseableHttpClient objeto, que es la implementación base del HttpClient interfaz.

Con este método, cree un objeto HttpClient como se muestra a continuación:

CloseableHttpClient httpclient = HttpClients.createDefault();

Paso 2: crear un objeto HttpGet

los HttpGet class representa la solicitud HTTPGET que recupera la información del servidor dado usando un URI.

Cree una solicitud HTTP GET creando una instancia de esta clase. El constructor de esta clase acepta un valor de cadena que representa el URI.

HttpGet httpget = new HttpGet("http://www.tutorialspoint.com/");

Paso 3: ejecutar la solicitud de obtención

los execute() método del CloseableHttpClient La clase acepta un objeto HttpUriRequest (interfaz) (es decir, HttpGet, HttpPost, HttpPut, HttpHead, etc.) y devuelve un objeto de respuesta.

Ejecute la solicitud utilizando este método como se muestra a continuación:

HttpResponse httpresponse = httpclient.execute(httpget);

Ejemplo

A continuación se muestra un ejemplo que demuestra la ejecución de la solicitud HTTP GET utilizando la biblioteca HttpClient.

import java.util.Scanner;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;

public class HttpGetExample {
 
   public static void main(String args[]) throws Exception{
 
      //Creating a HttpClient object
      CloseableHttpClient httpclient = HttpClients.createDefault();

      //Creating a HttpGet object
      HttpGet httpget = new HttpGet("https://www.tutorialspoint.com/ ");

      //Printing the method used
      System.out.println("Request Type: "+httpget.getMethod());

      //Executing the Get request
      HttpResponse httpresponse = httpclient.execute(httpget);

      Scanner sc = new Scanner(httpresponse.getEntity().getContent());

      //Printing the status line
      System.out.println(httpresponse.getStatusLine());
      while(sc.hasNext()) {
         System.out.println(sc.nextLine());
      }
   }
}

Salida

El programa anterior genera la siguiente salida:

Request Type: GET
<!DOCTYPE html>
<!--[if IE 8]><html class = "ie ie8"> <![endif]-->
<!--[if IE 9]><html class = "ie ie9"> <![endif]-->
<!--[if gt IE 9]><!-->
<html lang = "en-US"> <!--<![endif]-->
<head>
<!-- Basic -->
<meta charset = "utf-8">
<title>Parallax Scrolling, Java Cryptography, YAML, Python Data Science, Java
i18n, GitLab, TestRail, VersionOne, DBUtils, Common CLI, Seaborn, Ansible,
LOLCODE, Current Affairs 2018, Apache Commons Collections</title>
<meta name = "Description" content = "Parallax Scrolling, Java Cryptography, YAML,
Python Data Science, Java i18n, GitLab, TestRail, VersionOne, DBUtils, Common
CLI, Seaborn, Ansible, LOLCODE, Current Affairs 2018, Intellij Idea, Apache
Commons Collections, Java 9, GSON, TestLink, Inter Process Communication (IPC),
Logo, PySpark, Google Tag Manager, Free IFSC Code, SAP Workflow"/>
<meta name = "Keywords" content = "Python Data Science, Java i18n, GitLab,
TestRail, VersionOne, DBUtils, Common CLI, Seaborn, Ansible, LOLCODE, Gson,
TestLink, Inter Process Communication (IPC), Logo"/>
<meta http-equiv = "X-UA-Compatible" content = "IE = edge">
<meta name = "viewport" content = "width = device-width,initial-scale = 1.0,userscalable = yes">
<link href = "https://cdn.muicss.com/mui-0.9.39/extra/mui-rem.min.css"
rel = "stylesheet" type = "text/css" />
<link rel = "stylesheet" href="/questions/css/home.css?v = 3" />
<script src = "/questions/js/jquery.min.js"></script>
<script src = "/questions/js/fontawesome.js"></script>
<script src = "https://cdn.muicss.com/mui-0.9.39/js/mui.min.js"></script>
</head>
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
</script>
</body>
</html>

Una solicitud POST se utiliza para enviar datos al servidor; por ejemplo, información del cliente, carga de archivos, etc., utilizando formularios HTML.

La API de HttpClient proporciona una clase denominada HttpPost que representa la solicitud POST.

Siga los pasos que se indican a continuación para enviar una solicitud HTTP POST utilizando la biblioteca HttpClient.

Paso 1: crear un objeto HttpClient

los createDefault() método del HttpClients clase devuelve un objeto de la clase CloseableHttpClient, que es la implementación base del HttpClient interfaz.

Con este método, cree un objeto HttpClient.

CloseableHttpClient httpClient = HttpClients.createDefault();

Paso 2: crear un objeto HttpPost

los HttpPost clase representa el HTTP POSTsolicitud. Esto envía los datos requeridos y recupera la información del servidor dado usando un URI.

Cree esta solicitud creando una instancia del HttpPost class y pasar un valor de cadena que represente el URI, como parámetro a su constructor.

HttpGet httpGet = new HttpGet("http://www.tutorialspoint.com/");

Paso 3: ejecutar la solicitud de obtención

los execute() El método del objeto CloseableHttpClient acepta un objeto HttpUriRequest (interfaz) (es decir, HttpGet, HttpPost, HttpPut, HttpHead, etc.) y devuelve un objeto de respuesta.

HttpResponse httpResponse = httpclient.execute(httpget);

Ejemplo

A continuación se muestra un ejemplo que demuestra la ejecución de la solicitud HTTP POST utilizando la biblioteca HttpClient.

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;

public class HttpPostExample {
 
   public static void main(String args[]) throws Exception{
 
      //Creating a HttpClient object
      CloseableHttpClient httpclient = HttpClients.createDefault();

      //Creating a HttpGet object
      HttpPost httppost = new HttpPost("https://www.tutorialspoint.com/");

      //Printing the method used
      System.out.println("Request Type: "+httppost.getMethod());

      //Executing the Get request
      HttpResponse httpresponse = httpclient.execute(httppost);

      Scanner sc = new Scanner(httpresponse.getEntity().getContent());

      //Printing the status line
      System.out.println(httpresponse.getStatusLine());
      while(sc.hasNext()) {
         System.out.println(sc.nextLine());
      }
   }
}

Salida

El programa anterior genera la siguiente salida.

Request Type: POST
<!DOCTYPE html>
<!--[if IE 8]><html class = "ie ie8"> <![endif]-->
<!--[if IE 9]><html class = "ie ie9"> <![endif]-->
<!--[if gt IE 9]><!--> 
<html lang = "en-US"> <!--<![endif]-->
<head>
<!-- Basic -->
<meta charset = "utf-8">
<title>Parallax Scrolling, Java Cryptography, YAML, Python Data Science, Java
i18n, GitLab, TestRail, VersionOne, DBUtils, Common CLI, Seaborn, Ansible,
LOLCODE, Current Affairs 2018, Apache Commons Collections</title>
<meta name = "Description" content = "Parallax Scrolling, Java Cryptography, YAML,
Python Data Science, Java i18n, GitLab, TestRail, VersionOne, DBUtils, Common
CLI, Seaborn, Ansible, LOLCODE, Current Affairs 2018, Intellij Idea, Apache
Commons Collections, Java 9, GSON, TestLink, Inter Process Communication (IPC),
Logo, PySpark, Google Tag Manager, Free IFSC Code, SAP Workflow"/>
<meta name = "Keywords" content="Python Data Science, Java i18n, GitLab,
TestRail, VersionOne, DBUtils, Common CLI, Seaborn, Ansible, LOLCODE, Gson,
TestLink, Inter Process Communication (IPC), Logo"/>
<meta http-equiv = "X-UA-Compatible" content = "IE = edge">
<meta name = "viewport" conten t= "width = device-width,initial-scale = 1.0,userscalable = yes">
<link href = "https://cdn.muicss.com/mui-0.9.39/extra/mui-rem.min.css"
rel = "stylesheet" type = "text/css" />
<link rel = "stylesheet" href = "/questions/css/home.css?v = 3" />
<script src = "/questions/js/jquery.min.js"></script>
<script src = "/questions/js/fontawesome.js"></script>
<script src = "https://cdn.muicss.com/mui-0.9.39/js/mui.min.js"></script>
</head>
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
</script>
</body>
</html>

Se recomienda procesar las respuestas HTTP mediante los controladores de respuestas. En este capítulo, analizaremos cómo crear controladores de respuesta y cómo usarlos para procesar una respuesta.

Si usa el controlador de respuesta, todas las conexiones HTTP se liberarán automáticamente.

Creando un controlador de respuesta

La API de HttpClient proporciona una interfaz conocida como ResponseHandler en el paquete org.apache.http.client. Para crear un controlador de respuesta, implemente esta interfaz y anule su handleResponse() método.

Cada respuesta tiene un código de estado y si el código de estado está entre 200 y 300, eso significa que la acción se recibió, entendió y aceptó con éxito. Por lo tanto, en nuestro ejemplo, manejaremos las entidades de las respuestas con dichos códigos de estado.

Ejecutando la solicitud usando el controlador de respuesta

Siga los pasos que se indican a continuación para ejecutar la solicitud mediante un controlador de respuesta.

Paso 1: crear un objeto HttpClient

los createDefault() método del HttpClients clase devuelve un objeto de la clase CloseableHttpClient, que es la implementación base del HttpClientinterfaz. Usando este método, cree un objeto HttpClient

CloseableHttpClient httpclient = HttpClients.createDefault();

Paso 2: crear una instancia del controlador de respuesta

Cree una instancia del objeto controlador de respuesta creado anteriormente utilizando la siguiente línea de código:

ResponseHandler<String> responseHandler = new MyResponseHandler();

Paso 3: crear un objeto HttpGet

los HttpGet class representa la solicitud HTTP GET que recupera la información del servidor dado usando un URI.

Cree una solicitud HttpGet creando una instancia de la clase HttpGet y pasando una cadena que represente el URI como parámetro a su constructor.

ResponseHandler<String> responseHandler = new MyResponseHandler();

Paso 4: ejecutar la solicitud Get usando el controlador de respuesta

los CloseableHttpClient la clase tiene una variante de execute() método que acepta dos objetos ResponseHandler y HttpUriRequest, y devuelve un objeto de respuesta.

String httpResponse = httpclient.execute(httpget, responseHandler);

Ejemplo

El siguiente ejemplo demuestra el uso de controladores de respuesta.

import java.io.IOException;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

class MyResponseHandler implements ResponseHandler<String>{
 
   public String handleResponse(final HttpResponse response) throws IOException{

      //Get the status of the response
      int status = response.getStatusLine().getStatusCode();
      if (status >= 200 && status < 300) {
         HttpEntity entity = response.getEntity();
         if(entity == null) {
            return "";
         } else {
            return EntityUtils.toString(entity);
         }

      } else {
         return ""+status;
      }
   }
}

public class ResponseHandlerExample {
   
   public static void main(String args[]) throws Exception{
 
      //Create an HttpClient object
      CloseableHttpClient httpclient = HttpClients.createDefault();

      //instantiate the response handler
      ResponseHandler<String> responseHandler = new MyResponseHandler();

      //Create an HttpGet object
      HttpGet httpget = new HttpGet("http://www.tutorialspoint.com/");

      //Execute the Get request by passing the response handler object and HttpGet object
      String httpresponse = httpclient.execute(httpget, responseHandler);

      System.out.println(httpresponse);
   }
}

Salida

Los programas anteriores generan la siguiente salida:

<!DOCTYPE html>
<!--[if IE 8]><html class = "ie ie8"> <![endif]-->
<!--[if IE 9]><html class = "ie ie9"> <![endif]-->
<!--[if gt IE 9]><!-->
<html lang = "en-US"> <!--<![endif]-->
<head>
<!-- Basic -->
<meta charset = "utf-8">
<meta http-equiv = "X-UA-Compatible" content = "IE = edge">
<meta name = "viewport" content = "width = device-width,initial-scale = 1.0,userscalable = yes">
<link href = "https://cdn.muicss.com/mui-0.9.39/extra/mui-rem.min.css"
rel = "stylesheet" type = "text/css" />
<link rel = "stylesheet" href = "/questions/css/home.css?v = 3" />
<script src = "/questions/js/jquery.min.js"></script>
<script src = "/questions/js/fontawesome.js"></script>
<script src = "https://cdn.muicss.com/mui-0.9.39/js/mui.min.js"></script>
</head>
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
<script>
window.dataLayer = window.dataLayer || [];
function gtag() {dataLayer.push(arguments);}
gtag('js', new Date());
gtag('config', 'UA-232293-17');
</script>
</body>

Si está procesando respuestas HTTP manualmente en lugar de utilizar un controlador de respuestas, debe cerrar todas las conexiones http usted mismo. Este capítulo explica cómo cerrar las conexiones manualmente.

Al cerrar las conexiones HTTP manualmente, siga los pasos que se indican a continuación:

Paso 1: crea un objeto HttpClient

los createDefault() método del HttpClients clase devuelve un objeto de la clase CloseableHttpClient, que es la implementación base de la interfaz HttpClient.

Con este método, cree un HttpClient objeto como se muestra a continuación -

CloseableHttpClient httpClient = HttpClients.createDefault();

Paso 2: inicia un bloque de intentar finalmente

Inicie un bloque de prueba-finalmente, escriba el código restante en los programas en el bloque de prueba y cierre el objeto CloseableHttpClient en el bloque de finalmente.

CloseableHttpClient httpClient = HttpClients.createDefault();
try{
   //Remaining code . . . . . . . . . . . . . . .
}finally{
   httpClient.close();
}

Paso 3: crea un objeto HttpGetobject

los HttpGet class representa la solicitud HTTP GET que recupera la información del servidor dado usando un URI.

Cree una solicitud HTTP GET creando una instancia de la clase HttpGet pasando una cadena que represente el URI.

HttpGet httpGet = new HttpGet("http://www.tutorialspoint.com/");

Paso 4: ejecutar la solicitud Get

los execute() método del CloseableHttpClient objeto acepta un HttpUriRequest (interfaz) objeto (es decir, HttpGet, HttpPost, HttpPut, HttpHead, etc.) y devuelve un objeto de respuesta.

Ejecute la solicitud utilizando el método dado:

HttpResponse httpResponse = httpclient.execute(httpGet);

Paso 5 - Inicie otro intento (anidado) finalmente

Inicie otro bloque de intentar-finalmente (anidado dentro del anterior intento-finalmente), escriba el código restante en los programas en este bloque de intentar y cierre el objeto HttpResponse en el bloque de finalmente.

CloseableHttpClient httpclient = HttpClients.createDefault();
try{
   . . . . . . .
   . . . . . . .
   CloseableHttpResponse httpresponse = httpclient.execute(httpget);
   try{
      . . . . . . .
      . . . . . . .
   }finally{
      httpresponse.close();
   }
}finally{
   httpclient.close();
}

Ejemplo

Siempre que cree / obtenga objetos como solicitud, flujo de respuesta, etc., inicie un bloque try finalmente en la siguiente línea, escriba el código restante dentro del try y cierre el objeto respectivo en el bloque finalmente como se demuestra en el siguiente programa:

import java.util.Scanner;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;

public class CloseConnectionExample {
   
   public static void main(String args[])throws Exception{
 
      //Create an HttpClient object
      CloseableHttpClient httpclient = HttpClients.createDefault();

      try{
         //Create an HttpGet object
         HttpGet httpget = new HttpGet("http://www.tutorialspoint.com/");

         //Execute the Get request
         CloseableHttpResponse httpresponse = httpclient.execute(httpget);

         try{
            Scanner sc = new Scanner(httpresponse.getEntity().getContent());
            while(sc.hasNext()) {
               System.out.println(sc.nextLine());
            }
         }finally{
            httpresponse.close();
         }
      }finally{
         httpclient.close();
      }
   }
}

Salida

Al ejecutar el programa anterior, se genera la siguiente salida:

<!DOCTYPE html>
<!--[if IE 8]><html class = "ie ie8"> <![endif]-->
<!--[if IE 9]><html class = "ie ie9"> <![endif]-->
<!--[if gt IE 9]><!-->
<html lang = "en-US"> <!--<![endif]-->
<head>
<!-- Basic -->
<meta charset = "utf-8">
<meta http-equiv = "X-UA-Compatible" content = "IE = edge">
<meta name = "viewport" content = "width = device-width,initial-scale = 1.0,userscalable = yes">
<link href = "https://cdn.muicss.com/mui-0.9.39/extra/mui-rem.min.css"
rel = "stylesheet" type = "text/css" />
<link rel = "stylesheet" href = "/questions/css/home.css?v = 3" />
<script src = "/questions/js/jquery.min.js"></script>
<script src = "/questions/js/fontawesome.js"></script>
<script src = "https://cdn.muicss.com/mui-0.9.39/js/mui.min.js"></script>
</head>
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . 
<script>
window.dataLayer = window.dataLayer || [];
function gtag() {dataLayer.push(arguments);}
gtag('js', new Date());
gtag('config', 'UA-232293-17');
</script>
</body>
</html>

Puede cancelar la solicitud HTTP actual utilizando el abort() método, es decir, después de invocar este método, en una solicitud en particular, se abortará su ejecución.

Si se invoca este método después de una ejecución, las respuestas de esa ejecución no se verán afectadas y las ejecuciones posteriores se cancelarán.

Ejemplo

Si observa el siguiente ejemplo, hemos creado una solicitud HttpGet, imprimimos el formato de solicitud utilizado utilizando el getMethod().

Luego, hemos realizado otra ejecución con la misma solicitud. Imprimió la línea de estado usando la ^1ª ejecución nuevamente. Finalmente, imprimió la línea de estado de la segunda ejecución.

Como se discutió, las respuestas de la ^primera ejecución (ejecución antes del método de aborto) se imprimen (incluida la segunda línea de estado que se escribe después del método de aborto) y, todas las ejecuciones posteriores de la solicitud actual después del método de aborto fallan invocando un excepción.

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;

public class HttpGetExample {
   public static void main(String args[]) throws Exception{
   
      //Creating an HttpClient object
      CloseableHttpClient httpclient = HttpClients.createDefault();

      //Creating an HttpGet object
      HttpGet httpget = new HttpGet("http://www.tutorialspoint.com/");

      //Printing the method used
      System.out.println(httpget.getMethod());
 
      //Executing the Get request
      HttpResponse httpresponse = httpclient.execute(httpget);

      //Printing the status line
      System.out.println(httpresponse.getStatusLine());

      httpget.abort();
      System.out.println(httpresponse.getEntity().getContentLength());
 
      //Executing the Get request
      HttpResponse httpresponse2 = httpclient.execute(httpget);
      System.out.println(httpresponse2.getStatusLine());
   }
}

Salida

Al ejecutarse, el programa anterior genera la siguiente salida:

On executing, the above program generates the following output.
GET
HTTP/1.1 200 OK
-1
Exception in thread "main" org.apache.http.impl.execchain.RequestAbortedException:
Request aborted
at org.apache.http.impl.execchain.MainClientExec.execute(MainClientExec.java:180)
at org.apache.http.impl.execchain.ProtocolExec.execute(ProtocolExec.java:185)
at org.apache.http.impl.execchain.RetryExec.execute(RetryExec.java:89)
at org.apache.http.impl.execchain.RedirectExec.execute(RedirectExec.java:110)
at org.apache.http.impl.client.InternalHttpClient.doExecute(InternalHttpClient.java:185)
at org.apache.http.impl.client.CloseableHttpClient.execute(CloseableHttpClient.java:83)
at org.apache.http.impl.client.CloseableHttpClient.execute(CloseableHttpClient.java:108)
at HttpGetExample.main(HttpGetExample.java:32)

Los interceptores son aquellos que ayudan a obstruir o cambiar solicitudes o respuestas. Los interceptores de protocolo en general actúan sobre un encabezado específico o un grupo de encabezados relacionados. La biblioteca HttpClient proporciona soporte para interceptores.

Solicitar interceptor

los HttpRequestInterceptorLa interfaz representa los interceptores de solicitudes. Esta interfaz contiene un método conocido como proceso en el que debe escribir el fragmento de código para interceptar las solicitudes.

En el lado del cliente, este método verifica / procesa las solicitudes antes de enviarlas al servidor y, en el lado del servidor, este método se ejecuta antes de evaluar el cuerpo de la solicitud.

Creando un interceptor de solicitudes

Puede crear un interceptor de solicitudes siguiendo los pasos que se indican a continuación.

Step 1 - Create an object of HttpRequestInterceptor

Cree un objeto de la interfaz HttpRequestInterceptor implementando su proceso de método abstracto.

HttpRequestInterceptor requestInterceptor = new HttpRequestInterceptor() {

@Override
 public void process(HttpRequest request, HttpContext context) throws
HttpException, IOException {
   //Method implementation . . . . .
};

Step 2 - Instantiate CloseableHttpClient object

Crea una personalizada CloseableHttpClient objeto agregando el interceptor creado anteriormente como se muestra a continuación:

//Creating a CloseableHttpClient object
CloseableHttpClient httpclient =
HttpClients.custom().addInterceptorFirst(requestInterceptor).build();

Con este objeto, puede realizar las ejecuciones de solicitudes como de costumbre.

Ejemplo

El siguiente ejemplo demuestra el uso de interceptores de solicitudes. En este ejemplo, hemos creado un objeto de solicitud HTTP GET y le hemos agregado tres encabezados: sample-header, demoheader y test-header.

En el processor()método del interceptor, estamos verificando los encabezados de la solicitud enviada; si alguno de esos encabezados essample-header, estamos intentando eliminarlo y mostrar la lista de encabezados de esa solicitud en particular.

import java.io.IOException;
import org.apache.http.Header;
import org.apache.http.HttpException;
import org.apache.http.HttpRequest;
import org.apache.http.HttpRequestInterceptor;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicHeader;
import org.apache.http.protocol.HttpContext;

public class InterceptorsExample {
 
   public static void main(String args[]) throws Exception{
      
      //Creating an HttpRequestInterceptor
      HttpRequestInterceptor requestInterceptor = new HttpRequestInterceptor() {
         @Override
         public void process(HttpRequest request, HttpContext context) throws
         HttpException, IOException {
            if(request.containsHeader("sample-header")) {
               System.out.println("Contains header sample-header, removing it..");
               request.removeHeaders("sample-header"); 
            }
            //Printing remaining list of headers
            Header[] headers= request.getAllHeaders();
            for (int i = 0; i<headers.length;i++) {
               System.out.println(headers[i].getName());
            }
         }
      };

      //Creating a CloseableHttpClient object
      CloseableHttpClient httpclient =
      HttpClients.custom().addInterceptorFirst(requestInterceptor).build();

      //Creating a request object
      HttpGet httpget1 = new HttpGet("https://www.tutorialspoint.com/");

      //Setting the header to it
      httpget1.setHeader(new BasicHeader("sample-header","My first header"));
      httpget1.setHeader(new BasicHeader("demo-header","My second header"));
      httpget1.setHeader(new BasicHeader("test-header","My third header"));

      //Executing the request
      HttpResponse httpresponse = httpclient.execute(httpget1);

      //Printing the status line
      System.out.println(httpresponse.getStatusLine());
   }
}

Salida

Al ejecutar el programa anterior, se genera la siguiente salida:

Contains header sample-header, removing it..
demo-header
test-header
HTTP/1.1 200 OK

Interceptor de respuesta

los HttpResponseInterceptorLa interfaz representa los interceptores de respuesta. Esta interfaz contiene un método conocido comoprocess(). En este método, debe escribir el fragmento de código para interceptar las respuestas.

En el lado del servidor, este método verifica / procesa la respuesta antes de enviarla al cliente, y en el lado del cliente, este método se ejecuta antes de evaluar el cuerpo de la respuesta.

Creando interceptor de respuesta

Puede crear un interceptor de respuesta siguiendo los pasos que se indican a continuación:

Step 1 - Create an object of HttpResponseInterceptor

Crea un objeto del HttpResponseInterceptor interfaz implementando su método abstracto process.

HttpResponseInterceptor responseInterceptor = new HttpResponseInterceptor() {
   @Override
   public void process(HttpResponse response, HttpContext context) throws HttpException, IOException {
      //Method implementation . . . . . . . .
   }
};

Paso 2: crear una instancia del objeto CloseableHttpClient

Crea una personalizada CloseableHttpClient objeto agregando el interceptor creado anteriormente, como se muestra a continuación:

//Creating a CloseableHttpClient object
CloseableHttpClient httpclient =
HttpClients.custom().addInterceptorFirst(responseInterceptor).build();

Con este objeto, puede realizar las ejecuciones de solicitudes como de costumbre.

Ejemplo

El siguiente ejemplo demuestra el uso de interceptores de respuesta. En este ejemplo, hemos agregado tres encabezados: sample-header, demo-header y test-header a la respuesta en el procesador.

Después de ejecutar la solicitud y obtener la respuesta, imprimimos los nombres de todos los encabezados de la respuesta utilizando el getAllHeaders() método.

Y en la salida, puede observar los nombres de tres encabezados en la lista.

import java.io.IOException;
import org.apache.http.Header;
import org.apache.http.HttpException;
import org.apache.http.HttpResponse;
import org.apache.http.HttpResponseInterceptor;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.protocol.HttpContext;

public class ResponseInterceptorsExample {

   public static void main(String args[]) throws Exception{
      
      //Creating an HttpRequestInterceptor
      HttpResponseInterceptor responseInterceptor = new HttpResponseInterceptor() {
         @Override
         public void process(HttpResponse response, HttpContext context) throws
         HttpException, IOException {
            System.out.println("Adding header sample_header, demo-header, test_header to the response");
            response.setHeader("sample-header", "My first header");
            response.setHeader("demo-header", "My second header");
            response.setHeader("test-header", "My third header"); 
         }
      };

      //Creating a CloseableHttpClient object
      CloseableHttpClient httpclient = HttpClients.custom().addInterceptorFirst(responseInterceptor).build();

      //Creating a request object
      HttpGet httpget1 = new HttpGet("https://www.tutorialspoint.com/");

      //Executing the request
      HttpResponse httpresponse = httpclient.execute(httpget1); 

      //Printing remaining list of headers
      Header[] headers = httpresponse.getAllHeaders();
 
      for (int i = 0; i<headers.length;i++) {
         System.out.println(headers[i].getName());
      }
   }
}

Salida

Al ejecutarse, el programa anterior genera el siguiente resultado:

On executing the above program generates the following output.
Adding header sample_header, demo-header, test_header to the response
Accept-Ranges
Access-Control-Allow-Headers
Access-Control-Allow-Origin
Cache-Control
Content-Type
Date
Expires
Last-Modified
Server
Vary
X-Cache
sample-header
demo-header
test-header

Usando HttpClient, puede conectarse a un sitio web que necesita nombre de usuario y contraseña. Este capítulo explica cómo ejecutar una solicitud de cliente en un sitio que solicita nombre de usuario y contraseña.

Paso 1: crear un objeto CredentialsProvider

los CredentialsProviderLa interfaz mantiene una colección para almacenar las credenciales de inicio de sesión del usuario. Puede crear su objeto instanciando elBasicCredentialsProvider class, la implementación predeterminada de esta interfaz.

CredentialsProvider credentialsPovider = new BasicCredentialsProvider();

Paso 2: establece las credenciales

Puede configurar las credenciales requeridas para el objeto CredentialsProvider usando el setCredentials() método.

Este método acepta dos objetos como se indica a continuación:

• AuthScope object - Alcance de autenticación que especifica los detalles como nombre de host, número de puerto y nombre del esquema de autenticación.

• Credentials object - Especificando las credenciales (nombre de usuario, contraseña).

Configure las credenciales con el setCredentials() método para host y proxy como se muestra a continuación -

credsProvider.setCredentials(new AuthScope("example.com", 80), 
   new UsernamePasswordCredentials("user", "mypass"));
credsProvider.setCredentials(new AuthScope("localhost", 8000), 
   new UsernamePasswordCredentials("abc", "passwd"));

Paso 3: crear un objeto HttpClientBuilder

Crear un HttpClientBuilder utilizando el custom() método del HttpClients clase.

//Creating the HttpClientBuilder
HttpClientBuilder clientbuilder = HttpClients.custom();

Paso 4: establece las credenciales

Puede configurar el objeto credentialsPovider creado anteriormente en un HttpClientBuilder usando el setDefaultCredentialsProvider() método.

Establezca el objeto CredentialProvider creado en el paso anterior al compilador de clientes pasándolo al CredentialsProvider object() método como se muestra a continuación.

clientbuilder = clientbuilder.setDefaultCredentialsProvider(credsProvider);

Paso 5: compila el CloseableHttpClient

Construye el CloseableHttpClient objeto usando el build() método del HttpClientBuilder clase.

CloseableHttpClient httpclient = clientbuilder.build()

Paso 6: crea un objeto HttpGet y ejecútalo

Cree un objeto HttpRequest creando una instancia de la clase HttpGet. Ejecute esta solicitud utilizando elexecute() método.

//Creating a HttpGet object
HttpGet httpget = new HttpGet("https://www.tutorialspoint.com/ ");

//Executing the Get request
HttpResponse httpresponse = httpclient.execute(httpget);

Ejemplo

A continuación se muestra un programa de ejemplo que demuestra la ejecución de una solicitud HTTP en un sitio de destino que requiere autenticación de usuario.

import org.apache.http.Header;
import org.apache.http.HttpResponse;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.Credentials;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;

public class UserAuthenticationExample {
   
   public static void main(String args[]) throws Exception{
      
      //Create an object of credentialsProvider
      CredentialsProvider credentialsPovider = new BasicCredentialsProvider();

      //Set the credentials
      AuthScope scope = new AuthScope("https://www.tutorialspoint.com/questions/", 80);
      
      Credentials credentials = new UsernamePasswordCredentials("USERNAME", "PASSWORD");
      credentialsPovider.setCredentials(scope,credentials);

      //Creating the HttpClientBuilder
      HttpClientBuilder clientbuilder = HttpClients.custom();

      //Setting the credentials
      clientbuilder = clientbuilder.setDefaultCredentialsProvider(credentialsPovider);

      //Building the CloseableHttpClient object
      CloseableHttpClient httpclient = clientbuilder.build();

      //Creating a HttpGet object
      HttpGet httpget = new HttpGet("https://www.tutorialspoint.com/questions/index.php");

      //Printing the method used
      System.out.println(httpget.getMethod()); 

      //Executing the Get request
      HttpResponse httpresponse = httpclient.execute(httpget);

      //Printing the status line
      System.out.println(httpresponse.getStatusLine());
      int statusCode = httpresponse.getStatusLine().getStatusCode();
      System.out.println(statusCode);

      Header[] headers= httpresponse.getAllHeaders();
      for (int i = 0; i<headers.length;i++) {
         System.out.println(headers[i].getName());
      }
   }
}

Salida

Al ejecutarse, el programa anterior genera la siguiente salida.

GET
HTTP/1.1 200 OK
200

Un servidor proxy es un servidor intermediario entre el cliente e Internet. Los servidores proxy ofrecen las siguientes funcionalidades básicas:

• Filtrado de datos de red y firewall

• Compartir conexión de red

• Almacenamiento en caché de datos

Con la biblioteca HttpClient, puede enviar una solicitud HTTP mediante un proxy. Siga los pasos que se indican a continuación:

Paso 1: crea un objeto HttpHost

Instancia del HttpHost clase de la org.apache.http paquete pasando un parámetro de cadena que representa el nombre del servidor proxy (desde el cual necesita que se envíen las solicitudes) a su constructor.

//Creating an HttpHost object for proxy
HttpHost proxyHost = new HttpHost("localhost");

De la misma manera, cree otro objeto HttpHost para representar el host de destino al que se deben enviar las solicitudes.

//Creating an HttpHost object for target
HttpHost targetHost = new HttpHost("google.com");

Paso 2: crea un objeto HttpRoutePlanner

los HttpRoutePlannerLa interfaz calcula una ruta a un host especificado. Cree un objeto de esta interfaz instanciando elDefaultProxyRoutePlannerclass, una implementación de esta interfaz. Como parámetro para su constructor, pase el host proxy creado anteriormente:

//creating a RoutePlanner object
HttpRoutePlanner routePlanner = new DefaultProxyRoutePlanner(proxyhost);

Paso 3: configure el planificador de rutas para un creador de clientes

Utilizando el custom() método del HttpClients clase, crea una HttpClientBuilder objeto y, en este objeto, establezca el planificador de ruta creado anteriormente, utilizando el setRoutePlanner() método.

//Setting the route planner to the HttpClientBuilder object
HttpClientBuilder clientBuilder = HttpClients.custom();

clientBuilder = clientBuilder.setRoutePlanner(routePlanner);

Paso 4: compila el objeto CloseableHttpClient

Construye el CloseableHttpClient objeto llamando al build() método.

//Building a CloseableHttpClient
CloseableHttpClient httpClient = clientBuilder.build();

Paso 5 - Crea un HttpGetobject

Cree una solicitud HTTP GET creando una instancia del HttpGet clase.

//Creating an HttpGet object
HttpGet httpGet = new HttpGet("/");

Paso 6: ejecutar la solicitud

Una de las variantes del execute() el método acepta un HttpHost y HttpRequestobjetos y ejecuta la solicitud. Ejecute la solicitud utilizando este método:

//Executing the Get request
HttpResponse httpResponse = httpclient.execute(targetHost, httpGet);

Ejemplo

El siguiente ejemplo demuestra cómo enviar una solicitud HTTP a un servidor a través de un proxy. En este ejemplo, estamos enviando una solicitud HTTP GET a google.com a través de localhost. Hemos impreso los encabezados de la respuesta y el cuerpo de la respuesta.

import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.routing.HttpRoutePlanner;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.DefaultProxyRoutePlanner;
import org.apache.http.util.EntityUtils;

public class RequestViaProxyExample {

   public static void main(String args[]) throws Exception{
 
      //Creating an HttpHost object for proxy
      HttpHost proxyhost = new HttpHost("localhost");

      //Creating an HttpHost object for target
      HttpHost targethost = new HttpHost("google.com");
 
      //creating a RoutePlanner object
      HttpRoutePlanner routePlanner = new DefaultProxyRoutePlanner(proxyhost);

      //Setting the route planner to the HttpClientBuilder object
      HttpClientBuilder clientBuilder = HttpClients.custom();
      clientBuilder = clientBuilder.setRoutePlanner(routePlanner);

      //Building a CloseableHttpClient
      CloseableHttpClient httpclient = clientBuilder.build();

      //Creating an HttpGet object
      HttpGet httpget = new HttpGet("/");

      //Executing the Get request
      HttpResponse httpresponse = httpclient.execute(targethost, httpget);

      //Printing the status line
      System.out.println(httpresponse.getStatusLine());

      //Printing all the headers of the response
      Header[] headers = httpresponse.getAllHeaders();
 
      for (int i = 0; i < headers.length; i++) {
         System.out.println(headers[i]);
      }
      
      //Printing the body of the response
      HttpEntity entity = httpresponse.getEntity();

      if (entity != null) {
         System.out.println(EntityUtils.toString(entity));
      }
   }
}

Salida

Al ejecutarse, el programa anterior genera la siguiente salida:

HTTP/1.1 200 OK
Date: Sun, 23 Dec 2018 10:21:47 GMT
Server: Apache/2.4.9 (Win64) PHP/5.5.13
Last-Modified: Tue, 24 Jun 2014 10:46:24 GMT
ETag: "2e-4fc92abc3c000"
Accept-Ranges: bytes
Content-Length: 46
Content-Type: text/html
<html><body><h1>It works!</h1></body></html>

En este capítulo, aprenderemos cómo crear una HttpRequest autenticada usando un nombre de usuario y contraseña y un túnel a través de un proxy a un host de destino, usando un ejemplo.

Paso 1: crear un objeto CredentialsProvider

La interfaz CredentialsProvider mantiene una colección para contener las credenciales de inicio de sesión del usuario. Puede crear su objeto creando una instancia de la clase BasicCredentialsProvider, la implementación predeterminada de esta interfaz.

CredentialsProvider credentialsPovider = new BasicCredentialsProvider();

Paso 2: establece las credenciales

Puede configurar las credenciales requeridas para el objeto CredentialsProvider usando el setCredentials()método. Este método acepta dos objetos:

• AuthScope object - Alcance de autenticación que especifica los detalles como nombre de host, número de puerto y nombre del esquema de autenticación.

• Credentials object- Especificando las credenciales (nombre de usuario, contraseña). Configure las credenciales con elsetCredentials() método para el host y el proxy como se muestra a continuación.

credsProvider.setCredentials(new AuthScope("example.com", 80), new
   UsernamePasswordCredentials("user", "mypass"));
credsProvider.setCredentials(new AuthScope("localhost", 8000), new
   UsernamePasswordCredentials("abc", "passwd"));

Paso 3: crea un objeto HttpClientBuilder

Crear un HttpClientBuilder utilizando el custom() método del HttpClients clase como se muestra a continuación -

//Creating the HttpClientBuilder
HttpClientBuilder clientbuilder = HttpClients.custom();

Paso 4: establecer el proveedor de credenciales

Puede establecer el objeto CredentialsProvider en un objeto HttpClientBuilder utilizando el setDefaultCredentialsProvider()método. Pasar el creado previamenteCredentialsProvider objetar este método.

clientbuilder = clientbuilder.setDefaultCredentialsProvider(credsProvider);

Paso 5: compila el CloseableHttpClient

Construye el CloseableHttpClient objeto usando el build() método.

CloseableHttpClient httpclient = clientbuilder.build();

Paso 6: cree el proxy y los hosts de destino

Cree los hosts de destino y proxy creando instancias de HttpHost clase.

//Creating the target and proxy hosts
HttpHost target = new HttpHost("example.com", 80, "http");
HttpHost proxy = new HttpHost("localhost", 8000, "http");

Paso 7: configura el proxy y crea un objeto RequestConfig

Crear un RequestConfig.Builder objeto usando el custom()método. Establezca el objeto proxyHost creado anteriormente en elRequestConfig.Builder utilizando el setProxy()método. Finalmente, construya elRequestConfig objeto usando el build() método.

RequestConfig.Builder reqconfigconbuilder= RequestConfig.custom();
reqconfigconbuilder = reqconfigconbuilder.setProxy(proxyHost);
RequestConfig config = reqconfigconbuilder.build();

Paso 8: cree un objeto de solicitud HttpGet y establezca el objeto de configuración en él.

Crear un HttpGetobjeto creando una instancia de la clase HttpGet. Establezca el objeto de configuración creado en el paso anterior a este objeto usando elsetConfig() método.

//Create the HttpGet request object
HttpGet httpGet = new HttpGet("/");

//Setting the config to the request
httpget.setConfig(config);

Paso 9: ejecutar la solicitud

Ejecute la solicitud pasando el objeto HttpHost (destino) y la solicitud (HttpGet) como parámetros al execute() método.

HttpResponse httpResponse = httpclient.execute(targetHost, httpget);

Ejemplo

El siguiente ejemplo demuestra cómo ejecutar una solicitud HTTP a través de un proxy utilizando un nombre de usuario y una contraseña.

import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;

public class ProxyAuthenticationExample {
   public static void main(String[] args) throws Exception {

      //Creating the CredentialsProvider object
      CredentialsProvider credsProvider = new BasicCredentialsProvider();

      //Setting the credentials
      credsProvider.setCredentials(new AuthScope("example.com", 80), 
         new UsernamePasswordCredentials("user", "mypass"));
      credsProvider.setCredentials(new AuthScope("localhost", 8000), 
         new UsernamePasswordCredentials("abc", "passwd"));

      //Creating the HttpClientBuilder
      HttpClientBuilder clientbuilder = HttpClients.custom();

      //Setting the credentials
      clientbuilder = clientbuilder.setDefaultCredentialsProvider(credsProvider);
      
      //Building the CloseableHttpClient object
      CloseableHttpClient httpclient = clientbuilder.build();


      //Create the target and proxy hosts
      HttpHost targetHost = new HttpHost("example.com", 80, "http");
      HttpHost proxyHost = new HttpHost("localhost", 8000, "http");

      //Setting the proxy
      RequestConfig.Builder reqconfigconbuilder= RequestConfig.custom();
      reqconfigconbuilder = reqconfigconbuilder.setProxy(proxyHost);
      RequestConfig config = reqconfigconbuilder.build();

      //Create the HttpGet request object
      HttpGet httpget = new HttpGet("/");

      //Setting the config to the request
      httpget.setConfig(config);
 
      //Printing the status line
      HttpResponse response = httpclient.execute(targetHost, httpget);
      System.out.println(response.getStatusLine());

   }
}

Salida

Al ejecutarse, el programa anterior genera la siguiente salida:

HTTP/1.1 200 OK

Usando la biblioteca HttpClient, puede enviar una solicitud o iniciar sesión en un formulario pasando parámetros.

Siga los pasos que se indican a continuación para iniciar sesión en un formulario.

Paso 1: crea un objeto HttpClient

los createDefault() método del HttpClients clase devuelve un objeto de la clase CloseableHttpClient, que es la implementación base de la interfaz HttpClient. Usando este método, cree un objeto HttpClient -

CloseableHttpClient httpClient = HttpClients.createDefault();

Paso 2: crear un objeto RequestBuilder

La clase RequestBuilderse utiliza para crear una solicitud añadiéndole parámetros. Si el tipo de solicitud es PUT o POST, agrega los parámetros a la solicitud como entidad codificada en URL

Cree un objeto RequestBuilder (de tipo POST) utilizando el método post ().

//Building the post request object
RequestBuilder reqbuilder = RequestBuilder.post();

Paso 3: establezca la Uri y los parámetros en RequestBuilder.

Establezca el URI y los parámetros en el objeto RequestBuilder utilizando el setUri() y addParameter() métodos de la clase RequestBuilder.

//Set URI and parameters
RequestBuilder reqbuilder = reqbuilder.setUri("http://httpbin.org/post");
reqbuilder = reqbuilder1.addParameter("Name", "username").addParameter("password", "password");

Paso 4: compila el objeto HttpUriRequest

Después de configurar los parámetros requeridos, cree el HttpUriRequest objeto usando el build() método.

//Building the HttpUriRequest object
HttpUriRequest httppost = reqbuilder2.build();

Paso 5: ejecutar la solicitud

El método de ejecución del objeto CloseableHttpClient acepta un objeto HttpUriRequest (interfaz) (es decir, HttpGet, HttpPost, HttpPut, HttpHead, etc.) y devuelve un objeto de respuesta.

Ejecute el HttpUriRequest creado en los pasos anteriores pasándolo al execute() método.

//Execute the request
HttpResponse httpresponse = httpclient.execute(httppost);

Ejemplo

El siguiente ejemplo demuestra cómo iniciar sesión en un formulario enviando credenciales de inicio de sesión. Aquí, hemos enviado dos parámetros:username and password a un formulario e intentó imprimir la entidad del mensaje y el estado de la solicitud.

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.methods.RequestBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import java.io.IOException;
import java.net.URISyntaxException;

public class FormLoginExample {
 
   public static void main(String args[]) throws Exception {

      //Creating CloseableHttpClient object
      CloseableHttpClient httpclient = HttpClients.createDefault();
 
      //Creating the RequestBuilder object
      RequestBuilder reqbuilder = RequestBuilder.post();

      //Setting URI and parameters
      RequestBuilder reqbuilder1 = reqbuilder.setUri("http://httpbin.org/post");
      RequestBuilder reqbuilder2 = reqbuilder1.addParameter("Name", 
         "username").addParameter("password", "password");

      //Building the HttpUriRequest object
      HttpUriRequest httppost = reqbuilder2.build();

      //Executing the request
      HttpResponse httpresponse = httpclient.execute(httppost);

      //Printing the status and the contents of the response
      System.out.println(EntityUtils.toString(httpresponse.getEntity()));
      System.out.println(httpresponse.getStatusLine());
   }
}

Salida

Al ejecutarse, el programa anterior genera la siguiente salida:

{
   "args": {},
   "data": "",
   "files": {},
   "form": {
      "Name": "username",
      "password": "password"
   },
   "headers": {
      "Accept-Encoding": "gzip,deflate",
      "Connection": "close",
      "Content-Length": "31",
      "Content-Type": "application/x-www-form-urlencoded; charset = UTF-8",
      "Host": "httpbin.org",
      "User-Agent": "Apache-HttpClient/4.5.6 (Java/1.8.0_91)"
   },
   "json": null,
   "origin": "117.216.245.180",
   "url": "http://httpbin.org/post"
}
HTTP/1.1 200 OK

Formulario de inicio de sesión con cookies

Si su formulario almacena cookies, en lugar de crear predeterminadas CloseableHttpClient objeto.

Create a CookieStore object creando una instancia de la clase BasicCookieStore.

//Creating a BasicCookieStore object
BasicCookieStore cookieStore = new BasicCookieStore();

Create a HttpClientBuilder utilizando el custom() método del HttpClients clase.

//Creating an HttpClientBuilder object
HttpClientBuilder clientbuilder = HttpClients.custom();

Set the cookie store to the client builder utilizando el método setDefaultCookieStore ().

//Setting default cookie store to the client builder object
Clientbuilder = clientbuilder.setDefaultCookieStore(cookieStore);

Construye el CloseableHttpClient objeto usando el build() método.

//Building the CloseableHttpClient object
CloseableHttpClient httpclient = clientbuilder1.build();

Construye el HttpUriRequest objeto como se especificó anteriormente pasando ejecutar la solicitud.

Si la página almacena cookies, los parámetros que ha pasado se agregarán al almacén de cookies.

Puede imprimir el contenido del CookieStore objeto donde puedes ver tus parámetros (junto con los anteriores la página almacenada en el caso).

Para imprimir las cookies, obtenga todas las cookies del CookieStore objeto usando el getCookies()método. Este método devuelve unListobjeto. Usando Iterator, imprima el contenido de los objetos de la lista como se muestra a continuación:

//Printing the cookies
List list = cookieStore.getCookies();

System.out.println("list of cookies");
Iterator it = list.iterator();
if(it.hasNext()) {
   System.out.println(it.next());
}

Las cookies son archivos de texto almacenados en la computadora del cliente y se guardan para varios propósitos de rastreo de información.

HttpClient proporciona soporte para cookies que puede crear y administrar cookies.

Creando una cookie

Siga los pasos que se indican a continuación para crear una cookie usando la biblioteca HttpClient.

Paso 1: crear un objeto Cookiestore

los CookieStoreLa interfaz representa el almacén abstracto de los objetos Cookie. Puede crear una tienda de cookies instanciando elBasicCookieStore class, una implementación predeterminada de esta interfaz.

//Creating the CookieStore object
CookieStore cookieStore = new BasicCookieStore();

Paso 2: crear el objeto ClientCookie

Además de las funcionalidades de una cookie, ClientCookie puede obtener las cookies originales en el servidor. Puede crear una cookie de cliente instanciando elBasicClientCookieclase. Al constructor de esta clase, debe pasar el par clave-valor que desea almacenar en esa cookie en particular.

//Creating client cookie
BasicClientCookie clientCookie = new BasicClientCookie("name","Raju");

Paso 3: establecer valores para la cookie

Para una cookie de cliente, puede establecer / eliminar ruta, valor, versión, fecha de caducidad, dominio, comentario y atributo utilizando los métodos respectivos.

Calendar myCal = new GregorianCalendar(2018, 9, 26);
Date expiryDate = myCal.getTime();
clientcookie.setExpiryDate(expiryDate);
clientcookie.setPath("/");
clientcookie.setSecure(true);
clientcookie.setValue("25");
clientcookie.setVersion(5);

Paso 4: agregue cookies a la tienda de cookies

Puede agregar cookies a la tienda de cookies usando el addCookie() método del BasicCookieStore clase.

Agregue las cookies requeridas al Cookiestore.

//Adding the created cookies to cookie store
cookiestore.addCookie(clientcookie);

Ejemplo

El siguiente ejemplo demuestra cómo crear cookies y agregarlas a una tienda de cookies. Aquí, creamos un almacén de cookies, un montón de cookies estableciendo los valores de dominio y ruta, y los agregamos al almacén de cookies.

import org.apache.http.client.CookieStore;
import org.apache.http.impl.client.BasicCookieStore;
import org.apache.http.impl.cookie.BasicClientCookie;

public class CookieHandlingExample {
   
   public static void main(String args[]) throws Exception{
      
      //Creating the CookieStore object
      CookieStore cookiestore = new BasicCookieStore();
 
      //Creating client cookies
      BasicClientCookie clientcookie1 = new BasicClientCookie("name","Raju");
      BasicClientCookie clientcookie2 = new BasicClientCookie("age","28");
      BasicClientCookie clientcookie3 = new BasicClientCookie("place","Hyderabad");

      //Setting domains and paths to the created cookies
      clientcookie1.setDomain(".sample.com");
      clientcookie2.setDomain(".sample.com");
      clientcookie3.setDomain(".sample.com");

      clientcookie1.setPath("/");
      clientcookie2.setPath("/");
      clientcookie3.setPath("/");
 
      //Adding the created cookies to cookie store
      cookiestore.addCookie(clientcookie1);
      cookiestore.addCookie(clientcookie2);
      cookiestore.addCookie(clientcookie3);
   }
}

Recuperando una cookie

Puede agregar las cookies a una tienda de cookies usando getCookies() método del asicCookieStoreclase. Este método devuelve una lista que contiene todas las cookies en el almacén de cookies.

Puede imprimir el contenido de una tienda de cookies utilizando el Iterador como se muestra a continuación:

//Retrieving the cookies
List list = cookieStore.getCookies();

//Creating an iterator to the obtained list
Iterator it = list.iterator();
while(it.hasNext()) {
   System.out.println(it.next());
}

Ejemplo

El siguiente ejemplo demuestra cómo recuperar cookies de una tienda de cookies. Aquí, agregamos un montón de cookies a un almacén de cookies y las recuperamos.

import org.apache.http.client.CookieStore;
import org.apache.http.impl.client.BasicCookieStore;
import org.apache.http.impl.cookie.BasicClientCookie;

public class CookieHandlingExample {
 
   public static void main(String args[]) throws Exception{
      
      //Creating the CookieStore object
      CookieStore cookiestore = new BasicCookieStore();
      
      //Creating client cookies
      BasicClientCookie clientcookie1 = new BasicClientCookie("name","Raju");
      BasicClientCookie clientcookie2 = new BasicClientCookie("age","28");
      BasicClientCookie clientcookie3 = new BasicClientCookie("place","Hyderabad");

      //Setting domains and paths to the created cookies
      clientcookie1.setDomain(".sample.com");
      clientcookie2.setDomain(".sample.com");
      clientcookie3.setDomain(".sample.com");

      clientcookie1.setPath("/");
      clientcookie2.setPath("/");
      clientcookie3.setPath("/");
 
      //Adding the created cookies to cookie store
      cookiestore.addCookie(clientcookie1);
      cookiestore.addCookie(clientcookie2);
      cookiestore.addCookie(clientcookie3);
   }
}

Salida

Al ejecutarse, este programa genera la siguiente salida:

[version: 0][name: age][value: 28][domain: .sample.com][path: /][expiry: null]
[version: 0][name: name][value: Raju][domain: my.example.com][path: /][expiry:
null]
[version: 0][name: place][value: Hyderabad][domain: .sample.com][path:
/][expiry: null]

Un programa de subprocesos múltiples contiene dos o más partes que pueden ejecutarse simultáneamente y cada parte puede manejar una tarea diferente al mismo tiempo haciendo un uso óptimo de los recursos disponibles.

Puede ejecutar solicitudes de varios subprocesos escribiendo un programa HttpClient multiproceso.

Si desea ejecutar varias solicitudes de clientes desde subprocesos de forma consecutiva, debe crear un ClientConnectionPoolManager. Mantiene una piscina deHttpClientConnections y atiende múltiples solicitudes de subprocesos.

El administrador de conexiones agrupa las conexiones según la ruta. Si el administrador tiene conexiones para una ruta en particular, entonces atiende nuevas solicitudes en esas rutas alquilando una conexión existente del grupo, en lugar de crear una nueva.

Siga los pasos para ejecutar solicitudes de varios subprocesos:

Paso 1: creación del administrador del grupo de conexiones del cliente

Cree el administrador del grupo de conexiones del cliente instalando el PoolingHttpClientConnectionManager clase.

PoolingHttpClientConnectionManager connManager = new
   PoolingHttpClientConnectionManager();

Paso 2: establece el número máximo de conexiones

Establezca el número máximo de conexiones en el grupo mediante el setMaxTotal() método.

//Set the maximum number of connections in the pool
connManager.setMaxTotal(100);

Paso 3: crear un objeto ClientBuilder

Crear un ClientBuilder Objeto configurando el administrador de conexiones usando el setConnectionManager() método como se muestra a continuación -

HttpClientBuilder clientbuilder =
HttpClients.custom().setConnectionManager(connManager);

Paso 4: crear los objetos de solicitud HttpGet

Cree una instancia de la clase HttpGet pasando el URI deseado a su constructor como parámetro.

HttpGet httpget1 = new HttpGet("URI1");
HttpGet httpget2 = new HttpGet("URI2");
. . . . . . . . . . . .

Paso 5: implementación del método de ejecución

Asegúrese de haber creado una clase, convertirla en un hilo (ya sea extendiendo la clase del hilo o implementando la interfaz Runnable) e implementado el método de ejecución.

public class ClientMultiThreaded extends Thread {
   public void run() {
      //Run method implementation . . . . . . . . . .
   }
}

Paso 6: crear objetos Thread

Cree objetos de hilo creando una instancia de la clase Thread (ClientMultiThreaded) creada anteriormente.

Pase un objeto HttpClient, el objeto HttpGet respectivo y un número entero que represente el ID a estos hilos.

ClientMultiThreaded thread1 = new ClientMultiThreaded(httpclient,httpget1, 1);
ClientMultiThreaded thread2 = new ClientMultiThreaded(httpclient,httpget2, 2);
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Paso 7: inicia y une los hilos

Inicie todos los hilos usando start() método y únete a ellos usando la combinación method().

thread1.start();
thread2.start();
. . . . . . . .
thread1.join();
thread2.join();
. . . . . . . . . . . .

Paso 8: ejecutar la implementación del método

Dentro del método de ejecución, ejecute la solicitud, recupere la respuesta e imprima los resultados.

Ejemplo

El siguiente ejemplo demuestra la ejecución de solicitudes HTTP simultáneamente desde múltiples subprocesos. En este ejemplo, intentamos ejecutar varias solicitudes de varios subprocesos e intentamos imprimir el estado y la cantidad de bytes leídos por cada cliente.

import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.util.EntityUtils;

public class ClientMultiThreaded extends Thread {
   CloseableHttpClient httpClient;
   HttpGet httpget;
   int id;
 
   public ClientMultiThreaded(CloseableHttpClient httpClient, HttpGet httpget,
   int id) {
      this.httpClient = httpClient;
      this.httpget = httpget;
      this.id = id;
   }
   @Override
   public void run() {
      try{
         //Executing the request
         CloseableHttpResponse httpresponse = httpClient.execute(httpget);

         //Displaying the status of the request.
         System.out.println("status of thread "+id+":"+httpresponse.getStatusLine());

         //Retrieving the HttpEntity and displaying the no.of bytes read
         HttpEntity entity = httpresponse.getEntity();
         if (entity != null) {
            System.out.println("Bytes read by thread thread "+id+":
               "+EntityUtils.toByteArray(entity).length);
         }
      }catch(Exception e) {
         System.out.println(e.getMessage());
      }
   }
      
   public static void main(String[] args) throws Exception {

      //Creating the Client Connection Pool Manager by instantiating the PoolingHttpClientConnectionManager class.
      PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager();

      //Set the maximum number of connections in the pool
      connManager.setMaxTotal(100);

      //Create a ClientBuilder Object by setting the connection manager
      HttpClientBuilder clientbuilder = HttpClients.custom().setConnectionManager(connManager);
 
      //Build the CloseableHttpClient object using the build() method.
      CloseableHttpClient httpclient = clientbuilder.build();

      //Creating the HttpGet requests
      HttpGet httpget1 = new HttpGet("http://www.tutorialspoint.com/");
      HttpGet httpget2 = new HttpGet("http://www.google.com/");
      HttpGet httpget3 = new HttpGet("https://www.qries.com/");
      HttpGet httpget4 = new HttpGet("https://in.yahoo.com/");
 
      //Creating the Thread objects
      ClientMultiThreaded thread1 = new ClientMultiThreaded(httpclient,httpget1, 1);
      ClientMultiThreaded thread2 = new ClientMultiThreaded(httpclient,httpget2, 2);
      ClientMultiThreaded thread3 = new ClientMultiThreaded(httpclient,httpget3, 3);
      ClientMultiThreaded thread4 = new ClientMultiThreaded(httpclient,httpget4, 4);

      //Starting all the threads
      thread1.start();
      thread2.start();
      thread3.start();
      thread4.start();

      //Joining all the threads
      thread1.join();
      thread2.join();
      thread3.join();
      thread4.join();
   }
}

Salida

Al ejecutarse, el programa anterior genera la siguiente salida:

status of thread 1: HTTP/1.1 200 OK
Bytes read by thread thread 1: 36907
status of thread 2: HTTP/1.1 200 OK
Bytes read by thread thread 2: 13725
status of thread 3: HTTP/1.1 200 OK
Bytes read by thread thread 3: 17319
status of thread 4: HTTP/1.1 200 OK
Bytes read by thread thread 4: 127018

Con Secure Socket Layer, puede establecer una conexión segura entre el cliente y el servidor. Ayuda a proteger información confidencial como números de tarjetas de crédito, nombres de usuario, contraseñas, pines, etc.

Puede hacer que las conexiones sean más seguras creando su propio contexto SSL usando el HttpClient biblioteca.

Siga los pasos que se indican a continuación para personalizar SSLContext utilizando la biblioteca HttpClient:

Paso 1: crear un objeto SSLContextBuilder

SSLContextBuilderes el constructor de los objetos SSLContext. Crea su objeto usando elcustom() método del SSLContexts clase.

//Creating SSLContextBuilder object
SSLContextBuilder SSLBuilder = SSLContexts.custom();

Paso 2: carga el almacén de claves

En el camino Java_home_directory/jre/lib/security/, puede encontrar un archivo llamado cacerts. Guárdelo como su archivo de almacén de claves (con extensión .jks). Cargue el archivo del almacén de claves y su contraseña (que eschangeit por defecto) usando el loadTrustMaterial() método del SSLContextBuilder clase.

//Loading the Keystore file
File file = new File("mykeystore.jks");
SSLBuilder = SSLBuilder.loadTrustMaterial(file, "changeit".toCharArray());

Paso 3: construye un objeto SSLContext

Un objeto SSLContext representa una implementación de protocolo de socket seguro. Construya un SSLContext usando elbuild() método.

//Building the SSLContext
SSLContext sslContext = SSLBuilder.build();

Paso 4: creación del objeto SSLConnectionSocketFactory

SSLConnectionSocketFactoryes una fábrica de sockets en capas para conexiones TSL y SSL. Con esto, puede verificar el servidor Https usando una lista de certificados confiables y autenticar el servidor Https dado.

Puede crear esto de muchas formas. Dependiendo de la forma en que cree unSSLConnectionSocketFactory objeto, puede permitir todos los hosts, permitir solo certificados autofirmados, permitir solo protocolos particulares, etc.

To allow only particular protocols, crear SSLConnectionSocketFactory al pasar un objeto SSLContext, la matriz de cadenas que representa los protocolos debe ser compatible, la matriz de cadenas que representa los trajes de cifrado debe ser compatible y un objeto HostnameVerifier a su constructor.

new SSLConnectionSocketFactory(sslcontext, new String[]{"TLSv1"}, null,    
   SSLConnectionSocketFactory.getDefaultHostnameVerifier());

To allow all hosts, crear SSLConnectionSocketFactory objeto pasando un objeto SSLContext y un NoopHostnameVerifier objeto.

//Creating SSLConnectionSocketFactory SSLConnectionSocketFactory object
SSLConnectionSocketFactory sslConSocFactory = new SSLConnectionSocketFactory(sslcontext, new NoopHostnameVerifier());

Paso 5: crea un objeto HttpClientBuilder

Cree un objeto HttpClientBuilder usando el custom() método del HttpClients clase.

//Creating HttpClientBuilder
HttpClientBuilder clientbuilder = HttpClients.custom();

Paso 6: establecer el objeto SSLConnectionSocketFactory

Establezca el objeto SSLConnectionSocketFactory en el HttpClientBuilder utilizando el setSSLSocketFactory() método.

//Setting the SSLConnectionSocketFactory
clientbuilder = clientbuilder.setSSLSocketFactory(sslConSocFactory);

Paso 7: compila el objeto CloseableHttpClient

Construye el CloseableHttpClient objeto llamando al build() método.

//Building the CloseableHttpClient
CloseableHttpClient httpclient = clientbuilder.build();

Paso 8: crea un objeto HttpGet

los HttpGet class representa la solicitud HTTP GET que recupera la información del servidor dado usando un URI.

Cree una solicitud HTTP GET creando una instancia de la clase HttpGet pasando una cadena que represente el URI.

//Creating the HttpGet request
HttpGet httpget = new HttpGet("https://example.com/");

Paso 9: ejecutar la solicitud

Ejecute la solicitud usando el execute() método.

//Executing the request
HttpResponse httpresponse = httpclient.execute(httpget);

Ejemplo

El siguiente ejemplo demuestra la personalización de SSLContrext:

import java.io.File;
import javax.net.ssl.SSLContext;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.util.EntityUtils;

public class ClientCustomSSL {
   
   public final static void main(String[] args) throws Exception {

      //Creating SSLContextBuilder object
      SSLContextBuilder SSLBuilder = SSLContexts.custom();
  
      //Loading the Keystore file
      File file = new File("mykeystore.jks");
      SSLBuilder = SSLBuilder.loadTrustMaterial(file,
         "changeit".toCharArray());

      //Building the SSLContext usiong the build() method
      SSLContext sslcontext = SSLBuilder.build();
 
      //Creating SSLConnectionSocketFactory object
      SSLConnectionSocketFactory sslConSocFactory = new SSLConnectionSocketFactory(sslcontext, new NoopHostnameVerifier());
 
      //Creating HttpClientBuilder
      HttpClientBuilder clientbuilder = HttpClients.custom();

      //Setting the SSLConnectionSocketFactory
      clientbuilder = clientbuilder.setSSLSocketFactory(sslConSocFactory);

      //Building the CloseableHttpClient
      CloseableHttpClient httpclient = clientbuilder.build();
      
      //Creating the HttpGet request
      HttpGet httpget = new HttpGet("https://example.com/");
 
      //Executing the request
      HttpResponse httpresponse = httpclient.execute(httpget);

      //printing the status line
      System.out.println(httpresponse.getStatusLine());

      //Retrieving the HttpEntity and displaying the no.of bytes read
      HttpEntity entity = httpresponse.getEntity();
      if (entity != null) {
         System.out.println(EntityUtils.toByteArray(entity).length);
      } 
   }
}

Salida

Al ejecutarse, el programa anterior genera la siguiente salida.

HTTP/1.1 200 OK
1270

Usando HttpClient, podemos realizar cargas multiparte, es decir, podemos cargar objetos más grandes en partes más pequeñas. En este capítulo, demostramos la carga de varias partes en el cliente HTTP cargando un archivo de texto simple.

En general, cualquier carga de varias partes contiene tres partes.

• Inicio de la carga

• Subiendo las partes del objeto

• Completando la carga multiparte

Para la carga de varias partes usando HttpClient, debemos seguir los pasos a continuación:

• Cree un constructor de varias partes.

• Agregue las partes deseadas.

• Complete la compilación y obtenga una HttpEntity de varias partes.

• Solicitud de compilación configurando la entidad de varias partes anterior.

• Ejecute la solicitud.

Los siguientes son los pasos para cargar una entidad multiparte usando la biblioteca HttpClient.

Paso 1: crea un objeto HttpClient

los createDefault() método del HttpClients clase devuelve un objeto de la clase CloseableHttpClient, que es la implementación base de la interfaz HttpClient. Usando este método, cree un objeto HttpClient -

//Creating CloseableHttpClient object
CloseableHttpClient httpclient = HttpClients.createDefault();

Paso 2: crea un objeto FileBody

FileBodyclass representa la parte del cuerpo binario respaldada por un archivo. Cree una instancia de esta clase pasando unFile objeto y un ContentType objeto que representa el tipo de contenido.

//Creating a File object
File file = new File("sample.txt");

//Creating the FileBody object
FileBody filebody = new FileBody(file, ContentType.DEFAULT_BINARY);

Paso 3: crear un MultipartEntityBuilder

los MultipartEntityBuilder la clase se usa para construir el multiparte HttpEntityobjeto. Crea su objeto usando elcreate() método (de la misma clase).

//Creating the MultipartEntityBuilder
MultipartEntityBuilder entitybuilder = MultipartEntityBuilder.create();

Paso 4: establece el modo

UN MultipartEntityBuildertiene tres modos: STRICT, RFC6532 y BROWSER_COMPATIBLE. Configúrelo en el modo deseado utilizando elsetMode() método.

//Setting the mode
entitybuilder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);

Paso 5: agregue varias partes deseadas

Usando los métodos addTextBody(), addPart () y, addBinaryBody(), puede agregar texto simple, archivos, secuencias y otros objetos a un MultipartBuilder. Agregue el contenido deseado usando estos métodos.

//Adding text
entitybuilder.addTextBody("sample_text", "This is the text part of our file");
//Adding a file
entitybuilder.addBinaryBody("image", new File("logo.png"));

Paso 6: creación de una entidad única

Puede construir todas estas partes en una sola entidad usando el build() método del MultipartEntityBuilderclase. Usando este método, construya todas las partes en una solaHttpEntity.

//Building a single entity using the parts
HttpEntity mutiPartHttpEntity = entityBuilder.build();

Paso 7: crear un objeto RequestBuilder

La clase RequestBuilderse utiliza para crear solicitudes añadiéndoles parámetros. Si la solicitud es de tipo PUT o POST, agrega los parámetros a la solicitud como entidad codificada en URL.

Cree un objeto RequestBuilder (de tipo POST) utilizando el post()método. Y pasa la Uri a la que querías enviar la solicitud como parámetro.

//Building the post request object
RequestBuilder reqbuilder = RequestBuilder.post("http://httpbin.org/post");

Paso 8: establece el objeto de la entidad en RequestBuilder

Establezca la entidad multiparte creada anteriormente en RequestBuilder usando el setEntity() método del RequestBuilder clase.

//Setting the entity object to the RequestBuilder
reqbuilder.setEntity(mutiPartHttpEntity);

Paso 9: compila HttpUriRequest

Construir un HttpUriRequest Solicitar objeto usando el build() método del RequestBuilder clase.

//Building the request
HttpUriRequest multipartRequest = reqbuilder.build();

Paso 10: ejecutar la solicitud

Utilizando el execute() , ejecute la solicitud creada en el paso anterior (omitiendo la solicitud como parámetro de este método).

//Executing the request
HttpResponse httpresponse = httpclient.execute(multipartRequest);

Ejemplo

El siguiente ejemplo demuestra cómo enviar una solicitud de varias partes utilizando la biblioteca HttpClient. En este ejemplo, estamos intentando enviar una solicitud de varias partes respaldada por un archivo.

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.methods.RequestBuilder;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;

public class MultipartUploadExample {
 
   public static void main(String args[]) throws Exception{

      //Creating CloseableHttpClient object
      CloseableHttpClient httpclient = HttpClients.createDefault();
 
      //Creating a file object
      File file = new File("sample.txt");

      //Creating the FileBody object
      FileBody filebody = new FileBody(file, ContentType.DEFAULT_BINARY);

      //Creating the MultipartEntityBuilder
      MultipartEntityBuilder entitybuilder = MultipartEntityBuilder.create();

      //Setting the mode
      entitybuilder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);

      //Adding text
      entitybuilder.addTextBody("sample_text", "This is the text part of our file");

      //Adding a file
      entitybuilder.addBinaryBody("image", new File("logo.png"));

      //Building a single entity using the parts
      HttpEntity mutiPartHttpEntity = entitybuilder.build();

      //Building the RequestBuilder request object
      RequestBuilder reqbuilder = RequestBuilder.post("http://httpbin.org/post");

      //Set the entity object to the RequestBuilder
      reqbuilder.setEntity(mutiPartHttpEntity);

      //Building the request
      HttpUriRequest multipartRequest = reqbuilder.build();

      //Executing the request
      HttpResponse httpresponse = httpclient.execute(multipartRequest);

      //Printing the status and the contents of the response
      System.out.println(EntityUtils.toString(httpresponse.getEntity()));
      System.out.println(httpresponse.getStatusLine());
   }
}

Salida

Al ejecutarse, el programa anterior genera la siguiente salida:

{
   "args": {},
   "data": "",
   "files": {
      "image": "data:application/octets66PohrH3IWNk1FzpohfdXPIfv9X3490FGcuXsHn9X0piCwomF/xdgADZ9GsfSyvLYAAAAAE
      lFTkSuQmCC"
   },
   "form": {
      "sample_text": "This is the text part of our file"
   },
   "headers": {
      "Accept-Encoding": "gzip,deflate",
      "Connection": "close",
      "Content-Length": "11104", 
      "Content-Type": "multipart/form-data;
      boundary=UFJbPHT7mTwpVq70LpZgCi5I2nvxd1g-I8Rt",
      "Host": "httpbin.org",
      "User-Agent": "Apache-HttpClient/4.5.6 (Java/1.8.0_91)"
   },
   "json": null,
   "origin": "117.216.245.180",
   "url": "http://httpbin.org/post"
}
HTTP/1.1 200 OK