okhttp应用示例 - 封装工具类同步异步调用一文全解

已于 2023-12-26 16:26:46 修改
阅读量1.1k 收藏 2
点赞数
分类专栏： 一文全解 文章标签： okhttp android spring boot java
于 2023-03-27 22:39:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76354366/article/details/129805860
版权 
传送门
项目github地址https://github.com/square/okhttp

1. 添加pom依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

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

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.83</version>
        </dependency>
    </dependencies>

2. 创建相关类

/**
 * 测试okhttp的get与post请求
 */
@SpringBootApplication
public class OkhttpTestApplication {

    public static void main(String[] args) {
        SpringApplication.run(OkhttpTestApplication.class, args);
    }

}
/**
 * @Description: 用户实体类
 * @author: lh
 */
public class User {
    private String name; // 用户名
    private int password; // 密码

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPassword() {
        return password;
    }

    public void setPassword(int password) {
        this.password = password;
    }
}
/**
 * @Description: 返回响应实体类
 * @author: lh
 */
public class BaseResponse {
    private int code; // 响应状态码
    private String msg; // 响应消息体

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}
/**
 * @Description: 用户控制层
 * @author: lh
 */
@RestController
@RequestMapping("/user")
public class UserController {

    @GetMapping("/login")
    public BaseResponse login(@RequestParam String name, @RequestParam int password)
    {
        BaseResponse response = new BaseResponse();
        if (name.equals("li") && password == 123456)
        {
            response.setCode(200);
            response.setMsg("登录成功，欢迎使用");
        } else {
            response.setCode(500);
            response.setMsg("登录失败，请检查用户名密码后重试");
        }

        return response;
    }

    @PostMapping("register")
    public BaseResponse register(@RequestBody User user)
    {
        BaseResponse response = new BaseResponse();
        if (user != null)
        {
            response.setCode(200);
            response.setMsg("用户注册成功");
        } else {
            response.setCode(500);
            response.setMsg("注册失败，请检查后重试");
        }

        return response;
    }
}

3. 使用postman请求测试

http://localhost:8080/user/login?name=li&password=123456

{
    "code": 200,
    "msg": "登录成功，欢迎使用"
}
http://localhost:8080/user/register

{"name":"li","password":123456}

{
    "code": 200,
    "msg": "用户注册成功"
}

4. 使用okhttpClient进行测试

@SpringBootTest
class OkhttpTestApplicationTests {
    @Test
    public void testGet() {
        // 1.创建一个okHttpClient
        OkHttpClient okHttpClient = new OkHttpClient();
        // 2.创建一个httpUrl
        HttpUrl url = Objects.requireNonNull(HttpUrl.parse("http://localhost:8080/user/login")).newBuilder()
                .addQueryParameter("name", "li")
                .addQueryParameter("password", "123456")
                .build();
        // 3.创建一个request
        Request request = new Request.Builder()
                .url(url)
                .get()
                .build();
        // 4.执行请求命令
        try {
            Response response = okHttpClient.newCall(request).execute();
            System.out.println(Objects.requireNonNull(response.body()).string());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void testPost() {
        // 1.创建一个okHttpClient
        OkHttpClient okHttpClient = new OkHttpClient();
        // 2.创建一个url
        String url = String.format("http://localhost:8080/user/register");
        // 3.指定传输type为JSON
        MediaType Json = MediaType.get("application/json");
        // 4.创建request
        User user = new User();
        user.setName("li");
        user.setPassword(123456);
        String jsonString = JSONObject.toJSONString(user);
        RequestBody body = RequestBody.create(jsonString, Json);
        Request request = new Request.Builder().url(url)
                .post(body)
                .build();
        // 5.执行请求命令
        try {
            Response response = okHttpClient.newCall(request).execute();
            System.out.println(response.body().string());
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

5. 封装一个okhttp工具类

package com.example.okhttp.utils;

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: okhttp工具类
 * @author: lh
 */
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 (OkHttpClient.class) {
                if (okHttpClient == null) {
                    // 设置代理方式
//                    Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("127.0.0.1", 8080));
                    TrustManager[] trustManagers = buildTrustManagers();
                    okHttpClient = new OkHttpClient.Builder()
                            //设置连接超时时间
                            .connectTimeout(15, TimeUnit.SECONDS)
                            //写入超时时间
                            .writeTimeout(20, TimeUnit.SECONDS)
                            //从连接成功到响应的总时间
                            .readTimeout(20, TimeUnit.SECONDS)
                            //跳过ssl认证(https)
                            .sslSocketFactory(createSSLSocketFactory(trustManagers), (X509TrustManager) trustManagers[0])
                            .hostnameVerifier((hostName, session) -> true)
                            .retryOnConnectionFailure(true)
//                            .proxy(proxy)//代理ip
                            //设置连接池  最大连接数量  , 持续存活的连接
                            .connectionPool(new ConnectionPool(50, 10, TimeUnit.MINUTES))
                            .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");
                }
            }
        }
    }

    /**
     * 用于异步请求时，控制访问线程数，返回结果
     *
     */
    private static Semaphore getSemaphoreInstance() {
        //只能1个线程同时访问
        synchronized (OkHttpUtils.class) {
            if (semaphore == null) {
                semaphore = new Semaphore(0);
            }
        }
        return semaphore;
    }

    /**
     * 创建OkHttpUtils
     *
     */
    public static OkHttpUtils builder() {
        return new OkHttpUtils();
    }

    /**
     * 添加url
     *
     * @param url 地址
     */
    public OkHttpUtils url(String url) {
        this.url = url;
        return this;
    }

    /**
     * 添加参数
     *
     * @param key   参数名
     * @param value 参数值
     */
    public OkHttpUtils addParam(String key, String value) {
        if (paramMap == null) {
            paramMap = new LinkedHashMap<>(16);
        }
        paramMap.put(key, value);
        return this;
    }

    /**
     * 添加请求头
     *
     * @param key   参数名
     * @param value 参数值
     */
    public OkHttpUtils addHeader(String key, String value) {
        if (headerMap == null) {
            headerMap = new LinkedHashMap<>(16);
        }
        headerMap.put(key, value);
        return this;
    }

    /**
     * 初始化get方法
     *
     */
    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等于普通的表单提交
     */
    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;
    }

    public OkHttpUtils put() {
        String json = "";
        if (paramMap != null) {
            json = JSON.toJSONString(paramMap);
        }
        RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), json);

        request = new Request.Builder().put(requestBody).url(url);
        return this;
    }

    public OkHttpUtils del() {
        String json = "";
        if (paramMap != null) {
            json = JSON.toJSONString(paramMap);
        }
        RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), json);
        request = new Request.Builder().delete(requestBody).url(url);
        return this;
    }

    /**
     * 同步请求
     *
     */
    public String sync() {
        setHeader(request);
        try {
            Response response = okHttpClient.newCall(request.build()).execute();
            assert response.body() != null;
            return Objects.requireNonNull(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(@NotNull Call call, @NotNull IOException e) {
                buffer.append("请求出错：").append(e.getMessage());
            }

            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                assert response.body() != null;
                buffer.append(Objects.requireNonNull(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(@NotNull Call call, @NotNull IOException e) {
                callBack.onFailure(call, e.getMessage());
            }

            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                assert response.body() != null;
                callBack.onSuccessful(call, Objects.requireNonNull(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 SSLSocketFactory
     */
    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 {
        /**
         * 接口正常调用返回的内容
         *
         * @param call 回调
         * @param data 返回数据
         */
        void onSuccessful(Call call, String data);

        /**
         * 接口错误返回的内容
         *
         * @param call     回调
         * @param errorMsg 错误信息
         */
        void onFailure(Call call, String errorMsg);

    }
}

6. 使用封装的工具类进行请求

@SpringBootTest
class OkhttpTestApplicationTests {

    @Test
    public void testOkhttpGet() {
        String res = OkHttpUtils.builder()
                .url("http://localhost:8080/user/login")
                .addParam("name", "li").addParam("password", "123456")
                .get()
                .sync();
        System.out.println(res);
    }

    @Test
    public void testOkhttpPost() {
        String res = OkHttpUtils.builder()
                .url("http://localhost:8080/user/register")
                .addParam("name", "li").addParam("password", "123456")
                .post(true)
                .sync();
        System.out.println(res);
    }

    @Test
    public void testOkhttpAsync() {
        OkHttpUtils.builder()
                .url("http://localhost:8080/user/register")
                .addParam("name", "li").addParam("password", "123456")
                .post(true)
                .async(new AsyncHttpServiceImpl());
    }


    //回调实现类
    public class AsyncHttpServiceImpl implements OkHttpUtils.ICallBack {
        @Override
        public void onSuccessful(Call call, String data) {
            // 接口正常返回的内容
            System.out.println("onSuccessful" + data);
        }

        @Override
        public void onFailure(Call call, String errorMsg) {
            //接口错误返回的内容
            System.out.println("onFailure" + errorMsg);
        }
    }
}

半自定义大剑仙
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OKHttpClient简单使用工具类
yuejunfeng1993的博客
09-06 671
多多支持
springboot笔记示例一：okhttp正确姿势
逆天-逍遥哥哥的博客
06-24 742
springboot笔记示例一：okhttp正确姿势
一文吃透接口调用神器RestTemplate
weixin_44742132的博客
10-31 414
文末可以领取所有系列高清 pdf。大家好，我是路人，这是 SpringMVC 系列第 21 篇。本文介绍 Spring web 中特别牛逼的一个类 RestTemplate。目录1、Res...
【Gradle-8】Gradle插件开发指南
yechaoa
09-19 1565
编写一个插件Plugin其实挺简单的，只需要实现Plugin接口，并实现唯一apply方法即可。我们就直接写在@Overrideprintln("这是插件：${this.class.name}")这实际上是一个内联类。写完别忘了apply依赖上。第9行的apply方法是调用的PluginAware接口的apply()方法，参数是一个map，用来映射Plugin Id。这是插件：YechaoaPlugin...在上一文。
4.6 W 字总结！Java 11—Java 17特性详解
民工哥的博客
09-09 6605
点击关注公众号，回复“1024”获取2TB学习资源！接上一篇：7.8 W 字总结！Java 8—Java 10 特性详解Java 11 特性详解基于嵌套的访问控制与 Java 语言中现有的...
适合初学者入门的项目，通过对 Kotlin 的系统运用，实现的一个功能完备符合主流市场标准 App。包含知识点（MVVM 开发架构、单 Activity 多 Fragment 项目设计、暗夜模式、屏幕
未来很长，但我会努力的走下去。
05-27 601
fragmject 项目地址：miaowmiaow/fragmject 简介： 适合初学者入门的项目，通过对 Kotlin 的系统运用，实现的一个功能完备符合主流市场标准 App。包含知识点（MVVM 开发架构、单 Activity 多 Fragment 项目设计、暗夜模式、屏幕录制、图片编辑、字节码插桩）。项目结构清晰，代码简洁优雅。 更多：作者提 Bug 标签： 刚开始学习Kotlin其实挺痛苦的，相关的书籍或视频偏向于知识点的讲解看完好像还是不会做项目，开源的项目内...
一文搞懂全链路监控：方案概述与比较 | 干货
weixin_38320674的博客
01-30 3686
原文标题为《全链路监控（一）：方案概述与比较》，作者陶邦仁，链接：https://www.jianshu.com/p/92a12de11f180—问题背景随着微服务架构的流行，服务按照...
一文搞懂全链路监控：方案概述与比较！
weixin_45727359的博客
03-13 383
作者：陶邦仁https://www.jianshu.com/p/92a12de11f180—问题背景随着微服务架构的流行，服务按照不同的维度进行拆分，...
Java8 - Java17新特性说明
h295928126的博客
07-06 3576
Java8 - Java17新特性说明
android 必读的文章- 收藏集 - 掘金
hzy670800844的博客
05-06 3757
写给 Android 开发者的混淆使用手册 - Android - 掘金 本文转自：点击打开链接 毫无疑问，混淆是打包过程中最重要的流程之一，在没有特殊原因的情况下，所有 app 都应该开启混淆。 首先，这里说的的混淆其实是包括了代码压缩、代码混淆以及资源压缩等的优化过程。依靠 ProGuard，混淆流程将...
okhttp-spring-boot：OkHttp的Spring Boot启动程序
01-29
okhttp-spring-boot-starter （别名为okhttp3-spring-boot-starter ） 使用Gradle dependencies { compile " io.freefair.okhttp-spring-boot:okhttp3-spring-boot-starter: $v ersion " } 使用Maven ...
okhttp-3.3.1-API文档-中文版.zip
04-08
赠送jar包：okhttp-3.3.1.jar； 赠送原API文档：okhttp-3.3.1-javadoc.jar； 赠送源代码：okhttp-3.3.1-sources.jar； 包含翻译后的API文档：okhttp-3.3.1-javadoc-API文档-中文(简体)版.zip 对应Maven信息：...
Android-OkHttp3.0网络工具类
08-13
4. **使用OkHttp3.0封装工具类** - 开发者通常会封装一个OkHttp的工具类，以简化网络请求的调用，提供统一的接口供其他模块使用。封装的内容可能包括设置baseUrl、添加全局Header、处理请求结果等。 - 通过`...
OkHttp请求完美封装（并带工具类）
03-16
MD5、RSA、Base64Utils、DialogUtil、ZXingUtils、GlideUtil、、、工具类 自己总结了一些必备的工具类，可直接放入工程，简单调用 对OkHttp进行了封装，简单调用，便于操作 进行了post、get、文件上传等进行封装
okhttp-2.4.0-API文档-中文版.zip
04-23
赠送jar包：okhttp-2.4.0.jar； 赠送原API文档：okhttp-2.4.0-javadoc.jar； 赠送源代码：okhttp-2.4.0-sources.jar； 赠送Maven依赖信息文件：okhttp-2.4.0.pom； 包含翻译后的API文档：okhttp-2.4.0-javadoc-API...
掌握AJAX技术：从基础到实战
2301_80064376的博客
07-26 959
在现代Web开发中，AJAX（Asynchronous JavaScript and XML）技术已经成为一个不可或缺的工具。**它不仅提升了用户体验，还显著提高了网页的动态交互能力**。本文将为初学者详细介绍AJAX技术的基础知识，并通过简单的实例帮助大家快速上手。
Android图像显示SurfaceFlinger总结
最新发布
lz_1990的专栏
08-02 582
SurfaceFlinger源码解析
filament 初使用记录
wsfufua的博客
07-29 762
关于filament使用的使用笔记
OkHttp 应该怎么封装网络工具类
06-08
OkHttp 是一款非常优秀的网络请求框架，可以用来实现 Android 应用中的网络请求。如果要封装一个网络工具类，可以考虑以下几个步骤： 1. 引入 OkHttp 库。可以通过在 build.gradle 文件中添加以下依赖来引入 OkHttp 库： ``` implementation 'com.squareup.okhttp3:okhttp:4.9.0' ``` 2. 创建一个单例类来管理 OkHttp。在这个类中，我们可以创建一个 OkHttpClient 对象，用于发送网络请求。同时，可以在这个类中定义一些公共的请求参数、头部信息等，以便在发送网络请求时使用。 ```java public class HttpUtils { private static HttpUtils mInstance; private OkHttpClient mOkHttpClient; private HttpUtils() { mOkHttpClient = new OkHttpClient.Builder() .connectTimeout(10, TimeUnit.SECONDS) .readTimeout(10, TimeUnit.SECONDS) .writeTimeout(10, TimeUnit.SECONDS) .build(); } public static HttpUtils getInstance() { if (mInstance == null) { synchronized (HttpUtils.class) { if (mInstance == null) { mInstance = new HttpUtils(); } } } return mInstance; } public OkHttpClient getOkHttpClient() { return mOkHttpClient; } } ``` 3. 封装网络请求。在发送网络请求时，我们可以使用 OkHttp 提供的 Request 和 Response 类来实现。可以考虑封装一个方法，传入请求参数和回调函数，来发送网络请求，并将结果返回给回调函数。 ```java public void sendRequest(Request request, Callback callback) { mOkHttpClient.newCall(request).enqueue(callback); } ``` 4. 在回调函数中处理请求结果。在发送网络请求时，我们可以通过传入回调函数的方式，来处理请求结果。在回调函数中，可以根据请求结果的状态码、响应体等信息，来处理请求结果。 ```java public abstract class HttpCallback implements Callback { @Override public void onFailure(Call call, IOException e) { // 网络请求失败 } @Override public void onResponse(Call call, Response response) throws IOException { if (response.isSuccessful()) { // 网络请求成功，处理响应结果 String result = response.body().string(); onSuccess(result); } else { // 网络请求失败 onFailure(response.code(), response.message()); } } public abstract void onSuccess(String result); public abstract void onFailure(int code, String message); } ``` 5. 封装常用的网络请求方法。根据业务需求，可以封装一些常用的网络请求方法，例如 GET、POST 等请求方法，以便在发送网络请求时使用。 ```java public void doGet(String url, HttpCallback callback) { Request request = new Request.Builder().url(url).build(); sendRequest(request, callback); } public void doPost(String url, RequestBody body, HttpCallback callback) { Request request = new Request.Builder().url(url).post(body).build(); sendRequest(request, callback); } ``` 通过以上步骤，我们可以封装一个简单的 OkHttp 网络工具类，用于发送网络请求。当然，具体的实现还需要根据业务需求进行调整和优化，以上仅供参考。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值