OkHttp

最新推荐文章于 2024-05-01 18:09:05 发布

掐指一算乀缺钱

最新推荐文章于 2024-05-01 18:09:05 发布

阅读量108

点赞数

文章标签： okhttp ssl https

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/WangKun_0612/article/details/130520759

版权

import com.alibaba.fastjson.JSON;
import okhttp3.*;
import org.jetbrains.annotations.NotNull;

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.net.URLEncoder;
import java.security.SecureRandom;
import java.security.cert.X509Certificate;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * @Description 网络请求 http/https
 * @Author WangKun
 * @Date 2021/7/16 11:12
 * @Version
 */
public class OkHttpUtil {

    private static volatile OkHttpClient okHttpClient = null;
    private static volatile Semaphore semaphore = null;
    private Map<String, String> headerMap;
    private Map<String, String> paramMap;
    private String url;
    private Request.Builder request;

    /**
     * @Description 初始化网络请求,允许https访问
      * @param
     * @Throws
     * @Return
     * @Date 2021-07-16 11:29:40
     * @Author WangKun
     **/
    private OkHttpUtil() {
        if (okHttpClient == null) {
            synchronized (OkHttpUtil.class) {
                if (okHttpClient == null) {
                    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();
                    addHeader("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36");
                }
            }
        }
    }

    /**
     * @Description 生成安全数字套件工厂，用于https请求的证书跳过
      * @param trustManagers
     * @Throws
     * @Return javax.net.ssl.SSLSocketFactory
     * @Date 2021-07-16 11:27:10
     * @Author WangKun
     **/
    private static SSLSocketFactory createSSLSocketFactory(TrustManager[] trustManagers) {
        SSLSocketFactory ssfFactory = null;
        try {
            SSLContext sc = SSLContext.getInstance("SSL");
            sc.init(null, trustManagers, new SecureRandom());
            ssfFactory = sc.getSocketFactory();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ssfFactory;
    }

    /**
     * @Description 数字套件信任器
      * @param
     * @Throws
     * @Return javax.net.ssl.TrustManager[]
     * @Date 2021-07-16 11:28:31
     * @Author WangKun
     **/
    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[]{};
                    }
                }
        };
    }

    /**
     * @Description 添加请求头
     * @param key 参数名
     * @param value 参数值
     * @Throws
     * @Return com.harmonywisdom.common.utils.OkHttpUtil
     * @Date 2021-07-16 11:31:25
     * @Author WangKun
     **/
    public OkHttpUtil addHeader(String key, String value) {
        if (headerMap == null) {
            headerMap = new LinkedHashMap<>(16);
        }
        headerMap.put(key, value);
        return this;
    }



    /**
     * @Description OkHttpUtil
      * @param
     * @Throws
     * @Return com.harmonywisdom.common.utils.OkHttpUtil
     * @Date 2021-07-16 11:33:09
     * @Author WangKun
     **/
    public static OkHttpUtil builder() {
        return new OkHttpUtil();
    }

    /**
     * @Description url
      * @param url
     * @Throws
     * @Return com.harmonywisdom.common.utils.OkHttpUtil
     * @Date 2021-07-16 11:33:40
     * @Author WangKun
     **/
    public OkHttpUtil url(String url) {
        this.url = url;
        return this;
    }

    /**
     * @Description 添加参数
      * @param key 参数名
     * @param value 参数值
     * @Throws
     * @Return com.harmonywisdom.common.utils.OkHttpUtil
     * @Date 2021-07-16 11:34:02
     * @Author WangKun
     **/
    public OkHttpUtil addParam(String key, String value) {
        if (paramMap == null) {
            paramMap = new LinkedHashMap<>(16);
        }
        paramMap.put(key, value);
        return this;
    }
    /**
     * @Description 请求信号用于异步请求时，控制访问线程数，返回结果
     * @param
     * @Throws
     * @Return java.util.concurrent.Semaphore
     * @Date 2021-07-16 11:32:09
     * @Author WangKun
     **/
    private static Semaphore getSemaphoreInstance() {
        //只能1个线程同时访问(单例模式)
        synchronized (OkHttpUtil.class) {
            if (semaphore == null) {
                semaphore = new Semaphore(0);
            }
        }
        return semaphore;
    }

    /**
     * @Description request添加请求头
      * @param request
     * @Throws
     * @Return void
     * @Date 2021-07-16 11:39:18
     * @Author WangKun
     **/
    private void setHeader(Request.Builder request) {
        if (headerMap != null) {
            try {
                for (Map.Entry<String, String> entry : headerMap.entrySet()) {
                    request.addHeader(entry.getKey(), entry.getValue());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * @Description 初始化get方法
      * @param
     * @Throws
     * @Return com.harmonywisdom.common.utils.OkHttpUtil
     * @Date 2021-07-16 11:34:12
     * @Author WangKun
     **/
    public OkHttpUtil 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) {
                e.printStackTrace();
            }
            urlBuilder.deleteCharAt(urlBuilder.length() - 1);
        }
        request.url(urlBuilder.toString());
        return this;
    }

    /**
     * @Description 初始化post方法
      * @param isJsonPost true等于json的方式提交数据，类似postman里post方法的raw
     *                    false等于普通的表单提交
     * @Throws
     * @Return com.harmonywisdom.common.utils.OkHttpUtil
     * @Date 2021-07-16 11:34:54
     * @Author WangKun
     **/
    public OkHttpUtil post(boolean isJsonPost) {
        RequestBody requestBody;
        if (isJsonPost) {
            String json = "";
            if (paramMap != null) {
                json = JSON.toJSONString(paramMap);
            }
            // okhttp3的写法
            //requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), json);
            requestBody =RequestBody.Companion.create(json,MediaType.Companion.parse("application/json;charset=utf-8"));

        } else {
            FormBody.Builder formBody = new FormBody.Builder();
            if (paramMap != null) {
                paramMap.forEach(formBody::add);
            }
            requestBody = formBody.build();
        }
        request = new Request.Builder().post(requestBody).url(url);
        return this;
    }

    /**
     * @Description 同步请求
      * @param
     * @Throws
     * @Return java.lang.String
     * @Date 2021-07-16 11:37:04
     * @Author WangKun
     **/
    public String sync() {
        setHeader(request);
        try {
            Response response = okHttpClient.newCall(request.build()).execute();
            return Objects.requireNonNull(response.body()).string();
        } catch (IOException e) {
            e.printStackTrace();
            return "请求失败：" + e.getMessage();
        }
    }

    /**
     * @Description 异步请求，有返回值
      * @param
     * @Throws
     * @Return java.lang.String
     * @Date 2021-07-16 11:37:35
     * @Author WangKun
     **/
    public String async() {
        StringBuilder buffer = new StringBuilder("");
        setHeader(request);
        okHttpClient.newCall(request.build()).enqueue(new Callback() {
            @Override
            public void onFailure(@NotNull Call call, @NotNull IOException e) {
                buffer.append("请求出错：").append(e.getMessage());
            }

            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                buffer.append(Objects.requireNonNull(response.body()).string());
                getSemaphoreInstance().release();
            }
        });
        try {
            getSemaphoreInstance().acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return buffer.toString();
    }

    /**
     * @Description 异步请求，带有接口回调
      * @param callBack 回调函数 成功方法 失败方法
     * @Throws
     * @Return void
     * @Date 2021-07-16 11:38:14
     * @Author WangKun
     **/
    public void async(OkHttpCallback callBack) {
        setHeader(request);
        okHttpClient.newCall(request.build()).enqueue(new Callback() {
            @Override
            public void onFailure(@NotNull Call call, @NotNull IOException e) {
                callBack.onFailure(call, e.getMessage());
            }

            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                callBack.onSuccessful(call, Objects.requireNonNull(response.body()).string());
            }
        });
    }

            


    public static void main(String[] args) {
        // get请求，方法顺序按照这种方式，切记选择post/get一定要放在倒数第二，同步或者异步倒数第一，才会正确执行
//        OkHttpUtil.builder().url("请求地址，http/https都可以")
//                // 有参数的话添加参数，可多个
//                .addParam("参数名", "参数值")
//                .addParam("参数名", "参数值")
//                // 也可以添加多个
//                .addHeader("Content-Type", "application/json; charset=utf-8")
//                .get()
//                // 可选择是同步请求还是异步请求
//                //.async();
//                .sync();
//        // post请求，分为两种，一种是普通表单提交，一种是json提交
//        OkHttpUtil.builder().url("请求地址，http/https都可以")
//                // 有参数的话添加参数，可多个
//                .addParam("参数名", "参数值")
//                .addParam("参数名", "参数值")
//                // 也可以添加多个
//                .addHeader("Content-Type", "application/json; charset=utf-8")
//                // 如果是true的话，会类似于postman中post提交方式的raw，用json的方式提交，不是表单
//                // 如果是false的话传统的表单提交
//                .post(true)
//                .sync();
//
//        // 选择异步有两个方法，一个是带回调接口，一个是直接返回结果
//        OkHttpUtil.builder().url("")
//                .post(false)
//                .async();
//
//        OkHttpUtil.builder().url("").post(false).async(new OkHttpUtils.ICallBack() {
//            @Override
//            public void onSuccessful(Call call, String data) {
//                // 请求成功后的处理
//            }
//
//            @Override
//            public void onFailure(Call call, String errorMsg) {
//                // 请求失败后的处理
//            }
//        });
    }

}

import okhttp3.Call;

/**
 * @Description 请求回调接口
 * @Author WangKun
 * @Date 2021/7/16 11:22
 * @Version
 */
public interface OkHttpCallback {

    /**
     * 成功时返回
     **/
    void onSuccessful(Call call, String data);

    /**
     * 失败时返回
     **/
    void onFailure(Call call, String msg);

}