Apache HttpClient - Guida rapida

Il protocollo HTTP (Hypertext Transfer Protocol) è un protocollo a livello di applicazione per sistemi informativi distribuiti, collaborativi e ipermediali. Questa è la base per la comunicazione di dati per il World Wide Web (cioè Internet) dal 1990. HTTP è un protocollo generico e senza stato che può essere utilizzato anche per altri scopi utilizzando estensioni dei suoi metodi di richiesta, codici di errore e intestazioni.

Fondamentalmente, HTTP è un protocollo di comunicazione basato su TCP / IP, utilizzato per fornire dati (file HTML, file immagine, risultati di query, ecc.) Sul World Wide Web. La porta predefinita è TCP 80, ma è possibile utilizzare anche altre porte. Fornisce un modo standardizzato per i computer di comunicare tra loro. La specifica HTTP definisce come i dati della richiesta dei client verranno costruiti e inviati al server e come i server rispondono a queste richieste.

Cos'è Http Client

Il client HTTP è una libreria di trasferimento, risiede sul lato client, invia e riceve messaggi HTTP. Fornisce un'implementazione aggiornata, ricca di funzionalità ed efficiente che soddisfa i recenti standard HTTP.

Oltre a ciò utilizzando la libreria client, è possibile creare applicazioni basate su HTTP come browser Web, client di servizi Web, ecc.

Caratteristiche di Http Client

Di seguito sono riportate le caratteristiche principali del client Http:

• La libreria HttpClient implementa tutti i metodi HTTP disponibili.

• La libreria HttpClient fornisce API per proteggere le richieste utilizzando il protocollo Secure Socket Layer.

• Utilizzando HttpClient, è possibile stabilire connessioni tramite proxy.

• È possibile autenticare le connessioni utilizzando schemi di autenticazione come Basic, Digest, NTLMv1, NTLMv2, NTLM2 Session ecc.

• La libreria HttpClient supporta l'invio di richieste tramite più thread. Gestisce più connessioni stabilite da vari thread utilizzandoClientConnectionPoolManager.

• Utilizzando la libreria Apache HttpClient, è possibile impostare i timeout di connessione.

In questo capitolo, spiegheremo come impostare un ambiente per HttpClient nell'IDE di Eclipse. Prima di procedere con l'installazione, assicurati di avere già Eclipse installato nel tuo sistema. In caso contrario, scarica e installa Eclipse.

Per ulteriori informazioni su Eclipse, fare riferimento al nostro Tutorial Eclipse .

Passaggio 1: scarica il file JAR delle dipendenze

Apri la home page ufficiale del sito Web HttpClient (componenti) e vai alla pagina di download

Quindi, scarica l'ultima versione stabile di HttpClient. Qui, durante tutto il tutorial, utilizziamo la versione 4.5.6 quindi scarica il file4.5.6.zip.

All'interno della cartella scaricata, troverai una cartella denominata lib e questo contiene i file Jar richiesti che devono essere aggiunti nel classpath del progetto, per lavorare con HttpClient.

Passaggio 2: creare un progetto e impostare il percorso di compilazione

Apri eclipse e crea un progetto di esempio. Fare clic con il tasto destro sul progetto e selezionare l'opzioneBuild Path → Configure Build Path come mostrato di seguito.

Nel Java Build Path cornice in Libraries scheda, fare clic su Add External JARs.

E seleziona tutti i file jar nella cartella lib e fai clic su Apply and Close.

Sei pronto per lavorare con la libreria HttpClient in eclipse.

Il metodo GET viene utilizzato per recuperare le informazioni da un determinato server utilizzando un determinato URI. Le richieste che utilizzano GET dovrebbero solo recuperare i dati e non dovrebbero avere altri effetti sui dati.

L'API HttpClient fornisce una classe denominata HttpGet che rappresenta il metodo di richiesta get.

Seguire i passaggi indicati di seguito per inviare una richiesta get utilizzando la libreria HttpClient

Passaggio 1: creare un oggetto HttpClient

Il createDefault() metodo del HttpClients class restituisce a CloseableHttpClient oggetto, che è l'implementazione di base di HttpClient interfaccia.

Usando questo metodo, crea un oggetto HttpClient come mostrato di seguito -

CloseableHttpClient httpclient = HttpClients.createDefault();

Passaggio 2: creare un oggetto HttpGet

Il HttpGet class rappresenta la richiesta HTTPGET che recupera le informazioni del server dato utilizzando un URI.

Crea una richiesta HTTP GET istanziando questa classe. Il costruttore di questa classe accetta un valore String che rappresenta l'URI.

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

Passaggio 3: eseguire la richiesta di acquisizione

Il execute() metodo del CloseableHttpClient class accetta un oggetto HttpUriRequest (interfaccia) (cioè HttpGet, HttpPost, HttpPut, HttpHead ecc.) e restituisce un oggetto risposta.

Eseguire la richiesta utilizzando questo metodo come mostrato di seguito -

HttpResponse httpresponse = httpclient.execute(httpget);

Esempio

Di seguito è riportato un esempio che dimostra l'esecuzione della richiesta HTTP GET utilizzando la libreria 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());
      }
   }
}

Produzione

Il programma di cui sopra genera il seguente output:

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 richiesta POST viene utilizzata per inviare dati al server; ad esempio, informazioni sui clienti, caricamento di file, ecc. utilizzando moduli HTML.

L'API HttpClient fornisce una classe denominata HttpPost che rappresenta la richiesta POST.

Seguire i passaggi indicati di seguito per inviare una richiesta HTTP POST utilizzando la libreria HttpClient.

Passaggio 1: creare un oggetto HttpClient

Il createDefault() metodo del HttpClients class restituisce un oggetto della classe CloseableHttpClient, che è l'implementazione di base di HttpClient interfaccia.

Usando questo metodo, crea un oggetto HttpClient.

CloseableHttpClient httpClient = HttpClients.createDefault();

Passaggio 2: creare un oggetto HttpPost

Il HttpPost class rappresenta il HTTP POSTrichiesta. Questo invia i dati richiesti e recupera le informazioni del server specificato utilizzando un URI.

Crea questa richiesta istanziando il file HttpPost class e passare un valore stringa che rappresenta l'URI, come parametro al suo costruttore.

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

Passaggio 3: eseguire la richiesta di acquisizione

Il execute() Il metodo dell'oggetto CloseableHttpClient accetta un oggetto HttpUriRequest (interfaccia) (ad esempio HttpGet, HttpPost, HttpPut, HttpHead ecc.) e restituisce un oggetto risposta.

HttpResponse httpResponse = httpclient.execute(httpget);

Esempio

Di seguito è riportato un esempio che dimostra l'esecuzione della richiesta HTTP POST utilizzando la libreria 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());
      }
   }
}

Produzione

Il programma precedente genera il seguente output.

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>

Si consiglia di elaborare le risposte HTTP utilizzando i gestori delle risposte. In questo capitolo, discuteremo come creare gestori di risposta e come utilizzarli per elaborare una risposta.

Se utilizzi il gestore delle risposte, tutte le connessioni HTTP verranno rilasciate automaticamente.

Creazione di un gestore di risposte

L'API HttpClient fornisce un'interfaccia nota come ResponseHandler nella confezione org.apache.http.client. Per creare un gestore di risposte, implementare questa interfaccia e sovrascrivere la sua handleResponse() metodo.

Ogni risposta ha un codice di stato e se il codice di stato è compreso tra 200 e 300, significa che l'azione è stata ricevuta, compresa e accettata con successo. Pertanto, nel nostro esempio, gestiremo le entità delle risposte con tali codici di stato.

Esecuzione della richiesta utilizzando il gestore della risposta

Seguire i passaggi indicati di seguito per eseguire la richiesta utilizzando un gestore di risposte.

Passaggio 1: creare un oggetto HttpClient

Il createDefault() metodo del HttpClients class restituisce un oggetto della classe CloseableHttpClient, che è l'implementazione di base di HttpClientinterfaccia. Utilizzando questo metodo creare un oggetto HttpClient

CloseableHttpClient httpclient = HttpClients.createDefault();

Passaggio 2: creare un'istanza del gestore delle risposte

Crea un'istanza dell'oggetto gestore della risposta creato sopra utilizzando la seguente riga di codice:

ResponseHandler<String> responseHandler = new MyResponseHandler();

Passaggio 3: creare un oggetto HttpGet

Il HttpGet class rappresenta la richiesta HTTP GET che recupera le informazioni del server dato utilizzando un URI.

Creare una richiesta HttpGet creando un'istanza della classe HttpGet e passando una stringa che rappresenta l'URI come parametro al relativo costruttore.

ResponseHandler<String> responseHandler = new MyResponseHandler();

Passaggio 4: eseguire la richiesta Get utilizzando il gestore delle risposte

Il CloseableHttpClient class ha una variante di execute() metodo che accetta due oggetti ResponseHandler e HttpUriRequest e restituisce un oggetto risposta.

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

Esempio

L'esempio seguente mostra l'utilizzo dei gestori di risposta.

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);
   }
}

Produzione

I programmi di cui sopra generano il seguente output:

<!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>

Se stai elaborando le risposte HTTP manualmente invece di utilizzare un gestore di risposte, devi chiudere da solo tutte le connessioni http. Questo capitolo spiega come chiudere manualmente le connessioni.

Durante la chiusura manuale delle connessioni HTTP, seguire i passaggi indicati di seguito:

Passaggio 1: creare un oggetto HttpClient

Il createDefault() metodo del HttpClients class restituisce un oggetto della classe CloseableHttpClient, che è l'implementazione di base dell'interfaccia HttpClient.

Usando questo metodo, crea un file HttpClient oggetto come mostrato di seguito -

CloseableHttpClient httpClient = HttpClients.createDefault();

Passaggio 2: avviare un blocco di prova finale

Avvia un blocco try-latest, scrivi il codice rimanente nei programmi nel blocco try e chiudi l'oggetto CloseableHttpClient nel blocco latest.

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

Passaggio 3: creare un oggetto HttpGetobject

Il HttpGet class rappresenta la richiesta HTTP GET che recupera le informazioni del server dato utilizzando un URI.

Crea una richiesta HTTP GET creando un'istanza della classe HttpGet passando una stringa che rappresenta l'URI.

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

Passaggio 4: eseguire la richiesta Get

Il execute() metodo del CloseableHttpClient oggetto accetta un file HttpUriRequest oggetto (interfaccia) (ad esempio HttpGet, HttpPost, HttpPut, HttpHead ecc.) e restituisce un oggetto risposta.

Esegui la richiesta utilizzando il metodo indicato -

HttpResponse httpResponse = httpclient.execute(httpGet);

Passaggio 5: avviare un altro tentativo (annidato)

Avvia un altro blocco try-latest (annidato nel precedente try-latest), scrivi il codice rimanente nei programmi in questo blocco try e chiudi l'oggetto HttpResponse nel blocco finalmente.

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

Esempio

Ogni volta che crei / ottieni oggetti come richiesta, flusso di risposta, ecc., Avvia un blocco di prova finalmente nella riga successiva, scrivi il codice rimanente all'interno di prova e chiudi il rispettivo oggetto nel blocco finale come mostrato nel programma seguente:

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();
      }
   }
}

Produzione

Quando si esegue il programma sopra, viene generato il seguente output:

<!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>

È possibile interrompere la richiesta HTTP corrente utilizzando il abort() metodo, cioè, dopo aver invocato questo metodo, su una particolare richiesta, l'esecuzione di esso verrà interrotta.

Se questo metodo viene richiamato dopo un'esecuzione, le risposte di tale esecuzione non verranno influenzate e le esecuzioni successive verranno interrotte.

Esempio

Se osservi il seguente esempio, abbiamo creato una richiesta HttpGet, stampato il formato di richiesta utilizzato utilizzando il getMethod().

Quindi, abbiamo eseguito un'altra esecuzione con la stessa richiesta. Stampato la riga di stato utilizzando il 1 ^° di nuovo l'esecuzione. Infine, ha stampato la riga di stato della seconda esecuzione.

Come discusso, vengono stampate le risposte della 1 ^a esecuzione (esecuzione prima del metodo abort) (inclusa la seconda riga di stato che viene scritta dopo il metodo abort) e tutte le successive esecuzioni della richiesta corrente dopo il metodo abort falliscono invocando un eccezione.

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());
   }
}

Produzione

In esecuzione, il programma precedente genera il seguente output:

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)

Gli intercettatori sono quelli che aiutano a ostacolare o modificare richieste o risposte. Gli intercettori di protocollo in generale agiscono su un'intestazione specifica o su un gruppo di intestazioni correlate. La libreria HttpClient fornisce il supporto per gli intercettori.

Richiedi intercettore

Il HttpRequestInterceptorl'interfaccia rappresenta gli intercettatori di richiesta. Questa interfaccia contiene un metodo noto come processo in cui è necessario scrivere il blocco di codice per intercettare le richieste.

Sul lato client, questo metodo verifica / elabora le richieste prima di inviarle al server e, sul lato server, questo metodo viene eseguito prima di valutare il corpo della richiesta.

Creazione dell'intercettatore di richieste

È possibile creare un intercettatore di richieste seguendo i passaggi indicati di seguito.

Step 1 - Create an object of HttpRequestInterceptor

Crea un oggetto dell'interfaccia HttpRequestInterceptor implementando il suo processo del metodo astratto.

HttpRequestInterceptor requestInterceptor = new HttpRequestInterceptor() {

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

Step 2 - Instantiate CloseableHttpClient object

Crea un'abitudine CloseableHttpClient oggetto aggiungendo l'interceptor creato sopra come mostrato di seguito -

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

Usando questo oggetto, puoi eseguire le esecuzioni delle richieste come al solito.

Esempio

L'esempio seguente mostra l'utilizzo degli intercettatori di richieste. In questo esempio, abbiamo creato un oggetto richiesta HTTP GET e aggiunto tre intestazioni: sample-header, demoheader e test-header ad esso.

Nel processor()metodo dell'interceptor, stiamo verificando gli header della richiesta inviata; se una di queste intestazioni èsample-header, stiamo cercando di rimuoverlo e visualizzare l'elenco delle intestazioni di quella particolare richiesta.

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());
   }
}

Produzione

Quando si esegue il programma sopra, viene generato il seguente output:

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

Intercettore di risposta

Il HttpResponseInterceptorl'interfaccia rappresenta gli intercettori di risposta. Questa interfaccia contiene un metodo noto comeprocess(). In questo metodo, è necessario scrivere il blocco di codice per intercettare le risposte.

Sul lato server, questo metodo verifica / elabora la risposta prima di inviarli al client e sul lato client, questo metodo viene eseguito prima di valutare il corpo della risposta.

Creazione di intercettatori di risposta

È possibile creare un intercettatore di risposta seguendo i passaggi indicati di seguito:

Step 1 - Create an object of HttpResponseInterceptor

Crea un oggetto di HttpResponseInterceptor interfaccia implementando il suo metodo astratto process.

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

Passaggio 2: creare un'istanza dell'oggetto CloseableHttpClient

Crea un'abitudine CloseableHttpClient oggetto aggiungendo l'interceptor creato sopra, come mostrato di seguito -

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

Usando questo oggetto, puoi eseguire le esecuzioni delle richieste come al solito.

Esempio

L'esempio seguente mostra l'utilizzo di intercettori di risposta. In questo esempio, abbiamo aggiunto tre intestazioni: sample-header, demo-header e test-header alla risposta nel processore.

Dopo aver eseguito la richiesta e ottenuto la risposta, abbiamo stampato i nomi di tutte le intestazioni della risposta utilizzando il getAllHeaders() metodo.

E nell'output, puoi osservare i nomi di tre intestazioni nell'elenco.

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());
      }
   }
}

Produzione

All'esecuzione, il programma precedente genera il seguente risultato:

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

Utilizzando HttpClient, puoi connetterti a un sito Web che richiedeva nome utente e password. Questo capitolo spiega come eseguire una richiesta client su un sito che richiede nome utente e password.

Passaggio 1: creare un oggetto CredentialsProvider

Il CredentialsProviderL'interfaccia mantiene una raccolta per contenere le credenziali di accesso dell'utente. Puoi creare il suo oggetto istanziando il fileBasicCredentialsProvider class, l'implementazione predefinita di questa interfaccia.

CredentialsProvider credentialsPovider = new BasicCredentialsProvider();

Passaggio 2: impostare le credenziali

È possibile impostare le credenziali richieste per l'oggetto CredentialsProvider utilizzando il setCredentials() metodo.

Questo metodo accetta due oggetti come indicato di seguito:

• AuthScope object - Ambito di autenticazione che specifica i dettagli come nome host, numero di porta e nome dello schema di autenticazione.

• Credentials object - Specificare le credenziali (nome utente, password).

Impostare le credenziali utilizzando il setCredentials() metodo sia per l'host che per il proxy come mostrato di seguito:

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

Passaggio 3: creare un oggetto HttpClientBuilder

Creare un HttpClientBuilder usando il custom() metodo del HttpClients classe.

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

Passaggio 4: impostare le credenzialiPovider

È possibile impostare l'oggetto credentialsPovider creato sopra su un HttpClientBuilder utilizzando il setDefaultCredentialsProvider() metodo.

Impostare l'oggetto CredentialProvider creato nel passaggio precedente al generatore di client passandolo al CredentialsProvider object() metodo come mostrato di seguito.

clientbuilder = clientbuilder.setDefaultCredentialsProvider(credsProvider);

Passaggio 5: creare il CloseableHttpClient

Costruisci il file CloseableHttpClient oggetto utilizzando il build() metodo del HttpClientBuilder classe.

CloseableHttpClient httpclient = clientbuilder.build()

Passaggio 6: creare un oggetto HttpGet ed eseguirlo

Crea un oggetto HttpRequest creando un'istanza della classe HttpGet. Esegui questa richiesta utilizzando ilexecute() metodo.

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

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

Esempio

Di seguito è riportato un programma di esempio che dimostra l'esecuzione di una richiesta HTTP su un sito di destinazione che richiede l'autenticazione dell'utente.

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());
      }
   }
}

Produzione

In esecuzione, il programma precedente genera il seguente output.

GET
HTTP/1.1 200 OK
200

Un server proxy è un server intermedio tra il client e Internet. I server proxy offrono le seguenti funzionalità di base:

• Firewall e filtraggio dei dati di rete

• Condivisione della connessione di rete

• Memorizzazione nella cache dei dati

Utilizzando la libreria HttpClient, è possibile inviare una richiesta HTTP utilizzando un proxy. Segui i passaggi indicati di seguito:

Passaggio 1: creare un oggetto HttpHost

Istanziare il file HttpHost classe di org.apache.http pacchetto passando un parametro stringa che rappresenta il nome dell'host proxy, (da cui è necessario inviare le richieste) al suo costruttore.

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

Allo stesso modo, crea un altro oggetto HttpHost per rappresentare l'host di destinazione a cui devono essere inviate le richieste.

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

Passaggio 2: creare un oggetto HttpRoutePlanner

Il HttpRoutePlannerl'interfaccia calcola un percorso verso un host specificato. Crea un oggetto di questa interfaccia istanziando il fileDefaultProxyRoutePlannerclass, un'implementazione di questa interfaccia. Come parametro per il suo costruttore, passa l'host proxy creato sopra -

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

Passaggio 3: impostare il pianificatore di percorso su un costruttore del cliente

Usando il custom() metodo del HttpClients class, crea un file HttpClientBuilder oggetto e, a questo oggetto, impostare il pianificatore di percorso creato sopra, utilizzando il setRoutePlanner() metodo.

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

clientBuilder = clientBuilder.setRoutePlanner(routePlanner);

Passaggio 4: creare l'oggetto CloseableHttpClient

Costruisci il file CloseableHttpClient oggetto chiamando il build() metodo.

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

Passaggio 5: creare un oggetto HttpGetobject

Crea una richiesta HTTP GET istanziando il file HttpGet classe.

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

Passaggio 6: eseguire la richiesta

Una delle varianti di execute() metodo accetta un file HttpHost e HttpRequestoggetti ed esegue la richiesta. Esegui la richiesta utilizzando questo metodo -

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

Esempio

L'esempio seguente mostra come inviare una richiesta HTTP a un server tramite proxy. In questo esempio, stiamo inviando una richiesta HTTP GET a google.com tramite localhost. Abbiamo stampato le intestazioni della risposta e il corpo della risposta.

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));
      }
   }
}

Produzione

In esecuzione, il programma precedente genera il seguente output:

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>

In questo capitolo impareremo come creare un HttpRequest autenticato utilizzando nome utente e password e incanalarlo attraverso un proxy a un host di destinazione, utilizzando un esempio.

Passaggio 1: creare un oggetto CredentialsProvider

L'interfaccia CredentialsProvider mantiene una raccolta per contenere le credenziali di accesso dell'utente. È possibile creare il suo oggetto istanziando la classe BasicCredentialsProvider, l'implementazione predefinita di questa interfaccia.

CredentialsProvider credentialsPovider = new BasicCredentialsProvider();

Passaggio 2: impostare le credenziali

È possibile impostare le credenziali richieste per l'oggetto CredentialsProvider utilizzando il setCredentials()metodo. Questo metodo accetta due oggetti:

• AuthScope object - Ambito di autenticazione che specifica i dettagli come nome host, numero di porta e nome dello schema di autenticazione.

• Credentials object- Specificare le credenziali (nome utente, password). Impostare le credenziali utilizzando ilsetCredentials() metodo sia per l'host che per il proxy come mostrato di seguito.

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

Passaggio 3: creare un oggetto HttpClientBuilder

Creare un HttpClientBuilder usando il custom() metodo del HttpClients classe come mostrato di seguito -

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

Passaggio 4: impostare CredentialsProvider

È possibile impostare l'oggetto CredentialsProvider su un oggetto HttpClientBuilder utilizzando il setDefaultCredentialsProvider()metodo. Passa il file precedentemente creatoCredentialsProvider opporsi a questo metodo.

clientbuilder = clientbuilder.setDefaultCredentialsProvider(credsProvider);

Passaggio 5: creare il CloseableHttpClient

Costruisci il file CloseableHttpClient oggetto utilizzando il build() metodo.

CloseableHttpClient httpclient = clientbuilder.build();

Passaggio 6: creare il proxy e gli host di destinazione

Crea la destinazione e gli host proxy istanziando il file HttpHost classe.

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

Passaggio 7: impostare il proxy e creare un oggetto RequestConfig

Creare un RequestConfig.Builder oggetto utilizzando il custom()metodo. Imposta l'oggetto proxyHost creato in precedenza suRequestConfig.Builder usando il setProxy()metodo. Infine, crea il fileRequestConfig oggetto utilizzando il build() metodo.

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

Passaggio 8: creare un oggetto richiesta HttpGet e impostarvi l'oggetto config.

Creare un HttpGetoggetto istanziando la classe HttpGet. Impostare l'oggetto di configurazione creato nel passaggio precedente su questo oggetto utilizzando ilsetConfig() metodo.

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

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

Passaggio 9: eseguire la richiesta

Eseguire la richiesta passando l'oggetto HttpHost (destinazione) e la richiesta (HttpGet) come parametri al execute() metodo.

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

Esempio

L'esempio seguente mostra come eseguire una richiesta HTTP tramite un proxy utilizzando nome utente e password.

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());

   }
}

Produzione

In esecuzione, il programma precedente genera il seguente output:

HTTP/1.1 200 OK

Utilizzando la libreria HttpClient è possibile inviare una richiesta o accedere a un form passando i parametri.

Seguire i passaggi indicati di seguito per accedere a un modulo.

Passaggio 1: creare un oggetto HttpClient

Il createDefault() metodo del HttpClients class restituisce un oggetto della classe CloseableHttpClient, che è l'implementazione di base dell'interfaccia HttpClient. Utilizzando questo metodo, crea un oggetto HttpClient -

CloseableHttpClient httpClient = HttpClients.createDefault();

Passaggio 2: creare un oggetto RequestBuilder

La classe RequestBuilderviene utilizzato per creare la richiesta aggiungendovi parametri. Se il tipo di richiesta è PUT o POST, aggiunge i parametri alla richiesta come entità con codifica URL

Crea un oggetto RequestBuilder (di tipo POST) utilizzando il metodo post ().

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

Passaggio 3: impostare Uri e parametri su RequestBuilder.

Impostare l'URI e i parametri sull'oggetto RequestBuilder utilizzando il setUri() e addParameter() metodi della classe RequestBuilder.

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

Passaggio 4: creare l'oggetto HttpUriRequest

Dopo aver impostato i parametri richiesti, crea il file HttpUriRequest oggetto utilizzando il build() metodo.

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

Passaggio 5: eseguire la richiesta

Il metodo di esecuzione dell'oggetto CloseableHttpClient accetta un oggetto HttpUriRequest (interfaccia) (ad esempio HttpGet, HttpPost, HttpPut, HttpHead ecc.) E restituisce un oggetto di risposta.

Esegui HttpUriRequest creato nei passaggi precedenti passandolo al file execute() metodo.

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

Esempio

L'esempio seguente mostra come accedere a un modulo inviando le credenziali di accesso. Qui abbiamo inviato due parametri:username and password in un modulo e ha tentato di stampare l'entità del messaggio e lo stato della richiesta.

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());
   }
}

Produzione

In esecuzione, il programma precedente genera il seguente output:

{
   "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

Modulo di accesso con i cookie

Se il tuo modulo memorizza i cookie, invece di creare default CloseableHttpClient oggetto.

Create a CookieStore object istanziando la classe BasicCookieStore.

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

Create a HttpClientBuilder usando il custom() metodo del HttpClients classe.

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

Set the cookie store to the client builder utilizzando il metodo setDefaultCookieStore ().

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

Costruisci il file CloseableHttpClient oggetto utilizzando il build() metodo.

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

Costruisci il file HttpUriRequest oggetto come specificato sopra passando per eseguire la richiesta.

Se la pagina memorizza i cookie, i parametri che hai passato verranno aggiunti all'archivio dei cookie.

È possibile stampare il contenuto del file CookieStore oggetto in cui puoi vedere i tuoi parametri (insieme a quelli precedenti la pagina memorizzata nel caso).

Per stampare i cookie, prendi tutti i cookie dal CookieStore oggetto utilizzando il getCookies()metodo. Questo metodo restituisce un fileListoggetto. Utilizzando Iterator, stampare il contenuto degli oggetti dell'elenco come mostrato di seguito -

//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());
}

I cookie sono file di testo memorizzati sul computer client e vengono conservati per vari scopi di tracciamento delle informazioni.

HttpClient fornisce il supporto per i cookie che è possibile creare e gestire i cookie.

Creazione di un cookie

Seguire i passaggi indicati di seguito per creare un cookie utilizzando la libreria HttpClient.

Passaggio 1: crea l'oggetto Cookiestore

Il CookieStorel'interfaccia rappresenta l'archivio astratto per gli oggetti Cookie. È possibile creare un cookie store istanziando il fileBasicCookieStore class, un'implementazione predefinita di questa interfaccia.

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

Passaggio 2: creare l'oggetto ClientCookie

Oltre alle funzionalità di un cookie, ClientCookie può ottenere i cookie originali nel server. È possibile creare un cookie client istanziando il fileBasicClientCookieclasse. Al costruttore di questa classe, devi passare la coppia chiave-valore che desideri memorizzare in quel particolare cookie.

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

Passaggio 3: impostare i valori per il cookie

Per un cookie client, è possibile impostare / rimuovere percorso, valore, versione, data di scadenza, dominio, commento e attributo utilizzando i rispettivi metodi.

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);

Passaggio 4: aggiungi cookie al negozio di cookie

È possibile aggiungere cookie al negozio di cookie utilizzando il addCookie() metodo del BasicCookieStore classe.

Aggiungi i cookie necessari al file Cookiestore.

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

Esempio

L'esempio seguente mostra come creare cookie e aggiungerli a un negozio di cookie. Qui, abbiamo creato un cookie store, un gruppo di cookie impostando i valori di dominio e percorso e li abbiamo aggiunti al cookie store.

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);
   }
}

Recupero di un cookie

È possibile aggiungere i cookie a un negozio di cookie utilizzando getCookies() metodo del asicCookieStoreclasse. Questo metodo restituisce un elenco che contiene tutti i cookie nel cookie store.

È possibile stampare il contenuto di un negozio di cookie utilizzando Iterator come mostrato di seguito -

//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());
}

Esempio

L'esempio seguente mostra come recuperare i cookie da un negozio di cookie. Qui, stiamo aggiungendo una serie di cookie a un negozio di cookie e recuperandoli.

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);
   }
}

Produzione

All'esecuzione, questo programma genera il seguente output:

[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 programma multi-thread contiene due o più parti che possono essere eseguite contemporaneamente e ciascuna parte può gestire un'attività diversa allo stesso tempo facendo un uso ottimale delle risorse disponibili.

È possibile eseguire richieste da più thread scrivendo un programma HttpClient multithread.

Se si desidera eseguire più richieste client dai thread consecutivamente, è necessario creare un file ClientConnectionPoolManager. Mantiene un pool diHttpClientConnections e serve più richieste dai thread.

Il gestore delle connessioni raggruppa le connessioni in base al percorso. Se il gestore dispone di connessioni per una determinata route, serve nuove richieste in tali route prendendo in leasing una connessione esistente dal pool, invece di crearne una nuova.

Segui i passaggi per eseguire richieste da più thread:

Passaggio 1: creazione di Client Connection Pool Manager

Creare il Client Connection Pool Manager istanziando il file PoolingHttpClientConnectionManager classe.

PoolingHttpClientConnectionManager connManager = new
   PoolingHttpClientConnectionManager();

Passaggio 2: impostare il numero massimo di connessioni

Impostare il numero massimo di connessioni nel pool utilizzando il setMaxTotal() metodo.

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

Passaggio 3: creare un oggetto ClientBuilder

Creare un ClientBuilder Oggetto impostando il gestore della connessione utilizzando il setConnectionManager() metodo come mostrato di seguito -

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

Passaggio 4: creare gli oggetti di richiesta HttpGet

Creare un'istanza della classe HttpGet passando l'URI desiderato al relativo costruttore come parametro.

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

Passaggio 5: implementazione del metodo di esecuzione

Assicurati di aver creato una classe, di averlo reso un thread (estendendo la classe thread o implementando l'interfaccia Runnable) e implementato il metodo run.

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

Passaggio 6: creare oggetti Thread

Crea oggetti thread istanziando la classe Thread (ClientMultiThreaded) creata sopra.

Passa un oggetto HttpClient, il rispettivo oggetto HttpGet e un numero intero che rappresenta l'ID a questi thread.

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

Passaggio 7: avviare e unire i thread

Inizia tutti i thread usando start() metodo e unisciti a loro usando il join method().

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

Passaggio 8: eseguire l'implementazione del metodo

All'interno del metodo run, eseguire la richiesta, recuperare la risposta e stampare i risultati.

Esempio

L'esempio seguente mostra l'esecuzione simultanea di richieste HTTP da più thread. In questo esempio, stiamo cercando di eseguire varie richieste da vari thread e provando a stampare lo stato e il numero di byte letti da ogni client.

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();
   }
}

Produzione

In esecuzione, il programma precedente genera il seguente output:

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

Utilizzando Secure Socket Layer, è possibile stabilire una connessione protetta tra il client e il server. Aiuta a salvaguardare informazioni sensibili come numeri di carte di credito, nomi utente, password, pin, ecc.

Puoi rendere le connessioni più sicure creando il tuo contesto SSL utilizzando il HttpClient biblioteca.

Seguire i passaggi indicati di seguito per personalizzare SSLContext utilizzando la libreria HttpClient -

Passaggio 1: creare l'oggetto SSLContextBuilder

SSLContextBuilderè il generatore per gli oggetti SSLContext. Crea il suo oggetto usando ilcustom() metodo del SSLContexts classe.

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

Passaggio 2: caricare il keystore

Nel percorso Java_home_directory/jre/lib/security/, puoi trovare un file denominato cacerts. Salvalo come file di archivio chiavi (con estensione .jks). Carica il file keystore e la sua password (che èchangeit per impostazione predefinita) utilizzando il loadTrustMaterial() metodo del SSLContextBuilder classe.

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

Passaggio 3: crea un oggetto SSLContext

Un oggetto SSLContext rappresenta un'implementazione del protocollo socket sicuro. Crea un SSLContext usandobuild() metodo.

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

Passaggio 4: creazione dell'oggetto SSLConnectionSocketFactory

SSLConnectionSocketFactoryè una fabbrica di socket a più livelli per connessioni TSL e SSL. In questo modo, puoi verificare il server Https utilizzando un elenco di certificati attendibili e autenticare il server Https specificato.

Puoi crearlo in molti modi. A seconda del modo in cui crei un fileSSLConnectionSocketFactory oggetto, puoi consentire tutti gli host, consentire solo certificati autofirmati, consentire solo protocolli particolari, ecc.

To allow only particular protocols, creare SSLConnectionSocketFactory passando un oggetto SSLContext, la matrice di stringhe che rappresenta i protocolli deve essere supportata, la matrice di stringhe che rappresenta i semi di cifratura deve essere supportata e un oggetto HostnameVerifier al suo costruttore.

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

To allow all hosts, creare SSLConnectionSocketFactory oggetto passando un oggetto SSLContext e un file NoopHostnameVerifier oggetto.

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

Passaggio 5: creare un oggetto HttpClientBuilder

Crea un oggetto HttpClientBuilder usando il custom() metodo del HttpClients classe.

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

Passaggio 6: impostare l'oggetto SSLConnectionSocketFactory

Impostare l'oggetto SSLConnectionSocketFactory su HttpClientBuilder usando il setSSLSocketFactory() metodo.

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

Passaggio 7: creare l'oggetto CloseableHttpClient

Costruisci il file CloseableHttpClient oggetto chiamando il build() metodo.

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

Passaggio 8: creare un oggetto HttpGet

Il HttpGet class rappresenta la richiesta HTTP GET che recupera le informazioni del server dato utilizzando un URI.

Crea una richiesta HTTP GET creando un'istanza della classe HttpGet passando una stringa che rappresenta l'URI.

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

Passaggio 9: eseguire la richiesta

Eseguire la richiesta utilizzando il execute() metodo.

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

Esempio

L'esempio seguente mostra la personalizzazione di 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);
      } 
   }
}

Produzione

In esecuzione, il programma precedente genera il seguente output.

HTTP/1.1 200 OK
1270

Utilizzando HttpClient, possiamo eseguire il caricamento in più parti, ovvero possiamo caricare oggetti più grandi in parti più piccole. In questo capitolo viene illustrato il caricamento in più parti nel client HTTP caricando un semplice file di testo.

In generale, qualsiasi caricamento in più parti contiene tre parti.

• Avvio del caricamento

• Caricamento delle parti dell'oggetto

• Completamento del caricamento in più parti

Per il caricamento in più parti utilizzando HttpClient, è necessario seguire i passaggi seguenti:

• Crea un generatore in più parti.

• Aggiungi le parti desiderate.

• Completa la compilazione e ottieni un HttpEntity in più parti.

• Compila la richiesta impostando l'entità multiparte sopra.

• Esegui la richiesta.

Di seguito sono riportati i passaggi per caricare un'entità multiparte utilizzando la libreria HttpClient.

Passaggio 1: creare un oggetto HttpClient

Il createDefault() metodo del HttpClients class restituisce un oggetto della classe CloseableHttpClient, che è l'implementazione di base dell'interfaccia HttpClient. Utilizzando questo metodo, crea un oggetto HttpClient -

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

Passaggio 2: creare un oggetto FileBody

FileBodyclass rappresenta la parte del corpo binaria supportata da un file. Crea un'istanza di questa classe passando un fileFile oggetto e a ContentType oggetto che rappresenta il tipo di contenuto.

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

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

Passaggio 3: creare un MultipartEntityBuilder

Il MultipartEntityBuilder class viene utilizzata per costruire il multiparte HttpEntityoggetto. Crea il suo oggetto usando ilcreate() metodo (della stessa classe).

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

Passaggio 4: impostare la modalità

UN MultipartEntityBuilderha tre modalità: STRICT, RFC6532 e BROWSER_COMPATIBLE. Impostarlo sulla modalità desiderata utilizzando ilsetMode() metodo.

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

Passaggio 5: aggiungere varie parti desiderate

Utilizzando i metodi addTextBody(), addPart () e, addBinaryBody(), puoi aggiungere testo semplice, file, flussi e altri oggetti a un file MultipartBuilder. Aggiungi i contenuti desiderati usando questi metodi.

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

Passaggio 6: creazione di una singola entità

Puoi costruire tutte queste parti in una singola entità usando il build() metodo del MultipartEntityBuilderclasse. Usando questo metodo, costruisci tutte le parti in un unico fileHttpEntity.

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

Passaggio 7: creare un oggetto RequestBuilder

La classe RequestBuilderviene utilizzato per creare la richiesta aggiungendovi parametri. Se la richiesta è di tipo PUT o POST, aggiunge i parametri alla richiesta come entità con codifica URL.

Crea un oggetto RequestBuilder (di tipo POST) utilizzando l'estensione post()metodo. E passa l'URI a cui vuoi inviare la richiesta come parametro.

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

Passaggio 8: impostare l'oggetto entità su RequestBuilder

Impostare l'entità multiparte sopra creata su RequestBuilder utilizzando il setEntity() metodo del RequestBuilder classe.

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

Passaggio 9: crea HttpUriRequest

Costruire un HttpUriRequest oggetto richiesta utilizzando il build() metodo del RequestBuilder classe.

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

Passaggio 10: eseguire la richiesta

Usando il execute() , esegue la richiesta costruita nel passaggio precedente (ignorando la richiesta come parametro di questo metodo).

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

Esempio

L'esempio seguente mostra come inviare una richiesta multiparte usando la libreria HttpClient. In questo esempio, stiamo cercando di inviare una richiesta in più parti supportata da un file.

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());
   }
}

Produzione

In esecuzione, il programma precedente genera il seguente output:

{
   "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