okHttp工具类

最新推荐文章于 2024-02-04 23:55:19 发布
最新推荐文章于 2024-02-04 23:55:19 发布
阅读量616 收藏 2
点赞数
分类专栏： 工具包 文章标签： okhttp android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43296313/article/details/127264422
版权

okHttp工具类

文章目录

一、导入依赖

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

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.6.4</version>
        </dependency>

二、HttpClientConfig配置类

public class HttpClientConfig {

    private String masterUrl;
    private boolean trustCerts;
    private String username;
    private String password;
    private int connectionTimeout;
    private int requestTimeout;
    private int websocketPingInterval;
    private int maxConcurrentRequestsPerHost;

    private int maxConnection;

    private String httpProxy;
    private String httpsProxy;
    private String proxyUsername;
    private String proxyPassword;
    private String userAgent;
    private TlsVersion[] tlsVersions = new TlsVersion[]{TLS_1_2};
    private String[] noProxy;
    public static final String HTTP_PROTOCOL_PREFIX = "http://";
    public static final String HTTPS_PROTOCOL_PREFIX = "https://";
    
    //省略get、set方法
}

三、HttpClientUtils工具类

package com.yolo.springbootzkeco.util;

import cn.hutool.json.JSONUtil;
import okhttp3.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.net.ssl.*;
import java.io.IOException;
import java.math.BigInteger;
import java.net.InetSocketAddress;
import java.net.MalformedURLException;
import java.net.Proxy;
import java.net.URL;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.X509Certificate;
import java.util.Arrays;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

import static okhttp3.ConnectionSpec.CLEARTEXT;

public class HttpClientUtils {
    private static final Logger logger = LoggerFactory.getLogger(HttpClientUtils.class);
    private static final Map<String, OkHttpClient> map_clients = new ConcurrentHashMap<>();
    private static OkHttpClient okHttpClient2;

    private HttpClientUtils() {
    }

    /**
     * 饿汉式单例
     */
    private static OkHttpClient getInstance(final HttpClientConfig config) {
        if (map_clients.containsKey(md5Key(config))) {
            return map_clients.get(md5Key(config));
        }
        OkHttpClient okHttpClient = createHttpClient(config);
        map_clients.put(md5Key(config), okHttpClient);
        return okHttpClient;
    }

    /**
     * 懒汉式单例
     */
    private static OkHttpClient getOkHttpClient(HttpClientConfig config) {
        if (okHttpClient2 == null) {
            okHttpClient2 = createHttpClient(config);
        }
        return okHttpClient2;
    }

    private static String md5Key(HttpClientConfig config) {
        return getMD5InHex( config.getMasterUrl() + "/" + config.getUsername() + "/" + config.getPassword() + "/");
    }

    private static String getMD5InHex(String data) {
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            messageDigest.update(data.getBytes());
            byte[] result = messageDigest.digest();
            return new BigInteger(1, result).toString(16);
        } catch (NoSuchAlgorithmException e) {
            return null;
        }
    }

    private static OkHttpClient createHttpClient(final HttpClientConfig config) {
        try {
            OkHttpClient.Builder httpClientBuilder = new OkHttpClient.Builder();

            // Follow any redirects
            httpClientBuilder.followRedirects(true);
            httpClientBuilder.followSslRedirects(true);

            if (config.isTrustCerts()) {
                httpClientBuilder.hostnameVerifier((s, sslSession) -> true);
            }

            TrustManager[] trustManagers = buildTrustManagers();
            httpClientBuilder.sslSocketFactory(createSSLSocketFactory(trustManagers), (X509TrustManager) trustManagers[0]);

            if (config.getConnectionTimeout() > 0) {
                httpClientBuilder.connectTimeout(config.getConnectionTimeout(), TimeUnit.MILLISECONDS);
            }

            if (config.getRequestTimeout() > 0) {
                httpClientBuilder.readTimeout(config.getRequestTimeout(), TimeUnit.MILLISECONDS);
            }

            if (config.getWebsocketPingInterval() > 0) {
                httpClientBuilder.pingInterval(config.getWebsocketPingInterval(), TimeUnit.MILLISECONDS);
            }

            if (config.getMaxConcurrentRequestsPerHost() > 0) {
                Dispatcher dispatcher = new Dispatcher();
                dispatcher.setMaxRequestsPerHost(config.getMaxConcurrentRequestsPerHost());
                httpClientBuilder.dispatcher(dispatcher);
            }

            if (config.getMaxConnection() > 0) {
                ConnectionPool connectionPool = new ConnectionPool(config.getMaxConnection(), 60, TimeUnit.SECONDS);
                httpClientBuilder.connectionPool(connectionPool);
            }

            // Only check proxy if it's a full URL with protocol
            if (config.getMasterUrl().toLowerCase().startsWith(HttpClientConfig.HTTP_PROTOCOL_PREFIX) || config.getMasterUrl().startsWith(HttpClientConfig.HTTPS_PROTOCOL_PREFIX)) {
                try {
                    URL proxyUrl = getProxyUrl(config);
                    if (proxyUrl != null) {
                        httpClientBuilder.proxy(new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyUrl.getHost(), proxyUrl.getPort())));

                        if (config.getProxyUsername() != null) {
                            httpClientBuilder.proxyAuthenticator((route, response) -> {

                                String credential = Credentials.basic(config.getProxyUsername(), config.getProxyPassword());
                                return response.request().newBuilder().header("Proxy-Authorization", credential).build();
                            });
                        }
                    }


                } catch (MalformedURLException e) {
                    throw new RuntimeException("Invalid proxy server configuration", e);
                }
            }

            if (config.getUserAgent() != null && !config.getUserAgent().isEmpty()) {
                httpClientBuilder.addNetworkInterceptor(chain -> {
                    Request agent = chain.request().newBuilder().header("User-Agent", config.getUserAgent()).build();
                    return chain.proceed(agent);
                });
            }

            if (config.getTlsVersions() != null && config.getTlsVersions().length > 0) {
                ConnectionSpec spec = new ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS)
                        .tlsVersions(config.getTlsVersions())
                        .build();
                httpClientBuilder.connectionSpecs(Arrays.asList(spec, CLEARTEXT));
            }
            return httpClientBuilder.build();
        } catch (Exception e) {
            throw new RuntimeException("创建OKHTTPClient错误", e);
        }
    }

    /**
     * 生成安全套接字工厂，用于https请求的证书跳过
     */
    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[]{};
                    }
                }
        };
    }


    private static URL getProxyUrl(HttpClientConfig config) throws MalformedURLException {
        URL master = new URL(config.getMasterUrl());
        String host = master.getHost();
        if (config.getNoProxy() != null) {
            for (String noProxy : config.getNoProxy()) {
                if (host.endsWith(noProxy)) {
                    return null;
                }
            }
        }
        String proxy = config.getHttpsProxy();
        if (master.getProtocol().equals("http")) {
            proxy = config.getHttpProxy();
        }
        if (proxy != null) {
            return new URL(proxy);
        }
        return null;
    }

    /** -----------------------------------------------具体请求方法----------------------------------------------------**/


    /**
     * 发送post请求
     * @param isJsonPost true等于json的方式提交数据，类似postman里post方法的raw,false等于普通的表单提交
     * @param httpClientConfig httpclient配置类
     * @param paramMap 参数map
     * @return 返回的数据
     */
    public static String doPost(boolean isJsonPost,HttpClientConfig httpClientConfig,Map<String,String> paramMap){
        Response response = null;
        try {
            OkHttpClient client = getInstance(httpClientConfig);
            RequestBody requestBody;

            if (isJsonPost){
                String json = "";
                if (paramMap != null) {
                    json = JSONUtil.toJsonStr(paramMap);
                }
                requestBody = RequestBody.create(MediaType.parse("application/json"), json);
            }else {
                FormBody.Builder formBody = new FormBody.Builder();
                if (paramMap != null) {
                    paramMap.forEach(formBody::add);
                }
                requestBody = formBody.build();
            }

            Request.Builder builder = new Request.Builder();
            Request request = builder.url(httpClientConfig.getMasterUrl()).post(requestBody).build();
            response = client.newCall(request).execute();
            if (response.isSuccessful() && response.body() != null) {
                return  response.body().string();
            } else if (response.body() != null){
                logger.info(response.body().string());
                return null;
            }
        } catch (IOException e){
            e.printStackTrace();
        } finally {
            if (response != null){
                response.close();
            }
        }
        return null;
    }

    /**
     * 发送post请求(发送json格式的不是form表单格式的)
     * @param httpClientConfig httpclient配置类
     * @param map 参数map
     * @return 返回的数据
     */
    public static String doPost(HttpClientConfig httpClientConfig, Map<String,Object> map){
        Response response = null;
        try {
            OkHttpClient client = getInstance(httpClientConfig);

            String json = "";
            if (map != null) {
                json = JSONUtil.toJsonStr(map);
                System.out.println(json);
            }
            RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), json);

            Request.Builder builder = new Request.Builder();
            Request request = builder.url(httpClientConfig.getMasterUrl()).post(requestBody).build();
            response = client.newCall(request).execute();
            if (response.isSuccessful() && response.body() != null) {
                return  response.body().string();
            } else if (response.body() != null){
                logger.info(response.body().string());
                return null;
            }
        } catch (IOException e){
            e.printStackTrace();
        } finally {
            if (response != null){
                response.close();
            }
        }
        return null;
    }


    /**
     * 携带token的post请求
     * @param isJsonPost true等于json的方式提交数据，类似postman里post方法的raw,false等于普通的表单提交
     * @param httpClientConfig httpclient配置类
     * @param paramMap 参数map
     * @param token token
     * @return 返回的数据
     */
    public static String doPostByToken(boolean isJsonPost,HttpClientConfig httpClientConfig, Map<String,String> paramMap, String token){
        Response response = null;
        try {
            OkHttpClient client = getInstance(httpClientConfig);
            RequestBody requestBody;

            if (isJsonPost){
                String json = "";
                if (paramMap != null) {
                    json = JSONUtil.toJsonStr(paramMap);
                }
                requestBody = RequestBody.create(MediaType.parse("application/json"), json);
            }else {
                FormBody.Builder formBody = new FormBody.Builder();
                if (paramMap != null) {
                    paramMap.forEach(formBody::add);
                }
                requestBody = formBody.build();
            }

            Request.Builder builder = new Request.Builder();
            Request request = builder.url(httpClientConfig.getMasterUrl()).header("Authorization", token).post(requestBody).build();
            response = client.newCall(request).execute();
            if (response.isSuccessful() && response.body() != null) {
                return  response.body().string();
            } else if (response.body() != null){
                logger.info(response.body().string());
                return null;
            }
        } catch (IOException e){
            e.printStackTrace();
        } finally {
            if (response != null){
                response.close();
            }
        }
        return null;
    }


    /**
     * 返回请求头
     * @param config httpclient配置类
     * @param paramMap 参数map
     * @return 响应头
     */
    public static Headers doLoginRequest(boolean isJsonPost,HttpClientConfig config, Map<String, String> paramMap) {
        Response response = null;
        try {
            OkHttpClient client = getInstance(config);
            RequestBody requestBody;

            if (isJsonPost){
                String json = "";
                if (paramMap != null) {
                    json = JSONUtil.toJsonStr(paramMap);
                }
                requestBody = RequestBody.create(MediaType.parse("application/json"), json);
            }else {
                FormBody.Builder formBody = new FormBody.Builder();
                if (paramMap != null) {
                    paramMap.forEach(formBody::add);
                }
                requestBody = formBody.build();
            }

            Request request = new Request.Builder().url(config.getMasterUrl()).post(requestBody).build();
            response = client.newCall(request).execute();
            if (response.isSuccessful() && response.body() != null) {
                return response.headers();
            } else if (response.body() != null){
                return null;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (response != null){
                response.close();
            }
        }
        return null;
    }
}
yololee_
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java封装OkHttp3工具类
qq_40812553的博客
05-31 734
Java封装OkHttp3工具类比HttpClient3和4都香废话少说直接上代码 废话少说直接上代码 //引入maven <dependency> <groupId>com.squareup.okhttp3</groupId> <artifactId>okhttp</artifactId> <version>3.10.0</version> </dependency> <depen
己用Okhttp工具类
Choi晨的博客
02-20 1018
https工具类，可选。
OkHttp 工具类
一生编程，快乐编程
04-26 501
OkHttp依赖包： <dependency> <groupId>com.squareup.okhttp3</groupId> <artifactId>okhttp</artifactId> <version>3.8.1</version> ...
http框架--基于OkHttp 4 封装的http请求工具类
penriver的博客
06-30 1843
1. 基本介绍 OkHttp算是最火的Http第三方库，Retrofit底层也是使用OkHttp 本文将OkHttp请求的相同代码进行封装，简化代码，便捷使用。 2. 源代码 2.1 使用示例 以第三方系统集成海豚调度系统为例，演示http请求工具类的使用 工具类支持http、https协议，以链式进行调用，使用起来非常便捷。 class OkHttpUtilsTest { public static void main(String[] args) { String res = "
Java请求Http接口-OkHttp(超详细-附带工具类)
苍煜
08-17 7304
简介：OkHttp是一个默认有效的HTTP客户端，有效地执行HTTP可以加快您的负载并节省带宽，如果您的服务有多个IP地址，如果第一次连接失败，OkHttp将尝试备用地址。这对于IPv4 + IPv6和冗余数据中心中托管的服务是必需的。OkHttp启动具有现代TLS功能（SNI，ALPN）的新连接，并在握手失败时回退到TLS 1.0，OkHttp支持Android 2.3及更高版本。对于Java，最低要求是1.7。
Java封装OkHttp3工具类，文件上传也很简单
qq_36489499的博客
08-13 887
Maven项目在pom文件中引入jar包 <dependency> <groupId>com.squareup.okhttp3</groupId> <artifactId>okhttp</artifactId> <version>3.10.0</version> </dependency> <dependency> <groupId>com.aliba
okhttp应用示例 - 封装工具类同步异步调用一文全解
2301_76354366的博客
03-27 834
okhttp应用示例 - 封装工具类同步异步调用
OkHttp工具类
m0_75137365的博客
03-29 301
接收Post+JSON参数+token。接收Get方法+参数+ToKen。如果接收数据为这种格式。可以用这个类作为壳接收。
封装好的okhttp的工具类
11-15
使用时，直接调用OkhttpUtil类里的相应的方法，调用相应的接口，注释比较全，可以自己看
okHttp请求工具类
12-29
android网络框架之OKhttp[1] 一个处理网络请求的开源项目,是安卓端最火热的轻量级框架,由移动支付Square公司贡献(该公司还贡献了Picasso)[2] 用于替代HttpUrlConnection和Apache HttpClient(android API23 6.0里已...
OkHttpUtils工具类.java
12-02
通过封装的okthps，就能轻松实现客户端与服务端的
Android-OkHttp3.0网络工具类
08-13
OkHttp3.0封装框架，内部使用gson解析json数据
【Java工具类】OkHttp工具类
最新发布
frcoder的博客
02-04 1364
【代码】【Java工具类】OkHttp工具类。
Spring boot 整合 Okhttp3 并封装请求工具
枫
08-30 3747
OkHttp是一个高效、灵活、易于使用的HTTP客户端库，具有高性能，功能强大，使用简单，兼容性好，应用广泛等特点
OkHttpClient请求方式详解，及常用OkHttpUtils配置工具类
大数据开发、JAVA开发、人工智能AI
11-03 8143
OkHttpClient请求方式详解，及常用OkHttpUtils配置工具类
OKhttp4 工具类
坞村野人
09-13 169
以下是okhttp4工具类，版本如下。
实现okhttp工具类
06-11
下面是一个基于 OkHttp 的 Java 工具类，可以用于发送 HTTP 请求和接收响应： ```java import okhttp3.*; import java.io.IOException; public class OkHttpUtils { private static final OkHttpClient client =...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值