Java封装OkHttp3工具类

最新推荐文章于 2024-09-22 17:00:00 发布
最新推荐文章于 2024-09-22 17:00:00 发布
阅读量453 收藏 1
点赞数 2
分类专栏： 代码 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45980538/article/details/124187360
版权
本文介绍了如何在Java后端项目中封装OkHttp3工具类，以实现简洁高效的网络请求。作者强调OkHttp3相较于其他HTTP客户端的优势，如代码轻便、响应快，并提供了引入依赖、工具类代码示例以及使用教程，旨在帮助开发者快速上手。
摘要由CSDN通过智能技术生成

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>
//引用阿里巴巴fastjson解析工具
<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) {
            // 请求失败后的处理
        }
    });
}

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

风车车_
关注
专栏目录
Java封装OkHttp3工具类.zip
12-12
计算机技术、IT咨询、人工智能AI理论介绍，学习参考资料计算机技术、IT咨询、人工智能AI理论介绍，学习参考资料计算机技术、IT咨询、人工智能AI理论介绍，学习参考资料计算机技术、IT咨询、人工智能AI理论介绍，学习...
一个完整封装的 OkHttp3 工具类
白高林的专栏
04-25 1471
OkHttp3 封装
JavaWeb maven okhttp3包
qq_44023485的博客
12-22 8108
最近在使用微信支付签名生成中使用到okhttp3 <dependency> <groupId>com.squareup.okhttp3</groupId> <artifactId>okhttp</artifactId> <version>4.9.3</version> </dependency>
java的 OkHttp 库入门
最新发布
java专栏
09-22 1242
通过以上的步骤，我们已经了解了如何使用 OkHttp 来执行基本的 HTTP 请求和响应操作。OkHttp 是一个非常强大的库，能够帮助你轻松管理 HTTP 通信，并确保你的应用始终保持高效。希望这篇俏皮可爱的指南对你有所帮助，如果你还有任何疑问，欢迎随时留言哦！😊注意：上面的代码示例是为了教学目的而编写的，实际使用时请根据你的项目环境进行适当的调整。别忘了检查你的 Java 版本，确保你使用的版本是最新的，以免遇到兼容性问题。此外，记得添加必要的异常处理代码，使你的应用程序更加健壮。
Spring boot 整合 Okhttp3 并封装请求工具
枫
08-30 7119
OkHttp是一个高效、灵活、易于使用的HTTP客户端库，具有高性能，功能强大，使用简单，兼容性好，应用广泛等特点
OKHttp3工具类
broccoli2的博客
11-09 363
OKHttp3方式发送http请求
OkHttp请求完美封装（并带工具类）
03-16
MD5、RSA、Base64Utils、DialogUtil、ZXingUtils、GlideUtil、、、工具类 自己总结了一些必备的工具类，可直接放入工程，简单调用 对OkHttp进行了封装，简单调用，便于操作 进行了post、get、文件上传等进行封装
okhttp3工具类
06-06
标题中的"okhttp3工具类"指的是开发者对原生的OkHttp3库进行了一次定制化的封装，以适应特定项目的需求，同时也优化了一些功能，使得代码更简洁，更易于维护。 OkHttp3本身提供了许多特性，包括： 1. **连接池**：...
OkHttpUtils工具类.java
12-02
通过封装的okthps，就能轻松实现客户端与服务端的
okhttp3.0二次封装（独立的3个java文件封装的）
11-13
最简单的okhttp封装，CallBack方法执行在UI线程。支持get请求，post请求，支持文件上传和下载。 使用方法： 代码很简单，只有三个Java文件，建议下载后将Java文件拷贝到工程中使用。 封装的功能有： 一般的get...
封装http客户端请求工具类(基于okhttp3)
Seven71111的博客
11-25 886
目录 导入需要到的maven依赖 创建接收返回体封装类 Http请求工具类 用法 导入需要到的maven依赖 <!--http客户端,okhttp3--> <dependency> <groupId>com.squareup.okhttp3</groupId> <artifactId>okhttp</artifactId>
http框架--基于OkHttp 4 封装的http请求工具类
penriver的博客
06-30 2228
1. 基本介绍 OkHttp算是最火的Http第三方库，Retrofit底层也是使用OkHttp 本文将OkHttp请求的相同代码进行封装，简化代码，便捷使用。 2. 源代码 2.1 使用示例 以第三方系统集成海豚调度系统为例，演示http请求工具类的使用 工具类支持http、https协议，以链式进行调用，使用起来非常便捷。 class OkHttpUtilsTest { public static void main(String[] args) { String res = "
java使用OKHttp调用接口
qq_35086941的博客
04-01 828
【代码】java使用OKHttp调用接口。
记录Maven 依赖包版本号奇奇怪怪的问题 - okhttp3、okio 版本指定无效
热门推荐
LoveSummer
07-05 3万+
问题背景SprintBoot项目使用Okhttp 封装SDK，根据官网使用Maven导入JavaSDK
OKHttp3 快速开始
西京刀客
05-06 6084
文章目录什么是OKHttp3基于springboot的RestTemplate、okhttp和HttpClient对比Okhttp的基本使用maven引入其他参考 什么是OKHttp3 官网地址：https://square.github.io/okhttp/ github地址：https://github.com/square/okhttp OKHttp是一个当前主流的网络请求的开源框架 Squ...
Java封装OkHttp3工具类，真TM厉害！
这个时代，作为程序员可能要学习小程序
07-07 1342
点击上方蓝色字体，选择“标星公众号”优质文章，第一时间送达关注公众号后台回复pay或mall获取实战项目资料+视频作者：如漩涡https://blog.csdn.net/mJava封装Ok...
自定义封装的OkHttp3工具包发布与案例分享
- **MyOkHttp.jar**: 这是一个Java归档文件（JAR），包含了封装后的okhttp3库的所有类文件和相关的元数据。开发者可以将这个JAR文件添加到他们的项目中，以便使用封装后的网络请求功能。 - **jarTestRunable.java**...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值