http client实现请求级别的配置

笔记：单例RestTemplate下为指定请求定制差异化超时（Apache HttpClient）

一、业务背景（真实案例）

核心诉求：项目中已单例化RestTemplate（底层为Apache HttpClient），全局配置了默认超时时间，但部分接口（如大文件下载、第三方慢接口）需要更大的超时时间；
约束条件：不希望创建多个RestTemplate实例（避免连接池隔离、资源浪费），仅针对特定请求定制超时。

二、核心思路（正确性验证）

1. 思路可行性

RestTemplate支持「全局默认配置 + 请求级配置覆盖」，底层Apache HttpClient的RequestConfig支持请求级定制，无需多实例，是生产环境最佳实践。

2. 需规避的错误思路

错误思路	问题点
创建多个RestTemplate实例	连接池无法复用，高并发下资源耗尽
修改全局RequestConfig	影响所有请求，不符合“仅部分请求差异化”诉求
拦截器动态改超时	逻辑复杂，易引入线程安全问题

三、技术原理

1. 配置优先级

请求级RequestConfig > RestTemplate全局RequestConfig > Apache HttpClient默认配置。

2. 核心原理

RestTemplate单例复用连接池（PoolingHttpClientConnectionManager），保证资源复用；
通过RestTemplate.execute()方法，结合RequestCallback为单个请求绑定自定义RequestConfig，覆盖全局超时参数；
RequestConfig.copy()复用全局配置，仅修改差异化参数（避免重复配置）。

四、落地实现（完整代码）

1. 全局配置（单例RestTemplate+默认超时）

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.HttpClients;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {
    // 1. 连接池配置（全局单例，核心资源）
    @Bean
    public PoolingHttpClientConnectionManager connectionManager() {
        PoolingHttpClientConnectionManager manager = new PoolingHttpClientConnectionManager();
        manager.setMaxConnTotal(200); // 连接池总连接数
        manager.setDefaultMaxPerRoute(50); // 单路由最大连接数
        return manager;
    }

    // 2. 全局默认RequestConfig（大部分请求使用）
    @Bean
    public RequestConfig globalRequestConfig() {
        return RequestConfig.custom()
                .setConnectTimeout(5000)    // 连接超时：5s
                .setResponseTimeout(10000)  // 读取超时：10s
                .setConnectionRequestTimeout(3000) // 连接池获取超时：3s
                .build();
    }

    // 3. HttpClient实例（绑定全局配置）
    @Bean
    public CloseableHttpClient httpClient(PoolingHttpClientConnectionManager manager,
                                          RequestConfig globalRequestConfig) {
        return HttpClients.custom()
                .setConnectionManager(manager)
                .setDefaultRequestConfig(globalRequestConfig) // 绑定全局默认配置
                .build();
    }

    // 4. 单例RestTemplate（全局唯一）
    @Bean
    public RestTemplate restTemplate(CloseableHttpClient httpClient) {
        HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory(httpClient);
        return new RestTemplate(factory);
    }
}

2. 定制化请求实现（覆盖超时）

import org.apache.hc.client5.http.config.RequestConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;
import org.springframework.http.client.ClientHttpRequest;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RequestCallback;
import org.springframework.web.client.RestTemplate;

@Service
public class CustomTimeoutService {
    @Autowired
    private RestTemplate restTemplate;

    /**
     * 通用请求：使用全局默认超时
     */
    public String normalRequest(String url) {
        return restTemplate.getForObject(url, String.class);
    }

    /**
     * 特殊请求：定制超时（如连接10s，读取30s）
     */
    public String specialTimeoutRequest(String url) {
        // 1. 构建自定义RequestConfig（复用全局配置，仅修改差异化参数）
        RequestConfig customConfig = RequestConfig.copy(
                        restTemplate.getRequestFactory()
                                .getHttpClient()
                                .getDefaultRequestConfig() // 获取全局默认配置
                )
                .setConnectTimeout(10000)     // 覆盖：连接超时10s
                .setResponseTimeout(30000)   // 覆盖：读取超时30s
                // 非必要不修改：connectionRequestTimeout沿用全局3s
                .build();

        // 2. 自定义RequestCallback：绑定当前请求的专属配置
        RequestCallback requestCallback = new RequestCallback() {
            @Override
            public void doWithRequest(ClientHttpRequest request) {
                // 关键：将自定义配置绑定到当前请求
                ((HttpComponentsClientHttpRequest) request).getHttpUriRequest()
                        .setConfig(customConfig);
            }
        };

        // 3. 执行请求（使用execute方法支持RequestCallback）
        return restTemplate.execute(
                url,
                HttpMethod.GET,
                requestCallback,
                response -> { // 响应处理逻辑
                    if (response.getStatusCode().is2xxSuccessful()) {
                        return response.getBody() != null 
                                ? new String(response.getBody().readAllBytes()) 
                                : "";
                    } else {
                        throw new RuntimeException("请求失败：" + response.getStatusCode());
                    }
                }
        );
    }
}

3. 通用工具类封装（简化重复代码）

import org.apache.hc.client5.http.config.RequestConfig;
import org.springframework.http.HttpMethod;
import org.springframework.http.client.ClientHttpRequest;
import org.springframework.web.client.RequestCallback;
import org.springframework.web.client.RestTemplate;

import java.util.function.Function;

/**
 * RestTemplate超时定制工具类
 */
public class RestTemplateTimeoutUtils {
    /**
     * 执行带自定义超时的请求
     * @param restTemplate 单例RestTemplate
     * @param url 请求地址
     * @param method 请求方法（GET/POST等）
     * @param connectTimeout 连接超时（毫秒）
     * @param responseTimeout 读取超时（毫秒）
     * @param responseExtractor 响应处理逻辑
     * @return 响应结果
     */
    public static <T> T executeWithCustomTimeout(
            RestTemplate restTemplate,
            String url,
            HttpMethod method,
            int connectTimeout,
            int responseTimeout,
            Function<org.springframework.http.client.ClientHttpResponse, T> responseExtractor) {

        // 1. 复制全局配置，仅修改差异化超时
        RequestConfig globalConfig = restTemplate.getRequestFactory()
                .getHttpClient().getDefaultRequestConfig();
        RequestConfig customConfig = RequestConfig.copy(globalConfig)
                .setConnectTimeout(connectTimeout)
                .setResponseTimeout(responseTimeout)
                .build();

        // 2. 绑定自定义配置到当前请求
        RequestCallback callback = request -> ((HttpComponentsClientHttpRequest) request)
                .getHttpUriRequest().setConfig(customConfig);

        // 3. 执行请求
        return restTemplate.execute(url, method, callback, responseExtractor);
    }
}

4. 工具类使用示例

// 简化后的特殊请求调用
public String simplifySpecialRequest(String url) {
    return RestTemplateTimeoutUtils.executeWithCustomTimeout(
            restTemplate,
            url,
            HttpMethod.GET,
            10000,  // 连接超时10s
            30000,  // 读取超时30s
            response -> new String(response.getBody().readAllBytes())
    );
}

五、关键注意事项

1. 线程安全

自定义RequestConfig为请求级局部变量，仅作用于当前请求，无线程安全问题；
切勿在多线程下修改RestTemplate全局RequestFactory。

2. 连接池复用

所有请求复用同一个PoolingHttpClientConnectionManager，即使超时不同，连接池资源仍共享，性能不受影响。

3. 异常处理

差异化超时请求需单独捕获超时异常（如ConnectTimeoutException/SocketTimeoutException）；
避免与全局请求的异常处理逻辑混淆。

4. 配置复用

使用RequestConfig.copy()复用全局配置，仅修改需要差异化的参数（减少冗余配置）；
未修改的参数（如connectionRequestTimeout）沿用全局值。

六、核心总结

1. 核心方案

单例RestTemplate + 请求级RequestConfig覆盖，实现差异化超时，无需多实例。

2. 关键要点

要点	说明
配置优先级	请求级 > 全局 > HttpClient默认
核心方法	`RestTemplate.execute()` + `RequestCallback`
资源复用	单例连接池保证高并发下的资源效率
维护性	工具类封装减少重复代码，便于统一维护

3. 适用场景

部分接口需要更大超时（如慢接口、大文件下载）；
不同环境（测试/生产）需差异化超时；
第三方接口超时与内部接口不一致。

posted @ 2026-01-07 20:36 coder江阅读(3) 评论(0) 收藏举报

刷新页面返回顶部

lliujiang