双重检查单例模式的的HttpClient线程池实现

已于 2024-05-24 14:10:39 修改
阅读量1.3k 收藏 11
点赞数 4
分类专栏： Java 面试 文章标签： 单例模式 java httpclient
于 2022-05-19 10:59:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012760435/article/details/124858901
版权
Java 同时被 2 个专栏收录
30 篇文章 8 订阅
订阅专栏
面试
9 篇文章 0 订阅
订阅专栏

关键参数都进行了注释，具备链接自动关闭，超时设置，连接池等功能。个人备忘
httpclient版本为4.5.13，这是修改后的最终版本

import com.alibaba.fastjson2.JSONObject;
import org.apache.commons.collections4.MapUtils;
import org.apache.http.HttpEntity;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.ws.rs.core.MediaType;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

/**
 * 基于双重检查单例的HttpClient4连接池
 */
public class HttpClientUtil {
    private static final Logger log = LoggerFactory.getLogger(HttpClientUtil.class);
    private static volatile CloseableHttpClient httpClient = null;

    private HttpClientUtil() {
    }

    private static CloseableHttpClient getHttpClient() {
        if (Objects.isNull(httpClient)) {
            synchronized (HttpClientUtil.class) {
                if (Objects.isNull(httpClient)) {
                    PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager();
                    // 连接池总容量
                    connectionManager.setMaxTotal(100);
                    // 每个host为一组，此参数用于控制每组中连接池的容量 【重要】
                    connectionManager.setDefaultMaxPerRoute(10);

                    RequestConfig requestConfig = RequestConfig.custom()
                            // 从连接池中取连接超时时间
                            .setConnectionRequestTimeout(5000)
                            // 建立链接超时时间
                            .setConnectTimeout(5000)
                            // 等待读取数据时间
                            .setSocketTimeout(20000)
                            .build();

                    httpClient = HttpClientBuilder.create()
                            // 关闭自动重试
                            .disableAutomaticRetries()
                            // 设置连接池
                            .setConnectionManager(connectionManager)
                            // setConnectionTimeToLive(2, TimeUnit.MINUTES) 设置链接最大存活时间 此属性无效 注意
                            // 回收空闲超过2分钟的链接
                            .evictIdleConnections(2, TimeUnit.MINUTES)
                            // 设置超时时间
                            .setDefaultRequestConfig(requestConfig)
                            .build();
                }
            }
        }
        return httpClient;
    }

    /**
     * 不带header参数的JSON格式Post请求
     *
     * @param url      请求URL
     * @param bodyJson body参数
     * @return 响应体
     */
    public static String httpPost(String url, JSONObject bodyJson) {
        return httpPost(url, null, bodyJson);
    }

    /**
     * 携带header参数的JSON格式Post请求
     *
     * @param url         请求URL
     * @param headerParam header参数
     * @param bodyJson    body参数
     * @return 响应体
     */
    public static String httpPost(String url, Map<String, String> headerParam, JSONObject bodyJson) {
        HttpPost httpPost = new HttpPost(url);
        httpPost.addHeader("Content-Type", MediaType.APPLICATION_JSON);

        // 组装header
        if (MapUtils.isNotEmpty(headerParam)) {
            for (String key : headerParam.keySet()) {
                httpPost.addHeader(key, headerParam.get(key));
            }
        }

        // 组装body
        if (Objects.nonNull(bodyJson)) {
            StringEntity stringEntity = new StringEntity(bodyJson.toJSONString(), StandardCharsets.UTF_8);
            stringEntity.setContentType(MediaType.APPLICATION_JSON);
            stringEntity.setContentEncoding(StandardCharsets.UTF_8.name());
            httpPost.setEntity(stringEntity);
        }

        // 不要关闭client，会导致连接池被关闭
        CloseableHttpClient client = getHttpClient();
        try (CloseableHttpResponse response = client.execute(httpPost)) {
            HttpEntity entity = response.getEntity();
            String result = EntityUtils.toString(entity, StandardCharsets.UTF_8.name());
            EntityUtils.consume(entity);

            return result;
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            throw new RuntimeException(e);
        }
    }

    /**
     * Get请求
     *
     * @param url 请求URL
     * @return 响应体
     */
    public static String httpGet(String url) {
        return httpGet(url, null, null);
    }

    /**
     * 携带url参数的Get请求
     *
     * @param url      请求URL
     * @param urlParam url参数
     * @return 响应体
     */
    public static String httpGet(String url, Map<String, String> urlParam) {
        return httpGet(url, null, urlParam);
    }

    /**
     * 携带header参数与url参数的Get请求
     *
     * @param url         请求URL
     * @param headerParam header参数
     * @param urlParam    url参数
     * @return 响应体
     */
    public static String httpGet(String url, Map<String, String> headerParam, Map<String, String> urlParam) {
        HttpGet httpGet = new HttpGet();

        // 组装header
        if (MapUtils.isNotEmpty(headerParam)) {
            for (String key : headerParam.keySet()) {
                httpGet.addHeader(key, headerParam.get(key));
            }
        }

        try {
            // 组装url参数
            URIBuilder uriBuilder = new URIBuilder(url);
            if (MapUtils.isNotEmpty(urlParam)) {
                for (String key : urlParam.keySet()) {
                    uriBuilder.addParameter(key, urlParam.get(key));
                }
            }
            httpGet.setURI(uriBuilder.build());
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            throw new RuntimeException(e);
        }

        // 不要关闭client，会导致连接池被关闭
        CloseableHttpClient client = getHttpClient();
        try (CloseableHttpResponse response = client.execute(httpGet)) {
            HttpEntity entity = response.getEntity();
            String result = EntityUtils.toString(entity, StandardCharsets.UTF_8.name());
            EntityUtils.consume(entity);

            return result;
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            throw new RuntimeException(e);
        }
    }
}

附基于httpclient 5.1.4版本的实现

import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.hc.client5.http.classic.methods.HttpDelete;
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.classic.methods.HttpPost;
import org.apache.hc.client5.http.classic.methods.HttpPut;
import org.apache.hc.client5.http.config.RequestConfig;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
import org.apache.hc.client5.http.impl.classic.HttpClientBuilder;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder;
import org.apache.hc.core5.http.ContentType;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.http.io.entity.StringEntity;
import org.apache.hc.core5.net.URIBuilder;
import org.apache.hc.core5.pool.PoolConcurrencyPolicy;
import org.apache.hc.core5.pool.PoolReusePolicy;
import org.apache.hc.core5.util.TimeValue;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

/**
 * 基于双重检查单例的HttpClient5连接池
 */
public class HttpClientUtil {

    private static volatile CloseableHttpClient httpClient = null;
    private static final Logger logger = LoggerFactory.getLogger(HttpClientUtil.class);

    private HttpClientUtil() {
    }

    private static CloseableHttpClient getHttpClient() {
        if (Objects.isNull(httpClient)) {
            synchronized (HttpClientUtil.class) {
                if (Objects.isNull(httpClient)) {
                    RequestConfig requestConfig = RequestConfig.custom()
                            // 从链接池获取链接超时时间
                            .setConnectionRequestTimeout(10, TimeUnit.SECONDS)
                            // 链接建立超时时间
                            .setConnectTimeout(10, TimeUnit.SECONDS)
                            // 数据读取超时时间
                            .setResponseTimeout(1, TimeUnit.MINUTES).build();

                    PoolingHttpClientConnectionManager connectionManager = PoolingHttpClientConnectionManagerBuilder.create()
                            // 池子总链接数
                            .setMaxConnTotal(100)
                            // 每个 ip:port 为一个route，设置每个route的最大链接数
                            .setMaxConnPerRoute(20)
                            // 松策略，高负载时会超过上述限制
                            .setPoolConcurrencyPolicy(PoolConcurrencyPolicy.LAX)
                            // 平等使用已有链接，尽量避免其过期
                            .setConnPoolPolicy(PoolReusePolicy.LIFO)
                            // 连接池中链接生存时间
                            .setConnectionTimeToLive(TimeValue.ofMinutes(5))
                            // 构建
                            .build();

                    httpClient = HttpClientBuilder.create()
                            // 关闭身份验证缓存
                            .disableAuthCaching()
                            // 关闭自动重试
                            .disableAutomaticRetries()
                            // 配置链接池
                            .setConnectionManager(connectionManager)
                            // 配置链接
                            .setDefaultRequestConfig(requestConfig)
                            // 构建
                            .build();
                }
            }
        }
        return httpClient;
    }

    /**
     * 携带header参数与url参数的Get请求
     *
     * @param url         请求URL
     * @param headerParam header参数
     * @param urlParam    url参数
     * @return 响应体
     */
    public static String doGet(String url, Map<String, String> headerParam, Map<String, Object> urlParam) {
        try {
            // 拼装url参数
            URIBuilder uriBuilder = new URIBuilder(url);
            if (MapUtils.isNotEmpty(urlParam)) {
                for (String key : urlParam.keySet()) {
                    uriBuilder.addParameter(key, String.valueOf(urlParam.get(key)));
                }
            }

            // 拼装header参数
            HttpGet httpGet = new HttpGet(uriBuilder.build());
            if (MapUtils.isNotEmpty(headerParam)) {
                for (String key : headerParam.keySet()) {
                    httpGet.addHeader(key, headerParam.get(key));
                }
            }

            // 不要关闭client，会导致连接池被关闭
            CloseableHttpClient client = getHttpClient();
            try (CloseableHttpResponse response = client.execute(httpGet)) {
                return EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 携带header参数的post请求
     *
     * @param url            请求URL
     * @param headerParam    header参数
     * @param bodyJsonString json字符串body参数
     * @return 响应体
     */
    public static String doPost(String url, Map<String, String> headerParam, String bodyJsonString) {
        try {
            HttpPost httpPost = new HttpPost(url);
            if (MapUtils.isNotEmpty(headerParam)) {
                for (String key : headerParam.keySet()) {
                    httpPost.addHeader(key, headerParam.get(key));
                }
            }

            httpPost.setEntity(new StringEntity(StringUtils.isBlank(bodyJsonString) ? "{}" : bodyJsonString, ContentType.APPLICATION_JSON));

            // 不要关闭client，会导致连接池被关闭
            CloseableHttpClient client = getHttpClient();
            try (CloseableHttpResponse response = client.execute(httpPost)) {
                return EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 携带header参数的put请求
     *
     * @param url            请求URL
     * @param headerParam    header参数
     * @param bodyJsonString json字符串body参数
     * @return 响应体
     */
    public static String doPut(String url, Map<String, String> headerParam, String bodyJsonString) {
        try {
            HttpPut httpPut = new HttpPut(url);
            if (MapUtils.isNotEmpty(headerParam)) {
                for (String key : headerParam.keySet()) {
                    httpPut.addHeader(key, headerParam.get(key));
                }
            }

            httpPut.setEntity(new StringEntity(StringUtils.isBlank(bodyJsonString) ? "{}" : bodyJsonString, ContentType.APPLICATION_JSON));

            // 不要关闭client，会导致连接池被关闭
            CloseableHttpClient client = getHttpClient();
            try (CloseableHttpResponse response = client.execute(httpPut)) {
                return EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 携带header参数的delete请求
     *
     * @param url         请求URL
     * @param headerParam header参数
     * @return 响应体
     */
    public static String doDelete(String url, Map<String, String> headerParam) {
        try {
            HttpDelete httpDelete = new HttpDelete(url);
            if (MapUtils.isNotEmpty(headerParam)) {
                for (String key : headerParam.keySet()) {
                    httpDelete.addHeader(key, headerParam.get(key));
                }
            }

            // 不要关闭client，会导致连接池被关闭
            CloseableHttpClient client = getHttpClient();
            try (CloseableHttpResponse response = client.execute(httpDelete)) {
                return EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e);
        }
    }
}

UPDATE 20220630

// 设置链接最大存活时间
HttpClientBuilder.create().setConnectionTimeToLive(2, TimeUnit.MINUTES)

经测试，setConnectionTimeToLive参数不会自动回收空闲连接，具体此项作用待查。

正确的链接自动回收应该这样设置

// 设置连接自动回收
CloseableHttpClient httpClient = HttpClientBuilder.create().evictIdleConnections(2, TimeUnit.MINUTES).build();

以下是验证过程

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) throws IOException, InterruptedException {
        SpringApplication.run(DemoApplication.class, args);


        PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager();
        // 连接池总容量
        connectionManager.setMaxTotal(5);
        // 每个host为一组，此参数用于控制每组中连接池的容量 【重要】
        connectionManager.setDefaultMaxPerRoute(10);

        RequestConfig requestConfig = RequestConfig.custom()
                // 从连接池中取连接超时时间
                .setConnectionRequestTimeout(15000)
                // 建立链接超时时间
                .setConnectTimeout(150000000)
                // 等待读取数据时间
                .setSocketTimeout(2000000000).build();

        CloseableHttpClient httpClient = HttpClientBuilder.create()
                // 关闭自动重试
                .disableAutomaticRetries()
                // 设置连接池
                .setConnectionManager(connectionManager)
                // 设置超时时间
                .setDefaultRequestConfig(requestConfig)
                // 设置连接自动回收
                .evictIdleConnections(2, TimeUnit.SECONDS)
                .build();

        new Thread(() -> {
            do {
                System.out.println(LocalDateTime.now() + connectionManager.getTotalStats().toString());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            } while (true);
        }).start();

        CloseableHttpResponse response = httpClient.execute(new HttpGet("https://www.stackoverflow.com/"));
        EntityUtils.consume(response.getEntity());
        System.out.println(LocalDateTime.now() + " FINISH");
    }
}

输出结果是这样的：

2022-06-30T17:00:08.178[leased: 0; pending: 0; available: 0; max: 5]
2022-06-30T17:00:09.189[leased: 1; pending: 0; available: 0; max: 5]
2022-06-30T17:00:10.082 FINISH
2022-06-30T17:00:10.202[leased: 0; pending: 0; available: 2; max: 5]
2022-06-30T17:00:11.216[leased: 0; pending: 0; available: 2; max: 5]
2022-06-30T17:00:12.230[leased: 0; pending: 0; available: 0; max: 5]
2022-06-30T17:00:13.241[leased: 0; pending: 0; available: 0; max: 5]
  • leased表示正在使用的连接
  • pending表示正在准备的连接（类似与浏览器F12时看到的请求pending）
  • available表示已释放可重复使用的连接
  • max表示连接池大小

根据日志打印情况，直接说结论：

  1. 请求从发起到得到相应到被消费之前（非常重要），都处于leased状态；
  2. 请求被消费之后（EntityUtils.consume()或直接关闭连接），进入available状态；
  3. 默认情况下available状态的链接不会被主动释放，等待下一次调用；
  4. 对client设置了evictIdleConnections属性后链接才可以被自动回收；
  5. setConnectionTimeToLive不是自动回收设置，也不是链接最大有效时长设置，当此项设置时间小于请求响应时间时连接也无法被关闭，具体作用不明；
  6. 可以使用connectionManager.closeIdleConnections方法手动回收处于available的空闲链接；
  7. CSDN上绝大多数关于HttpClient自动回收设置的文章都是错的；

参考文章 https://blog.csdn.net/u013332124/article/details/82694076

半斤米粉闯天下
关注
  • 4
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Httpclient线程池的管理和利用
u010486495的专栏
04-04 3763
http协议时无连接的，本质上是需要和服务器建立连接的。对于需要从同一个站点抓取大量网页的程序，应该使用连接池，否则每次抓取都和Web站点建立连接、发送请求、获得响应、释放连接，一方面效率不高，另一方面稍不小心就会疏忽了某些资源的释放、导致站点拒绝连接（很多站点会拒绝同一个ip的大量连接、防止DOS攻击）。 packagetest.ffm83.commons.httpClient; importj...
spring boot 整合 HttpClient实现线程池连接
weixin_43360488的博客
07-23 2735
HTTP 协议是现在 Internet 上使用得最多、最重要的协议，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java net包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活。HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。
SpringBoot整合HttpClient结合线程池，且简单模仿MyBatisPlus设计思想
最新发布
m0_59926335的博客
04-06 293
近期想写一个针对某高校系统的套壳系统，提高其安全与使用便利性，优化用户体验，使用的第三方库为HttpClient。且最近简单了解了MyBatisPlus在MyBatis 的基础上只做增强不做改变的设计，所以简单用HttpClient进行了设计，不再使用原始的设计为工具类。
HttpClient 简介与实现
春风化雨
09-05 2047
HttpClient 是Apache Jakarta Common 下的子项目，可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。 1、简介 HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java ne...
HttpClient线程池原理
业精于勤，荒于嬉；行成于思，毁于随。
03-14 4589
HttpClient线程池原理 1.cpool对象 [java] view plain copy  print? class CPool extends AbstractConnPool {          private static final AtomicLong COUNTER = new AtomicLong();     
使用单例模式实现自己的HttpClient工具类
weixin_30906185的博客
08-17 387
引子 在Android开发中我们经常会用到网络连接功能与服务器进行数据的交互，为此Android的SDK提供了Apache的HttpClient来方便我们使用各种Http服务。你可以把HttpClient想象成一个浏览器，通过它的API我们可以很方便的发出GET，POST请求（当然它的功能远不止这些）。 比如你只需以下几行代码就能发出一个简单的GET请求并打印响应结果： try { ...
使用java的HttpClient实现多线程并发
09-01
bleHttpClient httpClient; private static PoolingHttpClientConnectionManager cm; 静态初始化HttpClient和连接池管理器： ```java static { // 创建连接池管理器 cm = new PoolingHttpClientConnectionManager...
关于Https协议和HttpClient的实现详解
08-27
HttpClient的实现是通过HttpClientBuilder来实现的。HttpClientBuilder可以设置连接工厂、域名校验器、SSL连接工厂等。HttpClient可以通过设置SSL连接工厂来支持HTTPS协议。 在HttpClient中，可以通过设置SSL连接...
HttpClient4.5 实现https忽略SSL证书验证
09-22
使用HttpClient4.5实现https请求忽略SSL证书验证工具类
HttpClient+ Spring实现多线程
07-28
通过这种方式，你可以利用Spring的依赖注入和线程池管理，配合HttpClient的并发能力，实现高效的多线程HTTP请求。注意在并发环境中，必须确保HttpClient的线程安全，例如，避免在多个线程之间共享同一个HttpClient...
php实现httpclient类.zip
07-11
主要介绍了php实现httpclient类示例,需要的朋友可以参考下，buffer 获取返回的字符串，referer 设置 HTTP_REFERER 的网址，response 服务器响应的 header 信息，request 发送到服务器的 header 信息。
java httpclient 单例_HttpClientFactory的套路，你知多少？
weixin_39712969的博客
02-24 391
背景ASP.NET Core 在 2.1 之后推出了具有弹性 HTTP 请求能力的 HttpClient 工厂类 HttpClientFactory。替换的初衷还是简单摆一下：① using(var client = new HttpClient()) 调用的 Dispose() 方法并不会立即释放底层 Socket 连接，新建 Socket 需要时间，导致在高并发场景下 Socket 耗尽。② ...
详解双重判定下的单例模式
Only_Young的博客
04-17 964
单例模式：保证一个类只有一个实例，并且提供一个可以访问的全局入口。 优点：节省内存、节省计算、方便管理 应用举例：无状态的工具类（日志工具、字符串工具）、全局信息类（全局记数、环境变量） 常见的五种写法：从简单到难递进 ######饿汉式写法： 优点：类装载的时候就完成了初始化，避免了线程同步的问题。 缺点：从始至终没有使用实例，造成内存浪费。 /** * 饿汉式： */ public cla...
线程池+HttpClient连接池读取指定目录下的所有内容作为参数下载数据
qq_26496077的博客
07-07 1027
由于工作需要，希望读取文件中的数据作为参数，调用API，返回结果存入到数据库或者excel文件中，如果使用单线程以及File包，如下代码： File file = new File("文件路径"); InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(template[i]), encoding); BufferedReader bufferedReader = new BufferedReader(
java httpclient 单例_【Java系列007】HttpClient调用：你考虑过关闭连接、并发了吗？...
weixin_32204013的博客
02-24 607
HttpClient在项目中还是比较常见的，主要都是通过GET或POST请求第三方以获取响应结果。前段时间还了解到也有企业用它来做爬虫。下面我们就从两方面来一起学习HttpClient。强占着不放我们先来看一张因未释放连接导致的异常图。 我们再来看代码，代码很简单，用一个static修饰HttpClient的一个对象，也是用static的方式实例化(并发下，static实例化的对象是线程不安全的)...
单例模式（双重检测锁式单例不安全的原因与解决）
GoodBoy的博客
04-21 2451
单例模式 核心作用 保证一个类只有一个对象，并且提供一个访问该实例的全局访问点 单例模式的优点 由于单例模式只生成一个实例，减少了系统的开销，当一个对象需要比较的多的资源时，如读取配置、产生其它依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决 单例模式可以在系统设置全局访问点，优化环共享资源访问，例如可以设计一个单例类，负责所以数据表的映射处理 常见的五...
http线程池的优化
qq_32532853的博客
02-24 1771
我们原来用的httpClient一直都是com.ning.http.client.AsyncHttpClient(线程池管理类)，需要的时候申请，不需要的时候释放。并发比较高的情况下，存在http链接不释放的问题，升级了版本也解决不了，我最近对它进行了一次重构，彻底解决了这个问题 替换的思路就是用ThreadLocal来为每一个线程分配一个HttpClient，使用后自己释放链接，这样每个线程就...
java http请求线程池_Http请求封装（对HttpClient类的进一步封装，使之调用更方便。另外，此类管理唯一的HttpClient对象，支持线程池调用，效率更高）...
weixin_30561959的博客
03-02 289
package com.ad.ssp.engine.common;import java.io.IOException;import java.util.ArrayList;import java.util.List;import java.util.Map;import java.util.Map.Entry;import org.apache.http.Header;import org.ap...
HttpClientFactory单例模式设计，方便以后直接使用
perfect_red的博客
11-24 1094
httpClient对象，一般推荐单例模式，这是一个可配置性很强的对象，同时也说明初始化需要很多复杂流程，初始化成本很高，以下为一个单例设计，以后有需要，不断完善注释信息，方便以后直接使用: /** * @author yaoqiang * @date 2020/9/23 10:07 * @description 对 {@link HttpClientWrapper} 做修改，不改动原类，重新编写 * @see HttpClientWrapper */ public class HttpCl
用HttpClient来实现
05-24
好的，使用HttpClient来实现对话可以分为以下几个步骤： 1. 创建HttpClient实例 ``` CloseableHttpClient httpClient = HttpClients.createDefault(); ``` 2. 创建HttpPost请求 ``` HttpPost httpPost = new HttpPost(url); ``` 其中，url是对话接口的地址。 3. 设置请求参数 对于ChitGPT，我们需要设置请求参数为JSON格式的字符串，例如： ``` StringEntity entity = new StringEntity("{\"text\": \"" + text + "\", \"context\": \"" + context + "\"}"); entity.setContentType("application/json"); httpPost.setEntity(entity); ``` 其中，text是用户输入的文本，context是对话上下文信息。 4. 执行请求并获取响应 ``` CloseableHttpResponse response = httpClient.execute(httpPost); ``` 5. 处理响应结果 ``` String result = EntityUtils.toString(response.getEntity(), "UTF-8"); ``` 其中，result为对话接口返回的JSON格式的字符串。 完整的代码示例如下： ``` import java.io.IOException; import org.apache.http.client.methods.CloseableHttpResponse; import org.apache.http.client.methods.HttpPost; import org.apache.http.entity.StringEntity; import org.apache.http.impl.client.CloseableHttpClient; import org.apache.http.impl.client.HttpClients; import org.apache.http.util.EntityUtils; public class ChatHttpClient { public static void main(String[] args) throws IOException { CloseableHttpClient httpClient = HttpClients.createDefault(); String url = "http://api.qingyunke.com/api.php?key=free&appid=0&msg="; String text = "你好"; String context = ""; HttpPost httpPost = new HttpPost(url); StringEntity entity = new StringEntity("{\"text\": \"" + text + "\", \"context\": \"" + context + "\"}"); entity.setContentType("application/json"); httpPost.setEntity(entity); CloseableHttpResponse response = httpClient.execute(httpPost); String result = EntityUtils.toString(response.getEntity(), "UTF-8"); System.out.println(result); response.close(); httpClient.close(); } } ``` 需要注意的是，这里使用了青云客的API作为示例，实际应用中需要替换成对应的对话接口。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值