手動(dòng)封裝了一個(gè) OkHttp3 工具類，用著賊舒服
作者：了不起
為什么在多線程環(huán)境下，異步請(qǐng)求同步阻塞等待結(jié)果這種方式能顯著的提升效率呢，其實(shí)答案也很簡(jiǎn)單，因?yàn)?OkHttp 在進(jìn)行異步請(qǐng)求的時(shí)候，使用了線程池來(lái)進(jìn)行執(zhí)行任務(wù)，能有效的管理需要執(zhí)行的任務(wù)。
一、摘要
在前幾篇文章中，我們介紹了 OKHttp 相關(guān)的使用操作方式，相信大家對(duì)它已經(jīng)有了初步的了解。
在實(shí)際的系統(tǒng)開發(fā)過(guò)程中，我們通常會(huì)基于項(xiàng)目環(huán)境，封裝一個(gè)公共的網(wǎng)絡(luò)請(qǐng)求工具庫(kù)，以便開發(fā)接口請(qǐng)求相關(guān)的需求時(shí)，能更加方便的使用。
以服務(wù)端編程為例，以下是小編封裝工具類的實(shí)踐過(guò)程。
二、案例實(shí)踐
2.1、首先在項(xiàng)目中導(dǎo)入相關(guān)的依賴包
<!-- 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 相關(guān)請(qǐng)求方法
首先將 OkHttpClient 客戶端配置參數(shù)單獨(dú)拎出來(lái)，方便后續(xù)獨(dú)立配置。
public class OkHttpClientFactory {
/**
* 默認(rèn)允許的最大并發(fā)數(shù)
*/
private static int concurrentSize = 100;
private OkHttpClientFactory(){}
/**
* 實(shí)例化客戶端配置
* @return
*/
public static OkHttpClient.Builder newInstance() {
OkHttpClient.Builder httpClientBuilder = new OkHttpClient.Builder();
// 設(shè)置超時(shí)時(shí)間
httpClientBuilder.connectTimeout(5, TimeUnit.SECONDS);
httpClientBuilder.writeTimeout(5, TimeUnit.SECONDS);
httpClientBuilder.readTimeout(5, TimeUnit.SECONDS);
// 設(shè)置連接池，連接池的最大數(shù)量=并發(fā)數(shù)，30秒空閑的連接會(huì)釋放掉
httpClientBuilder.connectionPool(new ConnectionPool(concurrentSize, 30, TimeUnit.SECONDS));
// 設(shè)置分發(fā)器處理的最大容量，這里的數(shù)量=連接池?cái)?shù)量=并發(fā)數(shù)，表示此客戶端有同時(shí)能夠處理xx并發(fā)數(shù)的能力
Dispatcher dispatcher = new Dispatcher();
dispatcher.setMaxRequests(concurrentSize);
dispatcher.setMaxRequestsPerHost(concurrentSize);
httpClientBuilder.dispatcher(dispatcher);
return httpClientBuilder;
}
}然后，構(gòu)建一個(gè) OkHttpClient 客戶端單例對(duì)象。
public class OkHttpClientBuilder {
private static final Logger LOGGER = LoggerFactory.getLogger(OkHttpClientBuilder.class);
/**
* 同步阻塞等待執(zhí)行結(jié)果的時(shí)間，單位毫秒
*/
private static Integer DEFAULT_WAIT_TIMEOUT = 3000;
/**
* 服務(wù)啟動(dòng)時(shí)初始化OkHttpClient對(duì)象，確?？蛻舳藢?duì)象單例
*/
private static OkHttpClient okHttpClient = OkHttpClientFactory.newInstance().build();
private OkHttpClientBuilder() {}
static {
// 向JVM注冊(cè)一個(gè)關(guān)閉鉤子，當(dāng)服務(wù)準(zhǔn)備停止時(shí)，等待 OkHttpClient 中任務(wù)執(zhí)行完畢再停止，防止線程池中正在執(zhí)行的任務(wù)突然中斷
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;
}
// 防止無(wú)限循環(huán)
if (--count == 0) {
LOGGER.error("ShutdownHook timeout：queuedCallsCount {} , runningCallsCount {}", dispatcher.queuedCallsCount(), dispatcher.runningCallsCount());
break;
}
}
logger.info("ShutdownHook end：queuedCallsCount {} , runningCallsCount {}", dispatcher.queuedCallsCount(), dispatcher.runningCallsCount());
}
}));
}
/**
* 同步執(zhí)行請(qǐng)求，公共方法
* @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");
}
}
/**
* 異步執(zhí)行請(qǐng)求，同步阻塞編程等待返回結(jié)果
* 此方式在多線程環(huán)境下請(qǐng)求處理依然能保持高性能，根據(jù)不同的場(chǎng)景顯式對(duì)ConnectionPool進(jìn)行調(diào)優(yōu)處理
* @param request
* @return
*/
public static OkHttpClientResult syncResponse(Request request){
if(LOGGER.isDebugEnabled()){
LOGGER.debug("request start，request:{}", request);
}
// 使用異步編程，在指定時(shí)間內(nèi)阻塞獲取 OKHttp 異步執(zhí)行結(jié)果
CompletableFuture<Response> completableFuture = new CompletableFuture();
// 發(fā)起異步請(qǐng)求調(diào)用
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);
}
});
// 這里的異步執(zhí)行結(jié)果等待時(shí)間，取決于get同步獲取時(shí)間的設(shè)定，而不是全局請(qǐng)求超時(shí)配置
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;
}
}相關(guān)的返回實(shí)體類對(duì)象
public class OkHttpClientResult {
/**
* 是否成功
*/
private boolean success = false;
/**
* http級(jí)，狀態(tài)標(biāo)識(shí)碼
*/
private Integer code;
/**
* http級(jí)，錯(cuò)誤信息
*/
private String message;
/**
* http級(jí)，返回頭部
*/
private Map<String, List<String>> headers;
/**
* http級(jí)，返回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;
}
}最后，基于以上的方法，封裝一個(gè)獨(dú)立的網(wǎng)絡(luò)請(qǐng)求工具類
public class OkHttpClientUtils {
/**
* get請(qǐng)求
* @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請(qǐng)求（支持范型對(duì)象返回參數(shù)）
* @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表單請(qǐng)求
* @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表單請(qǐng)求（支持范型對(duì)象返回參數(shù)）
* @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請(qǐng)求
* @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請(qǐng)求（支持范型對(duì)象返回參數(shù)）
* @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);
}
/**
* 包裝請(qǐng)求頭部
* @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();
}
/**
* 包裝請(qǐng)求表單
* @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();
}
/**
* 包裝請(qǐng)求json數(shù)據(jù)
* @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;
}
/**
* 包裝返回結(jié)果，針對(duì)字符串
* @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());
}
/**
* 包裝返回結(jié)果，針對(duì)返回范型對(duì)象
* @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);
}
/**
* 獲取內(nèi)容
* @param bytes
* @return
*/
private static String byteToString(byte[] bytes){
if(Objects.nonNull(bytes)){
return new String(bytes, Charset.forName("utf-8"));
}
return StringUtils.EMPTY;
}
/**
* 公共請(qǐng)求調(diào)用
* @param request
* @return
*/
private static OkHttpClientResult commonRequest(Request request){
return OkHttpClientBuilder.syncResponse(request);
}
}以上就是基于 OkHttp 封裝的整套工具類，可能有的網(wǎng)友對(duì)OkHttpClientBuilder.syncResponse編程方法不太理解，我們會(huì)在下面進(jìn)行詳細(xì)的講解。
2.3、封裝對(duì)象序列化工具
在上文的OkHttpClientUtils工具類中，我們提到了范型對(duì)象的返回。
其中用到了一個(gè)很重要的類庫(kù)工具，那就是jackson類庫(kù)，所以在上文第一段就介紹了導(dǎo)入jackson相關(guān)的庫(kù)包。
基于jackson庫(kù)封裝的工具類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);
// 讀取不認(rèn)識(shí)的枚舉時(shí)，當(dāng)null值處理
objectMapper.configure(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL, true);
// 全部輸出
objectMapper.configure(JsonParser.Feature.AUTO_CLOSE_SOURCE, true);
}
/**
* 將對(duì)象序列化成字節(jié)流
* @param value
* @return
*/
public static byte[] objToByte(Object value){
try {
if(Objects.nonNull(value)){
return objectMapper.writeValueAsBytes(value);
}
} catch (Exception e){
LOGGER.warn("將對(duì)象序列化成字節(jié)失敗",e);
}
return null;
}
/**
* 將對(duì)象序列化成json字符串
* @param value
* @return
*/
public static String objToJson(Object value){
try {
if(Objects.nonNull(value)){
return objectMapper.writeValueAsString(value);
}
} catch (Exception e){
LOGGER.warn("將對(duì)象序列化成json字符串失敗",e);
}
return "";
}
/**
* 將json字符串轉(zhuǎn)對(duì)象，支持指定類
* @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字符串轉(zhuǎn)對(duì)象失敗，字符串：" + value, e);
}
return null;
}
/**
* 將json字符串轉(zhuǎn)對(duì)象，支持范型類
* @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字符串轉(zhuǎn)對(duì)象失敗，字符串：" + value, e);
}
return null;
}
/**
* 將字節(jié)流轉(zhuǎn)對(duì)象，支持范型類
* @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("將字節(jié)流轉(zhuǎn)對(duì)象失敗", e);
}
return null;
}
}三、性能測(cè)試
在之前的文章中，我們介紹了 OkHttp 支持同步、異步兩種模式的網(wǎng)絡(luò)請(qǐng)求編程方法。
其實(shí)每種請(qǐng)求方式，帶來(lái)的性能體驗(yàn)也大為不同。
以 200 個(gè)線程同時(shí)發(fā)起網(wǎng)絡(luò)請(qǐng)求，同步請(qǐng)求／異步請(qǐng)求耗時(shí)如下：
同步請(qǐng)求平均耗時(shí)：1997 ms
異步請(qǐng)求平均耗時(shí)：1798 ms從數(shù)據(jù)顯示結(jié)果，兩者差異并不大。
下面我們以循環(huán)發(fā)起 200 請(qǐng)求為例，同步請(qǐng)求／異步請(qǐng)求耗時(shí)如下：
同步請(qǐng)求平均耗時(shí)：6478 ms
異步請(qǐng)求平均耗時(shí)：1794 ms兩者所消耗的時(shí)間差異 3 倍，隨著請(qǐng)求次數(shù)越多，差異越大。
總結(jié)下來(lái)，采用異步請(qǐng)求所消耗的時(shí)間比同步請(qǐng)求低很多。
基于以上結(jié)論，回到上文中介紹的OkHttpClientBuilder類，小編向大家提供了兩個(gè)方法。
一個(gè)是同步請(qǐng)求的編程方案
/**
* 同步執(zhí)行請(qǐng)求，公共方法
* @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");
}
}另一個(gè)是異步請(qǐng)求，同步阻塞等待返回結(jié)果的編程方案。
/**
* 異步執(zhí)行請(qǐng)求，同步阻塞編程等待返回結(jié)果
* 此方式在多線程環(huán)境下請(qǐng)求處理依然能保持高性能，根據(jù)不同的場(chǎng)景顯式對(duì)ConnectionPool進(jìn)行調(diào)優(yōu)處理
* @param request
* @return
*/
public static OkHttpClientResult syncResponse(Request request){
if(LOGGER.isDebugEnabled()){
LOGGER.debug("request start，request:{}", request);
}
// 使用異步編程，在指定時(shí)間內(nèi)阻塞獲取 OKHttp 異步執(zhí)行結(jié)果
CompletableFuture<Response> completableFuture = new CompletableFuture();
// 發(fā)起異步請(qǐng)求調(diào)用
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);
}
});
// 這里的異步執(zhí)行結(jié)果等待時(shí)間，取決于get同步獲取時(shí)間的設(shè)定，而不是全局請(qǐng)求超時(shí)配置
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");
}
}此方案其實(shí)本質(zhì)是采用 OkHttp 異步請(qǐng)求的方式來(lái)編程，只是為了滿足業(yè)務(wù)上同步返回請(qǐng)求結(jié)果，加入了CompletableFuture異步編程類，通過(guò)同步阻塞的方式來(lái)獲取響應(yīng)結(jié)果，以滿足高性能的網(wǎng)絡(luò)請(qǐng)求需要。
為了眼見為實(shí)，同步請(qǐng)求和異步請(qǐng)求同步阻塞等待結(jié)果，我們看看不同的請(qǐng)求模式下，請(qǐng)求所耗時(shí)的時(shí)間情況。
以循環(huán)發(fā)起多次請(qǐng)求為例，統(tǒng)計(jì)結(jié)果如下：
以同一時(shí)刻，發(fā)起多次請(qǐng)求為例，統(tǒng)計(jì)結(jié)果如下：
從數(shù)據(jù)的結(jié)論上看，如上面的分析一樣，在循環(huán)請(qǐng)求場(chǎng)景下，兩者幾乎無(wú)差異，但是在多線程請(qǐng)求場(chǎng)景下，兩者差異很明顯。
采用異步請(qǐng)求同步阻塞等待結(jié)果這種編程方式，能有效的降低接口請(qǐng)求所消耗的時(shí)間。
為什么在多線程環(huán)境下，異步請(qǐng)求同步阻塞等待結(jié)果這種方式能顯著的提升效率呢，其實(shí)答案也很簡(jiǎn)單，因?yàn)?OkHttp 在進(jìn)行異步請(qǐng)求的時(shí)候，使用了線程池來(lái)進(jìn)行執(zhí)行任務(wù)，能有效的管理需要執(zhí)行的任務(wù)。
而采用同步編程的方式，執(zhí)行的時(shí)候是直接發(fā)起同步調(diào)用的，無(wú)線程池管理，這就可能會(huì)出現(xiàn)一個(gè)問(wèn)題，當(dāng)瞬間出現(xiàn)大量的線程發(fā)起請(qǐng)求的時(shí)候，可能會(huì)導(dǎo)致 cpu 突然利用率飆升，資源會(huì)嚴(yán)重?cái)D壓占用，反而不利于任務(wù)的有效執(zhí)行。
最后有一個(gè)地方特別需要注意，如果項(xiàng)目中使用了自定義的線程池來(lái)異步的執(zhí)行任務(wù)，一定要向JVM注冊(cè)一個(gè)關(guān)閉鉤子，當(dāng) JVM 監(jiān)聽到服務(wù)關(guān)閉時(shí)，可以通過(guò)代碼檢查邏輯，等待線程池中的任務(wù)執(zhí)行完畢之后，再關(guān)停服務(wù)，以防止數(shù)據(jù)丟失。
責(zé)任編輯：武曉燕
來(lái)源：
Java極客技術(shù)
