OkHttpUtils常用

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.12.0</version>
</dependency>

public class OkHttpUtils {

    private static final Logger LOGGER = LoggerFactory.getLogger(OkHttpUtils.class);
    private static final OkHttpClient okHttpClient;
    private Map<String, String> headerMap;
    private Map<String, String> paramMap;
    private String url;
    private Request.Builder request;

    private OkHttpUtils() {
    }


    /**
     * 初始化okHttpClient，并且允许https访问
     */
    static {
        TrustManager[] trustManagers = buildTrustManagers();
        okHttpClient = new OkHttpClient.Builder()
                .connectTimeout(15, TimeUnit.SECONDS)
                .writeTimeout(20, TimeUnit.SECONDS)
                .readTimeout(20, TimeUnit.SECONDS)
                .sslSocketFactory(createSSLSocketFactory(trustManagers), (X509TrustManager) trustManagers[0])
                .hostnameVerifier((hostName, session) -> true)
                .retryOnConnectionFailure(true)
                .build();
    }
    

    /**
     * 创建OkHttpUtils
     *
     * @return
     **/
    public static OkHttpUtils builder() {
        return new OkHttpUtils();
    }

    /**
     * 添加url
     *
     * @param url
     * @return
     */
    public OkHttpUtils url(String url) {
        this.url = url;
        return this;
    }

    /**
     * 添加参数---表单/get请求
     *
     * @param key   参数名
     * @param value 参数值
     * @return
     */
    public OkHttpUtils addParam(String key, String value) {
        if (paramMap == null) {
            paramMap = new LinkedHashMap<>(16);
        }
        paramMap.put(key, value);
        return this;
    }

    /**
     * 添加请求头
     *
     * @param key   参数名
     * @param value 参数值
     * @return
     */
    public OkHttpUtils addHeader(String key, String value) {
        if (headerMap == null) {
            headerMap = new LinkedHashMap<>(16);
        }
        headerMap.put(key, value);
        return this;
    }

    /**
     * 初始化get方法
     *
     * @return
     */
    public OkHttpUtils get() {
        request = new Request.Builder().get();
        StringBuilder urlBuilder = new StringBuilder(url);
        if (paramMap != null) {
            urlBuilder.append("?");
            try {
                for (Map.Entry<String, String> entry : paramMap.entrySet()) {
                    urlBuilder.append(URLEncoder.encode(entry.getKey(), "utf-8")).
                            append("=").
                            append(URLEncoder.encode(entry.getValue(), "utf-8")).
                            append("&");
                }
            } catch (Exception e) {
                LOGGER.info("get请求组织参数异常{}", e.getMessage());
            }
            urlBuilder.deleteCharAt(urlBuilder.length() - 1);
        }
        request.url(urlBuilder.toString());
        return this;
    }

    /**
     * 表单请求
     *
     * @return
     */
    public OkHttpUtils postForm() {
        FormBody.Builder formBody = new FormBody.Builder();

        if (paramMap != null) {
            paramMap.forEach(formBody::add);
        }
        RequestBody requestBody = formBody.build();

        request = new Request.Builder().post(requestBody).url(url);
        return this;
    }
    /**
     * 表单请求
     * @param paramMapObj   参数
     * @return string
     */
    public  String postForm(Map<String, Object> paramMapObj) {
        FormBody.Builder formBody = new FormBody.Builder();
        for (Map.Entry<String, Object> entry : paramMapObj.entrySet()) {
            formBody.add(entry.getKey(), String.valueOf(entry.getValue()));
        }
        RequestBody requestBody = formBody.build();
        Request.Builder request = new Request.Builder().post(requestBody).url(url);
        try (Response response = okHttpClient.newCall(request.build()).execute()) {
            boolean successful = response.isSuccessful();
            //Assert.isTrue(successful,"请求返回失败");
            assert response.body() != null;
            return response.body().string();
        } catch (Exception e) {
            LOGGER.info("请求异常{},详情{}",url, e.getStackTrace());
            return "请求失败：" + e.getMessage();
        }

    }

    /**
     * json参数请求
     *
     * @param paramJson 参数值
     * @return
     */
    public OkHttpUtils postJson(String paramJson) {

        RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=UTF-8"), paramJson);

        request = new Request.Builder().post(requestBody).url(url);
        return this;
    }

    /**
     * 同步请求
     *
     * @return
     */
    public String sync() {
        setHeader(request);
        try (Response response = okHttpClient.newCall(request.build()).execute()) {
            boolean successful = response.isSuccessful();
            assert response.body() != null;
            return response.body().string();
        } catch (Exception e) {
            LOGGER.info("请求异常{},详情{}", e.getMessage(), e.getStackTrace());
            return "请求失败：" + e.getMessage();
        }
    }

    /**
     * 异步请求，带有接口回调
     *
     * @param callBack
     */
    public void async(ICallBack callBack) {
        setHeader(request);
        okHttpClient.newCall(request.build()).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                callBack.onFailure(call, e.getMessage());
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                assert response.body() != null;
                callBack.onSuccessful(call, response.body().string());
            }
        });
    }

    /**
     * 为request添加请求头
     *
     * @param request
     */
    private void setHeader(Request.Builder request) {
        if (headerMap != null) {
            for (Map.Entry<String, String> entry : headerMap.entrySet()) {
                request.addHeader(entry.getKey(), entry.getValue());
            }
        }
    }


    /**
     * 生成安全套接字工厂，用于https请求的证书跳过
     *
     * @return
     */
    private static SSLSocketFactory createSSLSocketFactory(TrustManager[] trustAllCerts) {
        SSLSocketFactory ssfFactory = null;
        try {
            SSLContext sc = SSLContext.getInstance("SSL");
            sc.init(null, trustAllCerts, new SecureRandom());
            ssfFactory = sc.getSocketFactory();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ssfFactory;
    }

    private static TrustManager[] buildTrustManagers() {
        return new TrustManager[]{
                new X509TrustManager() {
                    @Override
                    public void checkClientTrusted(X509Certificate[] chain, String authType) {
                    }

                    @Override
                    public void checkServerTrusted(X509Certificate[] chain, String authType) {
                    }

                    @Override
                    public X509Certificate[] getAcceptedIssuers() {
                        return new X509Certificate[]{};
                    }
                }
        };
    }

    /**
     * 自定义一个接口回调
     */
    public interface ICallBack {

        void onSuccessful(Call call, String data);

        void onFailure(Call call, String errorMsg);

    }
}