OkHttp3常用方法的封装

最新推荐文章于 2025-03-12 09:31:20 发布
最新推荐文章于 2025-03-12 09:31:20 发布
阅读量774 收藏 1
点赞数
文章标签： java
原文链接：https://cxyroad.blog.youkuaiyun.com/article/details/118447234
版权

原文转载于：https://cxyroad.blog.youkuaiyun.com/article/details/118447234

方便自己使用

1.引入pom文件：

<!-- springboot 整合Okhttp -->
<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>3.10.0</version>
</dependency>

2.封装okHttp方法


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);

    }
}

3.测试


import com.wugenet.springboot.util.OkHttpUtils;
import okhttp3.Call;
import org.junit.Test;


public class OkhttpTest {

    /**
     * get请求 不带参数 有返回值
     */
    @Test
    public void doGetNoParameter() {
        // get请求，方法顺序按照这种方式，切记选择post/get一定要放在倒数第二，同步或者异步倒数第一，才会正确执行
        String async = OkHttpUtils.builder()
                .url("http://127.0.0.1:8889/user/listUser")
                .get()
                .async();
        System.out.println("async:" + async);
    }

    /**
     * get请求 带参数 有返回值
     */
    @Test
    public void doGet() {
        // get请求，方法顺序按照这种方式，切记选择post/get一定要放在倒数第二，同步或者异步倒数第一，才会正确执行
        String async = OkHttpUtils.builder()
                .url("http://127.0.0.1:8889/user/listUserById")
                .addParam("id", "3")
                .get()
                .async();
        System.out.println("async:" + async);

    }

    /**
     * post请求 不带参数 表单提交 有返回值
     */
    @Test
    public void doPostNoParameter() {
        // post请求，方法顺序按照这种方式，切记选择post/get一定要放在倒数第二，同步或者异步倒数第一，才会正确执行
        String async = OkHttpUtils.builder()
                .url("http://127.0.0.1:8889/user/addUser")
                .post(false)//表单提交
                .async();
        System.out.println("async:" + async);
    }

    /**
     * post请求 带参数 表单提交 有返回值
     */
    @Test
    public void doPost() {
        // post请求，方法顺序按照这种方式，切记选择post/get一定要放在倒数第二，同步或者异步倒数第一，才会正确执行
        String async = OkHttpUtils.builder()
                .url("http://127.0.0.1:8889/user/addUser")
                .addParam("username", "zhangmengmeng")
                .post(false)//表单提交
                .async();
        System.out.println("async:" + async);
    }

    /**
     * post请求 带参数 body提交 带请求头参数token 有返回值
     */
    @Test
    public void doPostByHeader() {
        // post请求，方法顺序按照这种方式，切记选择post/get一定要放在倒数第二，同步或者异步倒数第一，才会正确执行
        String async = OkHttpUtils.builder()
                .url("http://XXXX")
                .addParam("id", "3")
                .addHeader("accessToken","123456789")
                .post(true)//body提交
                .async();
        System.out.println("async:" + async);
    }

    /**
     * 所有方法使用教程
     */
    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) {
                // 请求失败后的处理
            }
        });
    }

}

我封装的okhttp.zip_MHZ_OKhttp封装_okhttp_okhttp3_okhttp3 封装
09-15
总的来说，"我封装的okhttp.zip_MHZ_OKhttp封装_okhttp_okhttp3_okhttp3 封装"是一个针对OkHttp3的高级封装，它通过整合和优化常见网络请求操作，为开发者提供了更加便捷的网络通信解决方案。通过理解和掌握这个封装...
okhttp3的使用
一片蓝蓝的云
08-12 2865
xx
Java封装OkHttp3工具类
weixin_44421461的博客
07-06 672
点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！源码精品专栏原创 | Java 2020超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网...
两万字深入解析 OkHttp3：高效、灵活的 HTTP 客户端库
程序猿小样的博客
02-25 747
OkHttp3 是一个开源的 HTTP 客户端库，由 Square 公司开发。它专为 Java 和 Android 应用程序设计，旨在简化 HTTP 请求的处理，并提供高效、灵活的网络通信功能。OkHttp3 是 OkHttp 的第三个主要版本，相较于之前的版本，它在性能、功能和易用性上有了显著提升。OkHttp3 是一个功能强大、性能优越的 HTTP 客户端库，适用于各种网络通信场景。它的简洁 API 设计和丰富功能使其成为 Java 和 Android 开发者的首选工具之一。
OkHttp学习 - POM 文件
热门推荐
yansha的专栏
02-04 1万+
前言前段时间在项目中使用到了 OkHttp 这个 HTTP 开源库，感觉使用十分方便，而且也很高效。OkHttp 作为一款为 Android 量身打造的 HTTP 客户端，支持 SPDY/HTTP 2 协议，通过阅读它的源码确实可以学到不少知识。本文通过对根目录的 POM 文件进行解析，从而对项目有个整理上的了解。
OkHttp的二次封装
05-03
2. **请求方法封装**：`MyOkHttp`通常会提供`get`、`post`等常用请求方法，方便开发者直接调用。这些方法内部会使用OkHttpClient的`newCall`方法创建`Request`对象并执行请求。 ```java public void get(String url...
okHttp封装库 Eclipse版本
01-21
`okhttputils` 文件可能是一个工具类库，封装了一些常用的网络请求操作，使得使用更加方便。 学习 OkHttp 时，你需要理解以下几个核心概念： - ** OkHttpClient**：这是 OkHttp 的主要入口点，用于创建和配置 ...
Android OKHTTP的单例和再封装的实例
08-29
Android OKHTTP的单例和再封装的实例是Android开发中常用的网络请求框架，OKHTTP的单例模式和再封装的实例可以提高网络请求的效率和灵活性。 OKHTTP的单例模式是指使用单例模式来创建OKHTTP的实例，以避免多次创建...
深入了解OkHttp3之Interceptors
01-06
在Android应用中，我们通常需要获取用户手机的IMEI值和其他一些常用的参数，如果把他们封装到请求头里面的话会非常的方便。 既然是自定义拦截器，我们首先肯定要继承OKHttp的拦截器，把这个自定义类设置成 final ...
OkHttp3使用笔记
namelessmyth的专栏
10-17 615
项目中会使用OkHttp3来调用restful接口.步骤如下. pom文件引入依赖. <dependency> <groupId>com.squareup.okhttp3</groupId> <artifactId>okhttp</artifactId> <version>3.14.2</version> </
OKHttp3工具的使用
qq_35354529的博客
06-28 761
项目pom.xml添加maven依赖 <!-- json --> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.72</version> </dependency&gt
SpringBoot集成okhttp3爬虫
硬核编程乐乐的博客
10-07 1701
一.引入依赖 pom依赖如下: <dependency> <groupId>com.squareup.okhttp3</groupId> <artifactId>okhttp</artifactId> <version>3.10.0</version> </dependency> 二.在resources目录下配置application.propertie
Okhttp3系列之(3) - SpringBoot下配置Okhttp3工具类
u010349272的博客
07-09 3558
1.添加pom.xml依赖 <dependency> <groupId>com.squareup.okhttp3</groupId> <artifactId>okhttp</artifactId> <version>3.6.0</version> </dependency> 2.封装工具类： import lombok.extern.slf4j.Slf4j; import okhttp3.*; impo
【OpenFeign】okhttp3请求压缩请求与响应
hs598375774的博客
05-12 1389
在上面的配置中，feign.compression.request.enabled和feign.compression.response.enabled均设置为true，表示启用请求和响应的压缩。同时还配置了请求和响应的Content-Type类型，只对满足这些类型的请求和响应进行压缩。OpenFeign默认使用的是Spring Cloud自带的HttpURLConnection进行HTTP请求，不支持对请求和响应进行压缩，需要做一些配置才能实现压缩。
OkHttp3 详解及开发实例—官方原版(一）
最新发布
深圳市多克创新科技有限公司
03-12 1073
OkHttp3 详解及开发实例—官方原版(一）
SpringBoot 使用okhttp3
05-20 5206
SpringBoot 使用okhttp3 1.添加pom.xml依赖 <dependency> <groupId>com.squareup.okhttp3</groupId> <artifactId>okhttp</artifactId> <version>3.6.0</version> </dependenc
OkHttp3 - 1. OkHttp3简介与环境配置
一名全栈开发工程师
11-27 2168
OkHttp3 是一个高效的 Java HTTP 客户端库，支持同步与异步请求，具备简单易用的 API 和强大的功能。主要特点包括：轻量级与高性能：支持 HTTP/2 协议，实现复用连接，降低延迟。简单优雅的设计：使用简单的 API 构建复杂的 HTTP 请求。强大的功能支持：如拦截器、缓存、连接池、WebSocket 等。高度扩展性：可以轻松扩展功能，比如实现自定义拦截器和 DNS。
okhttp3封装库
08-20
对于OkHttp3的封装库，有很多可以选择的工具和框架。以下是一些常用的OkHttp3封装库： 1. Retrofit: Retrofit 是一个流行的RESTful HTTP客户端库，它基于OkHttp3进行了封装。它简化了网络请求的处理，使得在Android和Java应用中进行网络通信变得更加简单。它提供了强大的注解支持，可以将HTTP请求定义为接口方法，并自动将响应解析为Java对象。 2. Volley: Volley 是Google推出的一个网络请求库，它也可以与OkHttp3集成。Volley提供了一种简单的方式来处理网络请求和图片加载，它具有自动缓存、请求优先级、并发请求、取消请求等功能。 3. OkHttpUtils: OkHttpUtils 是一款轻量级的OkHttp3封装库，它提供了一些便捷的方法来发送HTTP请求，并支持同步和异步请求。它还提供了文件上传、下载、图片加载等常用功能的封装。 4. Fuel: Fuel 是一个基于Kotlin语言的HTTP客户端库，它支持OkHttp3作为底层网络协议栈。Fuel提供了简洁的API，并使用Kotlin的扩展函数来增强OkHttp3的功能。 这些封装库都可以帮助你更方便地使用OkHttp3进行网络请求，具体选择哪一个取决于你的项目需求和个人偏好。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值