首页 > 其他分享 >httpCLient请求工具类封装

httpCLient请求工具类封装

时间：2024-10-10 17:35:41浏览次数：1  
标签：null 封装 String OkHttpUtils url new httpCLient public 请求

1、okhttp工具类
依赖：

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

工具类

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

测试

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

标签：null,封装,String,OkHttpUtils,url,new,httpCLient,public,请求
From： https://www.cnblogs.com/cgy1995/p/18456821

相关文章

  • Vue3 封装不定高虚拟列表 hooks
    //useVirtualList.tsimport{ref,onMounted,onBeforeUnmount,watch,nextTick}from"vue";importtype{Ref}from"vue";interfaceConfig{data:Ref<any[]>;//数据源scrollContainer:string;//滚动容器的元素选择器actualHeightC......
  • 深度解析Spring AI：请求与响应机制的核心逻辑
    我们在前面的两个章节中基本上对SpringBoot3版本的新变化进行了全面的回顾，以确保在接下来研究SpringAI时能够避免任何潜在的问题。今天，我们终于可以直接进入主题：SpringAI是如何发起请求并将信息返回给用户的。在接下来的内容中，我们将专注于这一过程，而流式回答和函数回调的相......
  • 组合数与自动取模类（已封装）
    usingi64=longlong;template<classT>constexprTpower(Ta,i64b){Tres=1;for(;b;b/=2,a*=a){if(b%2){res*=a;}}returnres;}constexpri64mul(i64a,i64b,i64p){i64re......
  • 解密网易云音乐Web端的请求参数params与encSecKey
    网易云音乐作为一款功能强大的音乐流媒体平台，为用户提供了丰富的音乐体验和社区互动。然而，当用户希望批量下载音乐资源，尤其是整个歌单或某位歌手的全部歌曲时，受限于版权保护和平台策略，官方渠道通常无法直接实现这一需求。在这种情况下，一些技术爱好者或开发者可能会转向使用......
  • 7天毕设速成9小程序接口封装及对接
    1.接口封装1.1.请求接口封装新建文件夹request,新建index.js,封装接口接口调用对应此系列，springboot后端搭建笔记https://blog.csdn.net/PoofeeDong/article/details/140695913代码如下：constcommoneUrl="http://locahost:9999";//对应前面接口//get请求封装functi......
  • LED显示驱动/高亮数显屏驱动芯片VK16K33A 采用SOP28封装形式，可支持16SEGx8GRID的点阵L
    VK16K33A是一种带按键扫描接口的数码管或点阵LED驱动控制专用芯片，邱婷：188-2366-8825内部集成有数据锁存器、键盘扫描、LED驱动模块等电路。数据通过I2C通讯接口与MCU通信。SEG脚接LED阳极，GRID脚接LED阴极，可支持16SEGx8GRID的点阵LED显示面板。最大支持13×3的按键。内置上电......
  • 递归深拷贝导致浏览器网络请求中看不到响应
    前言：在项目中发现一个奇怪的问题，一个请求在数据量少的时候非常快速，数据量多的时候非常慢，甚至导致浏览器崩溃，在浏览器的网络抓包中看到有返回状态时200，但是响应迟迟没有返回，并且可以看到等待服务器响应时间非常长。排查：一开始是定位在后端问题，因为查询类型为1的时候反应速度非常快......
  • go抽象封装是一种简化认知的手段
    通过Kubernetes看Go接口设计之道原创 蔡蔡蔡菜 蔡蔡蔡云原生Go  2024年10月01日08:30 广东解耦依赖底层在 Kubernetes 中能看到非常多通过接口对具体实现的封装。Kubelet 实现了非常多复杂的功能，我们可以看到它实现了各种各样的接口，上层代码在使用的时候......
  • PHP中的HTTP请求：获取taobao商品数据的艺术
    在电子商务的世界里，数据是宝贵的资产。对于开发者来说，能够快速准确地获取商品数据是一项重要的技能。PHP作为一种流行的服务器端脚本语言，结合cURL扩展，可以轻松实现HTTP请求，从而获取API数据。本文将介绍如何在PHP中使用cURL来发送HTTP请求，并获取商品的详细信息。API简介开放......
  • PHP中的HTTP请求：Apache客户端的高效应用
    在现代Web开发中，PHP作为一种流行的服务器端脚本语言，经常需要与外部服务进行交互。这通常涉及到发送HTTP请求来获取或提交数据。ApacheHttpClient是PHP中一个强大的库，用于发送HTTP请求。本文将介绍如何在PHP中使用ApacheHttpClient来执行HTTP请求。ApacheHttpClient简介Ap......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99