Java封装OkHttp3工具类

港控/mmm° 2022-10-12 05:25 349阅读 0赞

![0D5F937FE12312312D81F17F.jpg][]

程序员的成长之路

互联网/程序员/技术/资料共享

[关注][Link 1]

阅读本文大概需要 5.5 分钟。

来自：https://blog.csdn.net/m0\_37701381

Java封装OkHttp3工具类，适用于Java后端开发者

说实在话，用过挺多网络请求工具，有过java原生的，HttpClient3和4，但是个人感觉用了OkHttp3之后，之前的那些完全不想再用了。怎么说呢，代码轻便，使用起来很很很灵活，响应快，比起HttpClient好用许多。当然，这些是我个人观点，不喜勿喷。

## 准备工作 ##

Maven项目在pom文件中引入jar包

<dependency>
        <groupId>com.squareup.okhttp3</groupId>
        <artifactId>okhttp</artifactId>
        <version>3.10.0</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.60</version>
    </dependency>

引入json是因为工具类中有些地方用到了，现在通信都流行使用json传输，也少不了要这个jar包

## 工具类代码 ##

import com.alibaba.fastjson.JSON;
    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.net.URLEncoder;
    import java.security.SecureRandom;
    import java.security.cert.X509Certificate;
    import java.util.LinkedHashMap;
    import java.util.Map;
    import java.util.concurrent.Semaphore;
    import java.util.concurrent.TimeUnit;
    
    public class OkHttpUtils {
        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;
    
        /**
         * 初始化okHttpClient，并且允许https访问
         */
        private OkHttpUtils() {
            if (okHttpClient == null) {
                synchronized (OkHttpUtils.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");
                    }
                }
            }
        }
    
        /**
         * 用于异步请求时，控制访问线程数，返回结果
         *
         * @return
         */
        private static Semaphore getSemaphoreInstance() {
            //只能1个线程同时访问
            synchronized (OkHttpUtils.class) {
                if (semaphore == null) {
                    semaphore = new Semaphore(0);
                }
            }
            return semaphore;
        }
    
        /**
         * 创建OkHttpUtils
         *
         * @return
         */
        public static OkHttpUtils builder() {
            return new OkHttpUtils();
        }
    
        /**
         * 添加url
         *
         * @param url
         * @return
         */
        public OkHttpUtils url(String url) {
            this.url = url;
            return this;
        }
    
        /**
         * 添加参数
         * 
         * @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) {
                    e.printStackTrace();
                }
                urlBuilder.deleteCharAt(urlBuilder.length() - 1);
            }
            request.url(urlBuilder.toString());
            return this;
        }
    
        /**
         * 初始化post方法
         *
         * @param isJsonPost true等于json的方式提交数据，类似postman里post方法的raw
         *                   false等于普通的表单提交
         * @return
         */
        public OkHttpUtils post(boolean isJsonPost) {
            RequestBody requestBody;
            if (isJsonPost) {
                String json = "";
                if (paramMap != null) {
                    json = JSON.toJSONString(paramMap);
                } 
                requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), json);
            } 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;
        }
    
        /**
         * 同步请求
         *
         * @return
         */
        public String sync() {
            setHeader(request);
            try {
                Response response = okHttpClient.newCall(request.build()).execute();
                assert response.body() != null;
                return response.body().string();
            } catch (IOException e) {
                e.printStackTrace();
                return "请求失败：" + e.getMessage();
            }
        }
    
        /**
         * 异步请求，有返回值
         */
        public String async() {
            StringBuilder buffer = new StringBuilder("");
            setHeader(request);
            okHttpClient.newCall(request.build()).enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
                    buffer.append("请求出错：").append(e.getMessage());
                }
    
                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    assert response.body() != null;
                    buffer.append(response.body().string());
                    getSemaphoreInstance().release();
                }
            });
            try {
                getSemaphoreInstance().acquire();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return buffer.toString();
        }
    
        /**
         * 异步请求，带有接口回调
         *
         * @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) {
                try {
                    for (Map.Entry<String, String> entry : headerMap.entrySet()) {
                        request.addHeader(entry.getKey(), entry.getValue());
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    
    
        /**
         * 生成安全套接字工厂，用于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);
    
        }
    }

## 使用教程 ##

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

## 结语 ##

封装的明明白白，使用的简简单单，简单的几下就能做请求，用建造者模式是真的舒服。

<END>

**推荐阅读：**

[全网疯传：程序员的酒后真言][Link 2]

[当Java枚举遇到位掩码，还能这么玩?][Java]

最近面试BAT，整理一份面试资料《Java面试BATJ通关手册》，覆盖了Java核心技术、JVM、Java并发、SSM、微服务、数据库、数据结构等等。

**获取方式：点个「****在看****」，点击上方小卡片，进入公众号后回复「****面试题****」领取，更多内容陆续奉上。**

朕已阅 ![657ba3aa50f80c8b435f2a921fff4484.gif][]

[0D5F937FE12312312D81F17F.jpg]: /images/20221005/cfd121bd8a754b78a954c914aaf92da3.png
[Link 1]: https://mp.weixin.qq.com/s?__biz=MzUyNDkzNzczNQ%3D%3D&chksm=fa24f0bacd5379ac93d74ffebac826d2401fd494f82e900e5102a8bf968f108e4ec72a4ad548&idx=3&lang=zh_CN&mid=2247487442&scene=21&sn=61e758d4bf9f15a3419fd028146469a3&token=1854383306#wechat_redirect
[Link 2]: http://mp.weixin.qq.com/s?__biz=MzUyNDkzNzczNQ%3D%3D&chksm=fa275c96cd50d580067553c2a06cececbfd0f889c4181f207fad06a82b10cb8eca444d9b5c98&idx=1&mid=2247508990&scene=21&sn=56c4b459feb679105f984de2d8f8c54b#wechat_redirect
[Java]: http://mp.weixin.qq.com/s?__biz=MzUyNDkzNzczNQ%3D%3D&chksm=fa275c96cd50d580d87d47402303925bd2dca17e296653dfc4fb5677c65c38c75a3db0f15656&idx=2&mid=2247508990&scene=21&sn=b9378e458dd22b8776e97e76c2a28a3d#wechat_redirect
[657ba3aa50f80c8b435f2a921fff4484.gif]: /images/20221005/8373e80f43194d6f9210f235eb7f09e9.png