HttpClient连接池复用连接详解
HttpClient连接池的核心作用是复用TCP连接,减少连接建立和关闭的开销，提升性能，下面是实现连接池复用的关键配置和原理：
基础配置示例
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.client.config.RequestConfig;
// 创建连接池管理器
PoolingHttpClientConnectionManager connectionManager =
new PoolingHttpClientConnectionManager();
// 设置最大连接数
connectionManager.setMaxTotal(200);
// 设置每个路由（host:port）的最大连接数
connectionManager.setDefaultMaxPerRoute(20);
// 创建HttpClient
CloseableHttpClient httpClient = HttpClientBuilder.create()
.setConnectionManager(connectionManager)
.setDefaultRequestConfig(RequestConfig.custom()
.setConnectionRequestTimeout(5000) // 从连接池获取连接的超时时间
.setConnectTimeout(5000) // 建立连接的超时时间
.setSocketTimeout(5000) // 等待数据的超时时间
.build())
.build();
连接池复用机制
// 连接池的核心实现
public class ConnectionPoolDemo {
public static void main(String[] args) throws Exception {
// 1. 创建连接池管理器
PoolingHttpClientConnectionManager cm =
new PoolingHttpClientConnectionManager();
// 2. 配置连接池参数
cm.setMaxTotal(100); // 最大连接数
cm.setDefaultMaxPerRoute(10); // 每个路由默认最大连接
// 3. 创建HttpClient
CloseableHttpClient httpClient = HttpClientBuilder.create()
.setConnectionManager(cm)
.evictIdleConnections(60, TimeUnit.SECONDS) // 清理空闲连接
.build();
// 4. 复用连接执行请求
for (int i = 0; i < 100; i++) {
HttpGet httpGet = new HttpGet("http://example.com/api");
try (CloseableHttpResponse response = httpClient.execute(httpGet)) {
// 处理响应... 注意：必须消费response的内容
}
}
// 5. 关闭连接池
httpClient.close();
}
}
关键配置和优化
@Configuration
public class HttpClientConfig {
@Bean
public CloseableHttpClient httpClient() {
// 1. 连接池配置
PoolingHttpClientConnectionManager cm =
new PoolingHttpClientConnectionManager();
// 总连接数
cm.setMaxTotal(500);
// 每个路由默认最大连接
cm.setDefaultMaxPerRoute(50);
// 2. 为特定路由设置更多连接
HttpHost specificHost = new HttpHost("api.example.com", 8080, "https");
cm.setMaxPerRoute(new HttpRoute(specificHost), 100);
// 3. 连接池维护策略
cm.setValidateAfterInactivity(5000); // 空闲5秒后验证连接
// 4. 请求配置
RequestConfig requestConfig = RequestConfig.custom()
.setConnectionRequestTimeout(3000) // 从连接池获取连接的超时
.setConnectTimeout(5000) // 与服务器建立连接的超时
.setSocketTimeout(10000) // 数据传输超时
.build();
// 5. HttpClient配置
return HttpClientBuilder.create()
.setConnectionManager(cm)
.setDefaultRequestConfig(requestConfig)
.setConnectionTimeToLive(60, TimeUnit.SECONDS) // 连接存活时间
.evictIdleConnections(30, TimeUnit.SECONDS) // 30秒清理空闲连接
.evictExpiredConnections() // 清理过期连接
.setRetryHandler(new DefaultHttpRequestRetryHandler(2, true)) // 重试2次
.build();
}
}
连接复用执行请求
@Service
public class HttpService {
@Autowired
private CloseableHttpClient httpClient;
public String executeGet(String url) throws IOException {
HttpGet httpGet = new HttpGet(url);
httpGet.setHeader("Connection", "keep-alive");
try (CloseableHttpResponse response = httpClient.execute(httpGet)) {
// 注意：必须完全消费response，才能复用连接
String result = EntityUtils.toString(response.getEntity());
// EntityUtils.consume(response.getEntity()); // 或者消费实体
return result;
}
}
// 正确复用连接的方式
public String correctWay(String url) throws IOException {
HttpGet httpGet = new HttpGet(url);
CloseableHttpResponse response = null;
try {
response = httpClient.execute(httpGet);
HttpEntity entity = response.getEntity();
// 必须消费实体内容，否则连接无法复用
String result = EntityUtils.toString(entity);
return result;
} finally {
if (response != null) {
try {
// 确保响应被完全消费
EntityUtils.consume(response.getEntity());
} finally {
response.close();
}
}
}
}
}
连接状态和监控
@Component
public class ConnectionPoolMonitor {
@Autowired
private PoolingHttpClientConnectionManager connectionManager;
@Scheduled(fixedRate = 30000) // 每30秒监控一次
public void monitorPool() {
PoolStats poolStats = connectionManager.getTotalStats();
System.out.println("连接池状态：");
System.out.println("连接数： " + poolStats.getLeased() +
"/" + poolStats.getAvailable() +
"/" + poolStats.getPending());
System.out.println("最大连接数：" + poolStats.getMax());
// 获取特定路由的状态
HttpHost host = new HttpHost("api.example.com");
PoolStats hostStats = connectionManager.getStats(host);
System.out.println(host + " 连接数：" + hostStats.getLeased());
}
}
常见问题和解决方案
public class HttpClientProblems {
// 问题1：连接泄漏 - 未正确关闭响应
public void problem1() throws IOException {
CloseableHttpResponse response = httpClient.execute(new HttpGet(url));
// 错误方式：直接返回，不关闭response
return EntityUtils.toString(response.getEntity());
}
// 问题2：连接超时配置不当
public void problem2() {
RequestConfig config = RequestConfig.custom()
.setConnectionRequestTimeout(0) // 连接池获取连接不限制超时
.setConnectTimeout(0) // 连接建立不限制超时
.build(); // 可能导致线程卡死
}
// 解决方案：正确的连接管理
public void solution() {
CloseableHttpClient httpClient = HttpClientBuilder.create()
.setConnectionManager(new PoolingHttpClientConnectionManager())
// 添加连接回收策略
.setConnectionReuseStrategy(DefaultConnectionReuseStrategy.INSTANCE)
// 设置连接存活时间
.setConnectionTimeToLive(60, TimeUnit.SECONDS)
// 空闲连接清理
.evictIdleConnections(30, TimeUnit.SECONDS)
// 连接池关闭时自动关闭连接
.setConnectionManagerShared(false)
.build();
}
}
性能最佳实践
# application.yml
httpclient:
pool:
max-total: 200
default-max-per-route: 20
max-per-route:
api.example.com: 50
api2.example.com: 30
timeout:
connect: 5000
connection-request: 3000
socket: 10000
pool-strategy:
time-to-live: 60s
idle-timeout: 30s
validate-after-inactivity: 5s
关键要点：
- 必须正确关闭和消费响应实体,才能复用连接
- 合理配置连接数,避免过多或过少
- 设置合适的超时时间,防止线程阻塞
- 定期清理空闲连接,释放资源
- 监控连接池状态,及时发现问题
连接池复用连接是提升HTTP性能的关键,但需要正确使用才能发挥效果。
