Apache HttpClient使用和原始碼分析
在上文中分析了 HttpURLConnection的用法，功能還是比較簡單的，沒有什麼封裝
接下來看看Apache HttpClient是如何封裝httpClient的
組成
HttpClient 5 的系統架構主要由以下幾個部分組成：
- HttpCore：核心包，包含了 HTTP 協定的核心抽象和實現，定義了 HTTP 使用者端和伺服器端的基本元件，例如請求訊息、響應訊息、傳輸層等。
- HttpClient：高階 API，封裝了 HttpCore 包中的核心抽象，提供了一組簡單易用的 API，以便於使用者端應用程式傳送 HTTP 請求。
- HttpAsyncClient：非同步 API，是基於 HttpCore 和 HttpClient 構建的非同步 HTTP 使用者端，可以通過非同步方式實現 HTTP 請求。
- 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();
注意看紀錄檔就有輸出了
攔截器和處理器都是用於攔截請求和響應的中介軟體，但它們在功能上有些不同：
- 攔截器：在請求傳送前或響應返回後對請求或響應進行修改，例如新增、刪除、修改請求頭或響應頭、修改請求體等。攔截器的主要作用是攔截請求和響應，對它們進行一些操作，並將它們傳遞給下一個攔截器或處理器
- 處理器：用於執行實際的請求和響應處理，例如建立連線、傳送請求、解析響應等。處理器通常是在整個請求-響應流程中的最後一環，負責將最終的響應結果返回給呼叫方
總之，攔截器和處理器都是用於處理請求和響應的中介軟體，但它們的職責和功能略有不同
非同步請求
非同步請求的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進行了封裝，學習到了
本文來自部落格園，作者：阿弱，轉載請註明原文連結：https://www.cnblogs.com/aruo/p/17165218.html