手動封裝了一個 OkHttp3 工具類，用著賊舒服
作者：了不起
為什么在多線程環境下，異步請求同步阻塞等待結果這種方式能顯著的提升效率呢，其實答案也很簡單，因為 OkHttp 在進行異步請求的時候，使用了線程池來進行執行任務，能有效的管理需要執行的任務。
一、摘要
在前幾篇文章中，我們介紹了 OKHttp 相關的使用操作方式，相信大家對它已經有了初步的了解。
在實際的系統開發過程中，我們通常會基于項目環境，封裝一個公共的網絡請求工具庫，以便開發接口請求相關的需求時，能更加方便的使用。
以服務端編程為例，以下是小編封裝工具類的實踐過程。
二、案例實踐
2.1、首先在項目中導入相關的依賴包
<!-- okhttp3 -->
<dependency>
<groupId>com.squareup.okhttp3</groupId>
<artifactId>okhttp</artifactId>
<version>3.14.9</version>
</dependency><!--jackson依賴包-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.8</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.9.8</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.8</version>
</dependency>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.2</version>
<scope>compile</scope>
</dependency>2.2、封裝 OkHttpClient 相關請求方法
首先將 OkHttpClient 客戶端配置參數單獨拎出來，方便后續獨立配置。
public class OkHttpClientFactory {
/**
* 默認允許的最大并發數
*/
private static int concurrentSize = 100;
private OkHttpClientFactory(){}
/**
* 實例化客戶端配置
* @return
*/
public static OkHttpClient.Builder newInstance() {
OkHttpClient.Builder httpClientBuilder = new OkHttpClient.Builder();
// 設置超時時間
httpClientBuilder.connectTimeout(5, TimeUnit.SECONDS);
httpClientBuilder.writeTimeout(5, TimeUnit.SECONDS);
httpClientBuilder.readTimeout(5, TimeUnit.SECONDS);
// 設置連接池，連接池的最大數量=并發數，30秒空閑的連接會釋放掉
httpClientBuilder.connectionPool(new ConnectionPool(concurrentSize, 30, TimeUnit.SECONDS));
// 設置分發器處理的最大容量，這里的數量=連接池數量=并發數，表示此客戶端有同時能夠處理xx并發數的能力
Dispatcher dispatcher = new Dispatcher();
dispatcher.setMaxRequests(concurrentSize);
dispatcher.setMaxRequestsPerHost(concurrentSize);
httpClientBuilder.dispatcher(dispatcher);
return httpClientBuilder;
}
}然后，構建一個 OkHttpClient 客戶端單例對象。
public class OkHttpClientBuilder {
private static final Logger LOGGER = LoggerFactory.getLogger(OkHttpClientBuilder.class);
/**
* 同步阻塞等待執行結果的時間，單位毫秒
*/
private static Integer DEFAULT_WAIT_TIMEOUT = 3000;
/**
* 服務啟動時初始化OkHttpClient對象，確保客戶端對象單例
*/
private static OkHttpClient okHttpClient = OkHttpClientFactory.newInstance().build();
private OkHttpClientBuilder() {}
static {
// 向JVM注冊一個關閉鉤子，當服務準備停止時，等待 OkHttpClient 中任務執行完畢再停止，防止線程池中正在執行的任務突然中斷
Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
@Override
public void run() {
final Logger logger = LoggerFactory.getLogger(OkHttpClient.class);
int count = 100;
Dispatcher dispatcher = okHttpClient.dispatcher();
logger.info("ShutdownHook start：queuedCallsCount {} , runningCallsCount {}", dispatcher.queuedCallsCount(), dispatcher.runningCallsCount());
while (dispatcher.queuedCallsCount() > 0 || dispatcher.runningCallsCount() > 0) {
try {
TimeUnit.MILLISECONDS.sleep(100);
} catch (InterruptedException e) {
logger.error("ShutdownHook interrupted：queuedCallsCount {} , runningCallsCount {}", dispatcher.queuedCallsCount(), dispatcher.runningCallsCount());
break;
}
// 防止無限循環
if (--count == 0) {
LOGGER.error("ShutdownHook timeout：queuedCallsCount {} , runningCallsCount {}", dispatcher.queuedCallsCount(), dispatcher.runningCallsCount());
break;
}
}
logger.info("ShutdownHook end：queuedCallsCount {} , runningCallsCount {}", dispatcher.queuedCallsCount(), dispatcher.runningCallsCount());
}
}));
}
/**
* 同步執行請求，公共方法
* @param request
* @return
*/
public static OkHttpClientResult syncRequest(Request request){
try (Response response = okHttpClient.newCall(request).execute()){
return buildResponseResult(request, response);
} catch (Exception e) {
LOGGER.error("request error，request:" + request, e);
return new OkHttpClientResult(false, 500, "request error");
}
}
/**
* 異步執行請求，同步阻塞編程等待返回結果
* 此方式在多線程環境下請求處理依然能保持高性能，根據不同的場景顯式對ConnectionPool進行調優處理
* @param request
* @return
*/
public static OkHttpClientResult syncResponse(Request request){
if(LOGGER.isDebugEnabled()){
LOGGER.debug("request start，request:{}", request);
}
// 使用異步編程，在指定時間內阻塞獲取 OKHttp 異步執行結果
CompletableFuture<Response> completableFuture = new CompletableFuture();
// 發起異步請求調用
Call call = okHttpClient.newCall(request);
call.enqueue(new Callback(){
@Override
public void onFailure(Call call, IOException e) {
completableFuture.completeExceptionally(e);
}
@Override
public void onResponse(Call call, Response response) throws IOException {
completableFuture.complete(response);
}
});
// 這里的異步執行結果等待時間，取決于get同步獲取時間的設定，而不是全局請求超時配置
try (Response response = completableFuture.get(DEFAULT_WAIT_TIMEOUT, TimeUnit.MILLISECONDS);) {
return buildResponseResult(request, response);
} catch (TimeoutException e){
call.cancel();
LOGGER.error("request timeout，request:" + request, e);
return new OkHttpClientResult(false, 500, "request timeout");
} catch (Exception e){
LOGGER.error("request error，request:" + request, e);
return new OkHttpClientResult(false, 500, "request error");
}
}
/**
* 封裝返回值
* @param request
* @param response
* @return
* @throws IOException
*/
private static OkHttpClientResult buildResponseResult(Request request, Response response) throws IOException {
if(LOGGER.isDebugEnabled()){
LOGGER.debug("request end，request:{}, response:{}", request, response);
}
ResponseBody responseBody = response.body();
OkHttpClientResult result = new OkHttpClientResult();
result.setSuccess(response.isSuccessful());
result.setCode(response.code());
result.setMessage(response.message());
result.setHeaders(response.headers().toMultimap());
if(Objects.nonNull(responseBody)){
result.setBody(responseBody.bytes());
}
if(!result.isSuccess()){
LOGGER.warn("request fail, request:{}, response:{}", request, response);
}
return result;
}
}相關的返回實體類對象
public class OkHttpClientResult {
/**
* 是否成功
*/
private boolean success = false;
/**
* http級，狀態標識碼
*/
private Integer code;
/**
* http級，錯誤信息
*/
private String message;
/**
* http級，返回頭部
*/
private Map<String, List<String>> headers;
/**
* http級，返回body
*/
private byte[] body;
public boolean isSuccess() {
return success;
}
public void setSuccess(boolean success) {
this.success = success;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public Map<String, List<String>> getHeaders() {
return headers;
}
public void setHeaders(Map<String, List<String>> headers) {
this.headers = headers;
}
public byte[] getBody() {
return body;
}
public void setBody(byte[] body) {
this.body = body;
}
public OkHttpClientResult() {
}
public OkHttpClientResult(boolean success, int code, String message) {
this.success = success;
this.code = code;
this.message = message;
}
}最后，基于以上的方法，封裝一個獨立的網絡請求工具類
public class OkHttpClientUtils {
/**
* get請求
* @param url
* @param headers
* @return
*/
public static String get(String url, Map<String, String> headers){
Request request = new Request.Builder()
.url(url)
.headers(buildHeaders(headers))
.get()
.build();
OkHttpClientResult result = commonRequest(request);
return buildResponse(result);
}
/**
* get請求（支持范型對象返回參數）
* @param url
* @param headers
* @param responseType
* @param <T>
* @return
*/
public static <T> T get(String url, Map<String, String> headers, TypeReference<T> responseType){
Request request = new Request.Builder()
.url(url)
.headers(buildHeaders(headers))
.get()
.build();
OkHttpClientResult result = commonRequest(request);
return buildResponse(result, responseType);
}
/**
* post表單請求
* @param url
* @param paramMap
* @param headers
* @return
*/
public static String postByForm(String url, Map<String, String> paramMap, Map<String, String> headers){
Request request = new Request.Builder()
.url(url)
.headers(buildHeaders(headers))
.post(buildFormBody(paramMap))
.build();
OkHttpClientResult result = commonRequest(request);
return buildResponse(result);
}
/**
* post表單請求（支持范型對象返回參數）
* @param url
* @param paramMap
* @param headers
* @param responseType
* @param <T>
* @return
*/
public static <T> T postByForm(String url, Map<String, String> paramMap, Map<String, String> headers, TypeReference<T> responseType){
Request request = new Request.Builder()
.url(url)
.headers(buildHeaders(headers))
.post(buildFormBody(paramMap))
.build();
OkHttpClientResult result = commonRequest(request);
return buildResponse(result, responseType);
}
/**
* post + json請求
* @param url
* @param value
* @param headers
* @return
*/
public static String postByJson(String url, Object value, Map<String, String> headers){
Request request = new Request.Builder()
.url(url)
.headers(buildHeaders(headers))
.post(buildJsonBody(value))
.build();
OkHttpClientResult result = commonRequest(request);
return buildResponse(result);
}
/**
* post + json請求（支持范型對象返回參數）
* @param url
* @param value
* @param headers
* @param responseType
* @param <T>
* @return
*/
public static <T> T postByJson(String url, Object value, Map<String, String> headers, TypeReference<T> responseType){
Request request = new Request.Builder()
.url(url)
.headers(buildHeaders(headers))
.post(buildJsonBody(value))
.build();
OkHttpClientResult result = commonRequest(request);
return buildResponse(result, responseType);
}
/**
* 包裝請求頭部
* @param headers
* @return
*/
private static Headers buildHeaders(Map<String, String> headers){
Headers.Builder headerBuilder = new Headers.Builder();
if(MapUtils.isNotEmpty(headers)){
headers.entrySet().forEach(entry -> headerBuilder.add(entry.getKey(), entry.getValue()));
}
return headerBuilder.build();
}
/**
* 包裝請求表單
* @param paramMap
* @return
*/
private static FormBody buildFormBody(Map<String, String> paramMap){
FormBody.Builder formBodyBuilder = new FormBody.Builder();
if(MapUtils.isNotEmpty(paramMap)){
paramMap.entrySet().forEach(entry -> formBodyBuilder.add(entry.getKey(), entry.getValue()));
}
return formBodyBuilder.build();
}
/**
* 包裝請求json數據
* @param request
* @return
*/
private static RequestBody buildJsonBody(Object request){
MediaType contentType = MediaType.parse("application/json; charset=utf-8");
RequestBody requestBody = RequestBody.create(contentType, JacksonObjectUtil.objToJson(request));
return requestBody;
}
/**
* 包裝返回結果，針對字符串
* @param result
* @return
*/
private static String buildResponse(OkHttpClientResult result){
if(!result.isSuccess() && StringUtils.isNotBlank(result.getMessage())){
throw new RuntimeException(result.getMessage());
}
return byteToString(result.getBody());
}
/**
* 包裝返回結果，針對返回范型對象
* @param result
* @return
*/
private static <T> T buildResponse(OkHttpClientResult result, TypeReference<T> responseType){
if(!result.isSuccess() && StringUtils.isNotBlank(result.getMessage())){
throw new RuntimeException(result.getMessage());
}
return JacksonObjectUtil.byteToObj(result.getBody(), responseType);
}
/**
* 獲取內容
* @param bytes
* @return
*/
private static String byteToString(byte[] bytes){
if(Objects.nonNull(bytes)){
return new String(bytes, Charset.forName("utf-8"));
}
return StringUtils.EMPTY;
}
/**
* 公共請求調用
* @param request
* @return
*/
private static OkHttpClientResult commonRequest(Request request){
return OkHttpClientBuilder.syncResponse(request);
}
}以上就是基于 OkHttp 封裝的整套工具類，可能有的網友對OkHttpClientBuilder.syncResponse編程方法不太理解，我們會在下面進行詳細的講解。
2.3、封裝對象序列化工具
在上文的OkHttpClientUtils工具類中，我們提到了范型對象的返回。
其中用到了一個很重要的類庫工具，那就是jackson類庫，所以在上文第一段就介紹了導入jackson相關的庫包。
基于jackson庫封裝的工具類JacksonObjectUtil，代碼如下：
public class JacksonObjectUtil {
private static final Logger LOGGER = LoggerFactory.getLogger(JacksonObjectUtil.class);
private static ObjectMapper objectMapper = new ObjectMapper();
static {
// 忽略未知的字段
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
// 讀取不認識的枚舉時，當null值處理
objectMapper.configure(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL, true);
// 全部輸出
objectMapper.configure(JsonParser.Feature.AUTO_CLOSE_SOURCE, true);
}
/**
* 將對象序列化成字節流
* @param value
* @return
*/
public static byte[] objToByte(Object value){
try {
if(Objects.nonNull(value)){
return objectMapper.writeValueAsBytes(value);
}
} catch (Exception e){
LOGGER.warn("將對象序列化成字節失敗",e);
}
return null;
}
/**
* 將對象序列化成json字符串
* @param value
* @return
*/
public static String objToJson(Object value){
try {
if(Objects.nonNull(value)){
return objectMapper.writeValueAsString(value);
}
} catch (Exception e){
LOGGER.warn("將對象序列化成json字符串失敗",e);
}
return "";
}
/**
* 將json字符串轉對象，支持指定類
* @param value
* @return
*/
public static <T> T jsonToObj(String value, Class<T> classType){
try {
if(StringUtils.isNotBlank(value)){
return objectMapper.readValue(value, classType);
}
} catch (Exception e){
LOGGER.warn("將json字符串轉對象失敗，字符串：" + value, e);
}
return null;
}
/**
* 將json字符串轉對象，支持范型類
* @param value
* @return
*/
public static <T> T jsonToObj(String value, TypeReference<T> referenceType){
try {
if(StringUtils.isNotBlank(value)){
return objectMapper.readValue(value, referenceType);
}
} catch (Exception e){
LOGGER.warn("將json字符串轉對象失敗，字符串：" + value, e);
}
return null;
}
/**
* 將字節流轉對象，支持范型類
* @param value
* @return
*/
public static <T> T byteToObj(byte[] value, TypeReference<T> referenceType){
try {
if(Objects.nonNull(value)){
return objectMapper.readValue(value, referenceType);
}
} catch (Exception e){
LOGGER.warn("將字節流轉對象失敗", e);
}
return null;
}
}三、性能測試
在之前的文章中，我們介紹了 OkHttp 支持同步、異步兩種模式的網絡請求編程方法。
其實每種請求方式，帶來的性能體驗也大為不同。
以 200 個線程同時發起網絡請求，同步請求／異步請求耗時如下：
同步請求平均耗時：1997 ms
異步請求平均耗時：1798 ms從數據顯示結果，兩者差異并不大。
下面我們以循環發起 200 請求為例，同步請求／異步請求耗時如下：
同步請求平均耗時：6478 ms
異步請求平均耗時：1794 ms兩者所消耗的時間差異 3 倍，隨著請求次數越多，差異越大。
總結下來，采用異步請求所消耗的時間比同步請求低很多。
基于以上結論，回到上文中介紹的OkHttpClientBuilder類，小編向大家提供了兩個方法。
一個是同步請求的編程方案
/**
* 同步執行請求，公共方法
* @param request
* @return
*/
public static OkHttpClientResult syncRequest(Request request){
try (Response response = okHttpClient.newCall(request).execute()){
return buildResponseResult(request, response);
} catch (Exception e) {
LOGGER.error("request error，request:" + request, e);
return new OkHttpClientResult(false, 500, "request error");
}
}另一個是異步請求，同步阻塞等待返回結果的編程方案。
/**
* 異步執行請求，同步阻塞編程等待返回結果
* 此方式在多線程環境下請求處理依然能保持高性能，根據不同的場景顯式對ConnectionPool進行調優處理
* @param request
* @return
*/
public static OkHttpClientResult syncResponse(Request request){
if(LOGGER.isDebugEnabled()){
LOGGER.debug("request start，request:{}", request);
}
// 使用異步編程，在指定時間內阻塞獲取 OKHttp 異步執行結果
CompletableFuture<Response> completableFuture = new CompletableFuture();
// 發起異步請求調用
Call call = okHttpClient.newCall(request);
call.enqueue(new Callback(){
@Override
public void onFailure(Call call, IOException e) {
completableFuture.completeExceptionally(e);
}
@Override
public void onResponse(Call call, Response response) throws IOException {
completableFuture.complete(response);
}
});
// 這里的異步執行結果等待時間，取決于get同步獲取時間的設定，而不是全局請求超時配置
try (Response response = completableFuture.get(DEFAULT_WAIT_TIMEOUT, TimeUnit.MILLISECONDS);) {
return buildResponseResult(request, response);
} catch (TimeoutException e){
call.cancel();
LOGGER.error("request timeout，request:" + request, e);
return new OkHttpClientResult(false, 500, "request timeout");
} catch (Exception e){
LOGGER.error("request error，request:" + request, e);
return new OkHttpClientResult(false, 500, "request error");
}
}此方案其實本質是采用 OkHttp 異步請求的方式來編程，只是為了滿足業務上同步返回請求結果，加入了CompletableFuture異步編程類，通過同步阻塞的方式來獲取響應結果，以滿足高性能的網絡請求需要。
為了眼見為實，同步請求和異步請求同步阻塞等待結果，我們看看不同的請求模式下，請求所耗時的時間情況。
以循環發起多次請求為例，統計結果如下：
以同一時刻，發起多次請求為例，統計結果如下：
從數據的結論上看，如上面的分析一樣，在循環請求場景下，兩者幾乎無差異，但是在多線程請求場景下，兩者差異很明顯。
采用異步請求同步阻塞等待結果這種編程方式，能有效的降低接口請求所消耗的時間。
為什么在多線程環境下，異步請求同步阻塞等待結果這種方式能顯著的提升效率呢，其實答案也很簡單，因為 OkHttp 在進行異步請求的時候，使用了線程池來進行執行任務，能有效的管理需要執行的任務。
而采用同步編程的方式，執行的時候是直接發起同步調用的，無線程池管理，這就可能會出現一個問題，當瞬間出現大量的線程發起請求的時候，可能會導致 cpu 突然利用率飆升，資源會嚴重擠壓占用，反而不利于任務的有效執行。
最后有一個地方特別需要注意，如果項目中使用了自定義的線程池來異步的執行任務，一定要向JVM注冊一個關閉鉤子，當 JVM 監聽到服務關閉時，可以通過代碼檢查邏輯，等待線程池中的任務執行完畢之后，再關停服務，以防止數據丟失。
責任編輯：武曉燕
來源：
Java極客技術
