OkHttp3 工具类

---

对请求的封装：可以进行https请求，重试次数，

依赖

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

代码

package com.demon.util;

import okhttp3.*;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.IOException;
import java.io.InputStream;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.X509Certificate;
import java.util.concurrent.TimeUnit;

/**
 * author ：demon
 * date ：2023 2023/3/5 13:28
 * desc ：
 */
public class OkHttpClientUtil {

    public static String post(Headers.Builder headerBuilder, String url, String content) throws Exception {
        // 执行POST(body)请求  - > 请问完成后 自动关闭连接
        try (Response response = getOkHttpClient()
                .newCall(new Request.Builder()
                        .url(url)
                        .headers(headerBuilder.build())
                        .post(RequestBody.create(MediaType.parse("application/json;charset=utf-8"), content))
                        .build()).execute()) {
            if (response.isSuccessful()) {
                ResponseBody body = response.body();
                System.out.println("响应的Code：" + response.code());
                if (body != null) {
                    String bodyString = body.string();
                    System.out.println("响应的内容：" + bodyString);
                    return bodyString;
                }
                throw new Exception("返回内容为空");
            } else {
                throw new Exception("请求错误，response code:" + response.code());
            }
        } catch (IOException e) {
            throw new IOException(e);
        }
    }

    public static InputStream downloadFile(String url) throws IOException, NoSuchAlgorithmException, KeyManagementException {
        // 发起请求得到请求结果
        Response response = getOkHttpClient().newCall(new Request.Builder().url(url).get().build()).execute();
        // 获取请求结果
        ResponseBody responseBody = response.body();
        if (null != responseBody) {
            // 获取文件后缀类型 可以使用 responseBody.contentType() 获取 ContentType，我这边知道这个url文件的类型
            // 获取请求结果输入流
            return responseBody.byteStream();
        }
        response.close();
        return null;
    }

    private static OkHttpClient getOkHttpClient() throws KeyManagementException, NoSuchAlgorithmException {
        return new OkHttpClient.Builder()
                // 设置连接时间10分钟 - >三次握手 + SSL建立耗时
                .connectTimeout(60 * 10, TimeUnit.SECONDS)
                // 设置写入时间60秒
                .writeTimeout(60, TimeUnit.SECONDS)
                // 设置读取时间60秒
                .readTimeout(60, TimeUnit.SECONDS)
                // 添加信任HTTPS请求
                .sslSocketFactory(sslSocketFactory(), x509TrustManager())
                // 过滤器，设置最大重试次数
                .addInterceptor(new OkHttpInterceptor(3))
                // 不自动重连
                .retryOnConnectionFailure(false).build();
    }


    private static SSLSocketFactory sslSocketFactory() throws NoSuchAlgorithmException, KeyManagementException {
        // 信任任何链接
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(null, new TrustManager[]{x509TrustManager()}, new SecureRandom());
        return sslContext.getSocketFactory();
    }

    private static X509TrustManager x509TrustManager() {
        return new X509TrustManager() {
            @Override
            public void checkClientTrusted(X509Certificate[] x509Certificates, String s) {
            }

            @Override
            public void checkServerTrusted(X509Certificate[] x509Certificates, String s) {
            }

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


    private static class OkHttpInterceptor implements Interceptor {

        // 最大重试次数
        private int maxRetry;

        OkHttpInterceptor(int maxRetry) {
            this.maxRetry = maxRetry;
        }

        @SuppressWarnings("NullableProblems")
        @Override
        public Response intercept(Chain chain) {
            /* 递归 4次下发请求，如果仍然失败 则返回 null ,但是 intercept must not return null.
             * 返回 null 会报 IllegalStateException 异常
             */
            return retry(chain, 0);
        }

        private Response retry(Chain chain, int retryCount) {
            Request request = chain.request();
            Response response = null;
            try {
                System.out.println("第" + (retryCount + 1) + "次执行HTTP请求···");
                response = chain.proceed(request);
            } catch (Exception e) {
                if (maxRetry > retryCount) {
                    return retry(chain, retryCount + 1);
                }
            }
            return response;
        }
    }
}

测试

@Test
public void toTest() {
    JSONObject json = new JSONObject();
    json.put("jobId", "999999999");
    try {
        String post = OkHttpClientUtil.post(
                new Headers.Builder().set("Content-Type", "application-json").set("API-KEY", "1234567890"),
                "https://www.baidu.com/",
                json.toJSONString());
        System.out.println(post);
    } catch (Exception e) {
        e.printStackTrace();
    }
}