okHttp客户端编程样例

    本文主要描述使用okHttp实现简单的客户端，仅支持REST调用，即请求和响应均为文本，可以作为RestTemplate底层的实现支撑。

    1、基于okHttp 3.10.0 + 

    2、仅实现同步调用。

    3、通用客户端，仅支持Rest调用，即请求和响应均为文本类型。

 

    类列表：

    1、HttpClientConfiguration：客户端的主要配置，包括连接超时、连接池大小等。

    2、HttpClientTemplate：接口，描述了客户端支持的基本操作。

    3、AbstractHttpClientTemplate：2、接口的基本实现，主要用于构建默认参数和方法。

    4、OkHttpClientTemplate：主要实现类，用户描述GET/POST操作的过程。

    5、OkHttpClientBuilder：静态类，用于外部便捷的构建client，可以被spring、springboot集成（自动装配时使用）。

 

一、HttpClientConfiguration

/**
 * HTTP Client配置管理
 **/
public class HttpClientConfiguration implements Serializable {

    //目前不能修改，常量值
    private static final int DEFAULT_MAX_CONNECTIONS = 1024;

    //连接创建
    public static final long DEFAULT_CONNECTION_TIMEOUT = 500;
    //SO_TIMEOUT
    public static final long DEFAULT_SOCKET_TIMEOUT = 500;

    //连接池中的连接被保活的时长
    public static final long DEFAULT_KEEP_ALIVE_TIME = 6000;

    //请求异常（exception），重试的次数，默认为0，不重试
    public static final int DEFAULT_HTTP_RETRY_TIMES = 0;
    //是否重试
    public static final boolean DEFAULT_HTTP_RETRY_ON_FAILURE = false;

    public static final int DEFAULT_CONNECTION_REQUEST_TIMEOUT = 1500;

    public static final String HTTP_CLIENT_TYPE_OK_HTTP = "okHttp";

    public static final String HTTP_CLIENT_TYPE_HTTP_COMPONENTS = "httpComponents";

    //连接创建
    private long connectionTimeout = DEFAULT_CONNECTION_TIMEOUT;
    //SO_TIMEOUT
    private long socketTimeout = DEFAULT_SOCKET_TIMEOUT;

    //连接池中的连接被保活的时长
    private long keepAliveTime = DEFAULT_KEEP_ALIVE_TIME;

    //请求异常（exception），重试的次数，默认为0，不重试
    private int retryTimes = DEFAULT_HTTP_RETRY_TIMES;
    //是否重试
    private boolean retryOnFailure = DEFAULT_HTTP_RETRY_ON_FAILURE;

    private String charset = ContextConstants.DEFAULT_CHARSET;

    //全局headers，即所有请求都会添加
    private Map<String, String> globalHeaders;

    private int connectionRequestTimeout = 1500;

    private String clientType = HTTP_CLIENT_TYPE_HTTP_COMPONENTS;

    public void setConnectionTimeout(Long connectionTimeout) {
        this.connectionTimeout = connectionTimeout;
    }

    public void setSocketTimeout(Long socketTimeout) {
        this.socketTimeout = socketTimeout;
    }

    public void setKeepAliveTime(Long keepAliveTime) {
        this.keepAliveTime = keepAliveTime;
    }

    public void setRetryTimes(Integer retryTimes) {
        this.retryTimes = retryTimes;
    }

    public void setRetryOnFailure(Boolean retryOnFailure) {
        this.retryOnFailure = retryOnFailure;
    }

    public void setCharset(String charset) {
        this.charset = charset;
    }

    public Long getConnectionTimeout() {
        return connectionTimeout;
    }

    public Long getSocketTimeout() {
        return socketTimeout;
    }

    public Long getKeepAliveTime() {
        return keepAliveTime;
    }

    public Integer getRetryTimes() {
        return retryTimes;
    }

    public Boolean getRetryOnFailure() {
        return retryOnFailure;
    }

    public String getCharset() {
        return charset;
    }

    public Map<String, String> getGlobalHeaders() {
        return globalHeaders;
    }

    public void setGlobalHeaders(Map<String, String> globalHeaders) {
        this.globalHeaders = globalHeaders;
    }

    public int getMaxConnections() {
        return DEFAULT_MAX_CONNECTIONS;
    }

    public int getConnectionRequestTimeout() {
        return connectionRequestTimeout;
    }


    public void setConnectionRequestTimeout(int connectionRequestTimeout) {
        this.connectionRequestTimeout = connectionRequestTimeout;
    }

    public String getClientType() {
        return clientType;
    }

    public void setClientType(String clientType) {
        this.clientType = clientType;
    }

    private HttpClientConfiguration() {
    }

    /**
     * 构建一个常规配置
     *
     * @param globalHeaders
     * @return
     */
    public static HttpClientConfiguration common(Map<String, String> globalHeaders) {
        HttpClientConfiguration configuration = new HttpClientConfiguration();
        configuration.setCharset(ContextConstants.DEFAULT_CHARSET);//UTF-8
        configuration.setConnectionTimeout(DEFAULT_CONNECTION_TIMEOUT);//500
        configuration.setSocketTimeout(DEFAULT_SOCKET_TIMEOUT);//500
        configuration.setKeepAliveTime(DEFAULT_KEEP_ALIVE_TIME);//6000
        configuration.setRetryOnFailure(DEFAULT_HTTP_RETRY_ON_FAILURE);//FALSE
        configuration.setRetryTimes(DEFAULT_HTTP_RETRY_TIMES);//0
        if (globalHeaders != null) {
            configuration.setGlobalHeaders(globalHeaders);
        }
        configuration.setConnectionRequestTimeout(DEFAULT_CONNECTION_REQUEST_TIMEOUT);
        return configuration;
    }

    public static HttpClientConfiguration common() {
        return common(null);
    }


}

 

    1）connectionTimeout、socketTimeout，我们约定为500ms，对于普通WEB接口而言，此参数为权衡值，你可以根据自己的业务现状适度调整。

    2）keepAliveTime：连接池中的连接被保活的时长，默认为6000ms，不建议设置太大。

    3）retryOnFailure：当请求调用失败时，是否支持重试，失败主要为IO异常，强烈建议此值为false。

    4）retryTimes：当retryOnFailure=true时，失败重试的次数，建议为0。

    5）连接池容量，需要注意okHttp其实不支持设置此值。为了与Apache HttpClient保持相同参数列表。

 

二、HttpClientTemplate

public interface HttpClientTemplate extends BeanLifeCycle {

    /**
     * 普通get操作
     *
     * @param uri 不应该包含查询字符串
     * @return
     */
    public String get(String uri);

    /**
     * @param uri        不包含查询字符串
     * @param parameters 查询字符串，编码之前原始字符串，内部会提供编码和转义。默认UTF-8
     * @return
     */
    public String get(String uri, Map<String, String> parameters);

    /**
     * @param uri        不应该包含查询字符串
     * @param parameters 查询字符串，编码之前的原始字符串
     * @param headers    http header
     * @return
     */
    public String get(String uri, Map<String, String> parameters, Map<String, String> headers);

    /**
     * 普通post
     *
     * @param uri 不应该包含查询字符串
     * @return
     */
    public String post(String uri);

    /**
     * 数据将通过body发送
     *
     * @param uri     不应该包含查询字符串
     * @param content JSON内容文本，应该使用与client相同的编码进行
     * @return
     */
    public String post(String uri, String content);

    /**
     * 数据将通过body发送
     *
     * @param uri        不应该包含查询字符串
     * @param content    JSON格式文本
     * @param parameters 查询字符串
     * @return
     */
    public String post(String uri, String content, Map<String, String> parameters);

    /**
     * 数据将通过body发送
     *
     * @param uri        不应该包含查询字符串
     * @param content    JSON格式文本，body
     * @param parameters 查询字符串
     * @param headers    headers
     * @return
     */
    public String post(String uri, String content, Map<String, String> parameters, Map<String, String> headers);

    /**
     * 返回底层的httpClient，通常情况是用户希望直接使用此client做自定义操作。
     *
     * @return
     */
    public Object getClient();

    public String clientType();
}

 

 

三、AbstractHttpClientTemplate

public abstract class AbstractHttpClientTemplate implements HttpClientTemplate {

    //全局headers，即所有请求都会添加，可以被用户指定的headers覆盖
    protected Map<String, String> globalHeaders;

    protected static final String CONTENT_TYPE_JSON = "application/json";//default
    //json格式，限定
    protected static final String CONTENT_TYPE_JSON_PATTERN = CONTENT_TYPE_JSON + "; charset={0}";//default

    protected HttpClientConfiguration configuration = HttpClientConfiguration.common();

    protected String charset = configuration.getCharset();

    private volatile boolean init = false;

    public AbstractHttpClientTemplate() {
    }

    public AbstractHttpClientTemplate(HttpClientConfiguration configuration) {
        if (configuration != null) {
            this.configuration = configuration;
            this.globalHeaders = configuration.getGlobalHeaders();
        }
    }

    public void setGlobalHeaders(Map<String, String> globalHeaders) {
        this.globalHeaders = globalHeaders;
        configuration.setGlobalHeaders(globalHeaders);
    }

    public synchronized void init() {
        if (init) {
            return;
        }
        init = true;
    }

    protected HttpClientConfiguration configuration() {
        return this.configuration;
    }

}

 

 

四、OkHttpClientTemplate实现类

import okhttp3.*;
import org.apache.commons.lang3.StringUtils;

import java.io.IOException;
import java.net.URLEncoder;
import java.text.MessageFormat;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 **/
public class OkHttpClientTemplate extends AbstractHttpClientTemplate {


    private OkHttpClient httpClient;
    private volatile boolean init = false;

    private List<Interceptor> interceptors;

    public void setInterceptors(List<Interceptor> interceptors) {
        this.interceptors = interceptors;
    }

    public OkHttpClientTemplate() {
        super();
    }

    public OkHttpClientTemplate(HttpClientConfiguration configuration) {
        super(configuration);
    }

    @Override
    public synchronized void init() {
        if (init) {
            return;
        }
        super.init();
        httpClient = OkHttpClientBuilder.build(configuration(), interceptors);
        init = true;
    }

    @Override
    public String get(String uri) {
        return get(uri, null);
    }

    @Override
    public String get(String uri, Map<String, String> parameters) {
        return get(uri, parameters, null);
    }

    @Override
    public String get(String uri, Map<String, String> parameters, Map<String, String> headers) {
        if (StringUtils.isBlank(uri)) {
            return null;
        }
        try {
            Request.Builder builder = new Request.Builder();
            builder.url(url(uri, parameters));
            builder.header("Content-type", MessageFormat.format(CONTENT_TYPE_JSON_PATTERN, charset));
            headers(builder, headers);
            Request request = builder.get().build();
            return process(request);
        } catch (Exception e) {
            throw new RuntimeException("HttpClient error.", e);
        }
    }

    /**
     * 将URI与查询字符串进行编码拼装。
     *
     * @param uri
     * @param parameters
     * @return
     * @throws Exception
     */
    private String url(String uri, Map<String, String> parameters) throws Exception {
        if (parameters == null || parameters.isEmpty()) {
            return uri;
        }
        StringBuilder sb = new StringBuilder(uri);
        if (uri.indexOf("?") == -1) {
            sb.append("?1=1");
        }
        for (Map.Entry<String, String> entry : parameters.entrySet()) {
            String value = entry.getValue();
            String encodedValue = "";
            //如果value为null，使用空串
            if (value != null) {
                encodedValue = URLEncoder.encode(entry.getValue(), charset);
            }
            sb.append("&").append(entry.getKey())
                    .append("=")
                    .append(encodedValue);
        }
        return sb.toString();
    }

    /**
     * 整合headers，将用户指定的请求headers与配置的globalHeaders进行merge，并添加到request中。
     *
     * @param builder
     * @param headers
     */
    private void headers(Request.Builder builder, Map<String, String> headers) {
        if (headers == null && globalHeaders == null) {
            return;
        }

        Map<String, String> _headers = new HashMap<>();
        if (globalHeaders != null && !globalHeaders.isEmpty()) {
            _headers.putAll(globalHeaders);
        }
        if (headers != null && !headers.isEmpty()) {
            _headers.putAll(headers);//允许自定义header覆盖全局
        }

        for (Map.Entry<String, String> entry : _headers.entrySet()) {
            String value = entry.getValue() == null ? "" : entry.getValue();
            builder.header(entry.getKey(), value);
        }
    }

    @Override
    public String post(String uri) {
        return post(uri, null);
    }

    @Override
    public String post(String uri, String content) {
        return post(uri, content, null);
    }

    @Override
    public String post(String uri, String content, Map<String, String> parameters) {
        return post(uri, content, parameters, null);
    }

    @Override
    public String post(String uri, String content, Map<String, String> parameters, Map<String, String> headers) {
        if (StringUtils.isBlank(uri)) {
            return null;
        }
        try {
            Request.Builder builder = new Request.Builder();
            builder.url(url(uri, parameters));
            headers(builder, headers);

            String contentType = MessageFormat.format(CONTENT_TYPE_JSON_PATTERN, charset);
            RequestBody body = RequestBody.create(MediaType.parse(contentType), content);
            builder.post(body);

            Request request = builder.build();
            return process(request);
        } catch (Exception e) {
            throw new RuntimeException("HttpClient error.", e);
        }
    }

    private String process(Request request) throws Exception {
        Response response = null;
        try {
            response = httpClient.newCall(request).execute();
            int statusCode = response.code();
            if (statusCode != 200) {
                throw new RuntimeException("HttpClient error,status =" + response.code() + ",message:" + response.message());
            }
            ResponseBody body = response.body();
            String result = null;
            if (body != null) {
                result = body.string();
            }
            return result;
        } finally {
            if (response != null) {
                response.close();
            }
        }
    }

    @Override
    public OkHttpClient getClient() {
        return httpClient;
    }

    @Override
    public String clientType() {
        return HttpClientConfiguration.HTTP_CLIENT_TYPE_OK_HTTP;
    }

    @Override
    public void close() throws IOException {
        if (httpClient != null) {
            httpClient.dispatcher().executorService().shutdown();
        }
    }
}

 

五、OkHttpClientBuilder构建类

import okhttp3.ConnectionPool;
import okhttp3.Interceptor;
import okhttp3.OkHttpClient;

import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * 基于OkHttp实现的客户端,辅助builder，适用于外部应用在没有context配置情况下构建内置的HTTP组件
 * okHttp的优点很多：特别的高效、简单易控、默认线程池、自动保活 + 断链等。
 * 缺点就是：特性略少，不能便捷的自定义很多特殊的场景，比如cookie、form表单等等。
 * <p>
 * 当使用者希望自己构建httpClient时，可以使用builder。
 **/
public final class OkHttpClientBuilder {

    public static OkHttpClient build(HttpClientConfiguration configuration) {
        return build(configuration, null);
    }

    /**
     * used OkHttp
     *
     * @return
     */
    public static OkHttpClient build(HttpClientConfiguration configuration, List<Interceptor> interceptors) {
        OkHttpClient.Builder builder = new OkHttpClient.Builder();
        builder.connectTimeout(configuration.getConnectionTimeout(), TimeUnit.MILLISECONDS);

        //不能设置最大连接数，默认连接是可重用的。
        ConnectionPool connectionPool = new ConnectionPool(3, configuration.getKeepAliveTime(), TimeUnit.MILLISECONDS);
        builder.connectionPool(connectionPool);

        builder.readTimeout(configuration.getSocketTimeout(), TimeUnit.MILLISECONDS);
        builder.retryOnConnectionFailure(configuration.getRetryOnFailure());
        builder.writeTimeout(configuration.getSocketTimeout(), TimeUnit.MILLISECONDS);
        if (interceptors != null) {
            for (Interceptor interceptor : interceptors) {
                builder.addInterceptor(interceptor);
            }
        }

        return builder.build();
    }

    /**
     * 基于常规默认
     *
     * @return
     */
    public static OkHttpClient build() {
        HttpClientConfiguration configuration = HttpClientConfiguration.common();
        return build(configuration);
    }
}