Apache HttpClient使用和原始碼分析

阿弱發表於2023-02-28
ApacheHTTPclient原始碼

在上文中分析了 HttpURLConnection的用法，功能還是比較簡單的，沒有什麼封裝

接下來看看Apache HttpClient是如何封裝httpClient的

目錄

組成

HttpClient 5 的系統架構主要由以下幾個部分組成：

  1. HttpCore：核心包，包含了 HTTP 協議的核心抽象和實現，定義了 HTTP 客戶端和服務端的基本元件，例如請求訊息、響應訊息、傳輸層等。
  2. HttpClient：高階 API，封裝了 HttpCore 包中的核心抽象，提供了一組簡單易用的 API，以便於客戶端應用程式傳送 HTTP 請求。
  3. HttpAsyncClient：非同步 API，是基於 HttpCore 和 HttpClient 構建的非同步 HTTP 客戶端，可以透過非同步方式實現 HTTP 請求。
  4. HttpClient 和 HttpAsyncClient 都可以透過擴充套件進行定製和最佳化，可以新增攔截器、設定連線管理器、Cookie 管理器、認證器等。

請求程式碼

GET請求程式碼

String resultContent = null;
String url = "http://127.0.0.1:8081/get";
HttpGet httpGet = new HttpGet(url);
//透過工廠獲取
CloseableHttpClient httpClient = HttpClients.createDefault();
//請求
CloseableHttpResponse response = httpClient.execute(httpGet);

// Get status code
System.out.println(response.getVersion()); 
// HTTP/1.1
System.out.println(response.getCode()); 
// 200
System.out.println(response.getReasonPhrase()); 
// OK
HttpEntity entity = response.getEntity();
// Get response information
resultContent = EntityUtils.toString(entity);
System.out.println(resultContent);

程式碼分析

建立例項

Apache HttpClient提供了一個工廠類來返回HttpClient例項

但實際上都是透過HttpClientBuilder去建立的，

Apache HttpClient透過構建者模式加上策略模式實現非常靈活的配置，以實現各種不同的業務場景

透過看build()的程式碼，建立HttpClient主要分為兩步

    public static CloseableHttpClient createDefault() {
        return HttpClientBuilder.create().build();
    }

第一步是初始化配置

裡邊很多策略模式的使用，可以實現相關的類來擴充自己的需求，可以透過HttpClient的set方法把新的策略設定進去，其他配置也可以透過RequestConfig設定好

ConnectionKeepAliveStrategy keepAliveStrategyCopy = this.keepAliveStrategy;
if (keepAliveStrategyCopy == null) {
    keepAliveStrategyCopy = DefaultConnectionKeepAliveStrategy.INSTANCE;
}
AuthenticationStrategy targetAuthStrategyCopy = this.targetAuthStrategy;
if (targetAuthStrategyCopy == null) {
    targetAuthStrategyCopy = DefaultAuthenticationStrategy.INSTANCE;
}
AuthenticationStrategy proxyAuthStrategyCopy = this.proxyAuthStrategy;
if (proxyAuthStrategyCopy == null) {
    proxyAuthStrategyCopy = DefaultAuthenticationStrategy.INSTANCE;
}

在這裡會初始化包括連線管理器、請求重試處理器、請求執行器、重定向策略、認證策略、代理、SSL/TLS等配置

第二步是建立處理器鏈

透過組合多個處理器來構建成處理器鏈處理請求

需要注意的是這裡的新增順序的方法，新增最終的執行處理器呼叫的是addLast()

處理器鏈中的每個處理器都有不同的功能，例如請求預處理、重試、身份驗證、請求傳送、響應解析等等。在每個處理器的處理過程中，可以對請求或響應進行修改或擴充套件，以滿足不同的需求

最後再把初始化好的引數傳遞給InternalHttpClient返回一個HttpClient例項

發起請求

接下來看看請求方法

CloseableHttpResponse response = httpClient.execute(httpGet);

主要請求方法在InternalHttpClient#doExecute中

主要分為三步，第一步是將各種配置填充到上下文中HttpContext

第二步，執行剛剛封裝執行鏈

//execChain就是上一步封裝好的執行鏈
final ClassicHttpResponse response = this.execChain.execute(ClassicRequestBuilder.copy(request).build(), scope);

執行 execute 方法，執行鏈中的處理器被依次呼叫，每個元素都可以執行一些預處理、後處理、重試等邏輯

第三步，請求結束後，將結果轉換為CloseableHttpResponse返回

自定義攔截器和處理器

接下來試試加一下自定義的攔截器和處理器

攔截器和處理器的實現是不一樣的，處理器的實現是ExecChainHandler，攔截器是HttpResponseInterceptor和HttpRequestInterceptor

//執行鏈處理器
class MyCustomInterceptor implements ExecChainHandler {
    @Override
    public ClassicHttpResponse execute(ClassicHttpRequest request, ExecChain.Scope scope, ExecChain chain) throws IOException, HttpException {
        System.out.println("MyCustomInterceptor-------------");
        //呼叫下一個鏈
        return chain.proceed(request,scope);
    }
}

//響應攔截器
class MyCustomResponseInterceptor implements HttpResponseInterceptor {

    @Override
    public void process(HttpResponse response, EntityDetails entity, HttpContext context) throws HttpException, IOException {
        System.out.println("MyCustomResponseInterceptor-------------");
    }
}

//請求攔截器
class MyCustomRequestInterceptor implements HttpRequestInterceptor {


    @Override
    public void process(HttpRequest request, EntityDetails entity, HttpContext context) throws HttpException, IOException {
        System.out.println("MyCustomRequestInterceptor-------------");
    }
}

然後加入到攔截鏈中，custom()方法返回HttpClientBuilder來支援自定義

CloseableHttpClient httpClient = HttpClients.custom()
.addExecInterceptorLast("myCustomInterceptor", new MyCustomInterceptor())
.addRequestInterceptorFirst(new MyCustomRequestInterceptor())
.addResponseInterceptorLast(new MyCustomResponseInterceptor())
.build();

注意看日誌就有輸出了

攔截器和處理器都是用於攔截請求和響應的中介軟體，但它們在功能上有些不同：

  1. 攔截器：在請求傳送前或響應返回後對請求或響應進行修改，例如新增、刪除、修改請求頭或響應頭、修改請求體等。攔截器的主要作用是攔截請求和響應，對它們進行一些操作，並將它們傳遞給下一個攔截器或處理器
  2. 處理器：用於執行實際的請求和響應處理，例如建立連線、傳送請求、解析響應等。處理器通常是在整個請求-響應流程中的最後一環，負責將最終的響應結果返回給呼叫方

總之，攔截器和處理器都是用於處理請求和響應的中介軟體，但它們的職責和功能略有不同

非同步請求

非同步請求的HttpAsyncClient透過HttpAsyncClients工廠返回

主要的流程和同步請求差不多，包括初始化配置和初始化執行鏈，主要差異在執行請求那裡

因為是非同步執行，需要開啟非同步請求的執行器執行緒池，透過httpClient.start();方法來設定非同步執行緒的狀態，否則非同步請求將無法執行

@Override
public final void start() {
    if (status.compareAndSet(Status.READY, Status.RUNNING)) {
        executorService.execute(ioReactor::start);
    }
}

如果沒有開啟，會丟擲異常

if (!isRunning()) {
    throw new CancellationException("Request execution cancelled");
}

因為是非同步請求，所以請求方法需要提供回撥方法，主要實現三個方法，執行完成、失敗和取消

//建立url
SimpleHttpRequest get = SimpleHttpRequest.create("GET", url);

Future<SimpleHttpResponse> future = httpClient.execute(get, 
//非同步回撥                                                     
new FutureCallback<SimpleHttpResponse>() {
    @Override
    public void completed(SimpleHttpResponse result) {
        System.out.println("completed---------------");
    }

    @Override
    public void failed(Exception ex) {
        System.out.println("failed---------------");
    }

    @Override
    public void cancelled() {
        System.out.println("cancelled---------------");
    }
});

SimpleHttpResponse response = future.get();

透過future.get()來獲取非同步結果，接下來看看底層是怎麼實現的

//請求
execute(SimpleRequestProducer.create(request), SimpleResponseConsumer.create(), context, callback);

非同步請求會建立SimpleRequestProducer和SimpleResponseConsumer來處理請求和響應，execute()也支援我們自己傳進去

最終的請求和資料的接收都是依賴管道，過程有點像NIO

當請求時，會呼叫requestProducer.produce(channel);把請求資料寫入channel中，在響應時，responseConsumer從channel中取得資料

原始碼的整一塊請求程式碼都是透過幾個匿名函式的寫法完成的，看的有點繞

發起請求，匿名函式段代表的是RequestChannel的請求方法

//requestProducer的sendRequest方法
void sendRequest(RequestChannel channel, HttpContext context)

因為RequestChannel類是一個函式式介面，所以可以透過這種方式呼叫

public interface RequestChannel {
	//請求方法也是叫sendRequest
    void sendRequest(HttpRequest request, EntityDetails entityDetails, HttpContext context) throws HttpException, IOException;
}

生產和消費資料的程式碼都在那一刻函式段中，具體的實現細節可以看一下那一段原始碼，最終requestProducer也是委託RequestChannel來發起請求

消費完後透過一層一層的回撥，最終到達最上邊自己實現的三個方法上

非同步的HttpClient也可以自定義攔截器喝處理器，實現方式和上邊的一樣，處理非同步處理器的實現不同

 CloseableHttpClient httpClient = HttpClients.custom()
                .setDefaultRequestConfig(config)
                .addExecInterceptorLast("myCustomInterceptor", new MyCustomInterceptor())
                .addRequestInterceptorFirst(new MyCustomRequestInterceptor())
                .addResponseInterceptorLast(new MyCustomResponseInterceptor())
                .build();

使用示例

建立HttpClient

如果是同步的就使用HttpClients工廠，非同步的使用HttpAsyncClients

//返回預設的
CloseableHttpClient httpClient = HttpClients.createDefault();

如果想實現自定義配置，可以使用HttpClients.custom()方法

基本的配置被封裝在RequestConfig類中

RequestConfig config = RequestConfig.custom()
            .setConnectionRequestTimeout(3L, TimeUnit.SECONDS)
            .setResponseTimeout(3L, TimeUnit.SECONDS)
            .setDefaultKeepAlive(10L , TimeUnit.SECONDS)
            .build();

如果還不滿足，可以還可以去實現這些策略類

使用自定義配置建立httpClient

CloseableHttpClient httpClient = HttpClients.custom()
            .setDefaultRequestConfig(config)
            .addExecInterceptorLast("myCustomInterceptor", new MyCustomInterceptor())
            .addRequestInterceptorFirst(new MyCustomRequestInterceptor())
            .addResponseInterceptorLast(new MyCustomResponseInterceptor())
            .build();

GET方法請求

 String url = "http://127.0.0.1:8081/get";

List<NameValuePair> nvps = new ArrayList<>();
// GET 請求引數
nvps.add(new BasicNameValuePair("username", "test"));
nvps.add(new BasicNameValuePair("password", "password"));
//將引數填充道url中
URI uri = new URIBuilder(new URI(url))
        .addParameters(nvps)
        .build();
//建立get請求物件
HttpGet httpGet = new HttpGet(uri);

//發起請求
CloseableHttpResponse response = httpClient.execute(httpGet);

// Get status code
System.out.println(response.getVersion()); // HTTP/1.1
System.out.println(response.getCode()); // 200
HttpEntity entity = response.getEntity();
// Get response information
String resultContent = EntityUtils.toString(entity);
System.out.println(resultContent);

POST請求

這次將引數寫到HttpEntity裡

String url = "http://127.0.0.1:8081/post";

List<NameValuePair> nvps = new ArrayList<>();
// GET 請求引數
nvps.add(new BasicNameValuePair("username", "test"));
nvps.add(new BasicNameValuePair("password", "password"));

UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nvps, StandardCharsets.UTF_8);

HttpPost httpPost = new HttpPost(url);
httpPost.setEntity(formEntity);

CloseableHttpClient httpClient = HttpClients.createDefault();

CloseableHttpResponse response = httpClient.execute(httpPost);

// Get status code
System.out.println(response.getVersion()); // HTTP/1.1
System.out.println(response.getCode()); // 200
HttpEntity entity = response.getEntity();
// Get response information
String resultContent = EntityUtils.toString(entity);
System.out.println(resultContent);

和GET請求基本一致，除了用的是HttpPost，引數可以像GET一樣填充到url中，也可以使用HttpEntity填充到請求體裡

Json請求

String json = "{"
        + "    \"username\": \"test\","
        + "    \"password\": \"password\""
        + "}";
StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
HttpPost post = new HttpPost("http://127.0.0.1:8081/postJson");
post.setEntity(entity);
CloseableHttpClient client = HttpClients.createDefault();
CloseableHttpResponse response = client.execute(post);

// Get status code
System.out.println(response.getCode()); // 200
// Get response information
String resultContent = EntityUtils.toString(response.getEntity());
System.out.println(resultContent);

總結

和HttpURLConnection相比，做了很多封裝，功能也強大了很多，例如連線池、快取、重試機制、執行緒池等等，並且對於請求引數的設定更加靈活，還封裝了非同步請求、HTTPS等、自定義攔截器和處理器等

請求是使用了處理鏈的方式發起的，可以對請求和響應進行一系列處理，好處是可以將這些處理器封裝成一個公共的類庫，然後透過自己組合來滿足自己的需求，還可以在請求和響應的不同階段進行攔截和修改，例如新增請求頭、修改請求引數、解密響應資料等，不需要在一個大類裡寫很多程式碼了，已免程式碼臃腫

效能方面使用了連線池技術，可以有效地複用連線，提高效能

不得不說是apache的專案，原始碼使用了包括構建者模式、策略模式、責任鏈模式等設計模式對整個httpClient進行了封裝，學習到了

相關文章