RestClient配置增强咨询：集成circuit breaker、retry及proxy gateway

基于Spring Boot 3.2 + JDK21的RestClient鲁棒性增强方案 #

针对你提出的三个需求，结合当前技术栈给出以下可落地的实践方案：

1. 集成断路器（Resilience4j实现）

Spring Boot 3.2默认适配Resilience4j作为断路器组件，步骤如下：

第一步：添加依赖
在pom.xml中引入必要依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-spring-boot3</artifactId>
</dependency>

第二步：配置断路器规则
在application.yml中定义上游服务的断路器策略：

resilience4j.circuitbreaker:
  instances:
    upstreamService:
      slidingWindowSize: 100          # 滑动窗口大小
      failureRateThreshold: 50        # 失败率阈值（%）
      waitDurationInOpenState: 10s    # 打开状态持续时间
      permittedNumberOfCallsInHalfOpenState: 5  # 半开状态允许的请求数
      automaticTransitionFromOpenToHalfOpenEnabled: true  # 自动从打开转半开

第三步：改造RestClient请求
用断路器包裹请求逻辑，同时添加降级处理：

@Autowired
private CircuitBreakerFactory circuitBreakerFactory;

public Map<String, Object> fetchUpstreamData(String backend) {
    CircuitBreaker circuitBreaker = circuitBreakerFactory.create("upstreamService");
    return circuitBreaker.run(() -> restClient.get()
                    .uri(backend)
                    .retrieve()
                    .body(Map.class),
            throwable -> {
                // 断路器打开时的降级逻辑，返回默认值或抛出自定义异常
                return Collections.emptyMap();
            });
}

2. 实现重试机制（Resilience4j Retry）

和断路器统一使用Resilience4j组件，避免依赖冗余：

第一步：添加重试配置
在application.yml中补充重试规则：

resilience4j.retry:
  instances:
    upstreamService:
      maxAttempts: 3                  # 最大重试次数
      waitDuration: 500ms             # 重试间隔
      retryExceptions:                # 需要重试的异常类型
        - org.springframework.web.client.HttpServerErrorException
        - java.net.SocketTimeoutException
        - java.net.ConnectException

第二步：组合重试与断路器
确保重试不会触发断路器误判，将两者串联使用：

@Autowired
private RetryRegistry retryRegistry;

public Map<String, Object> fetchUpstreamData(String backend) {
    CircuitBreaker circuitBreaker = circuitBreakerFactory.create("upstreamService");
    Retry retry = retryRegistry.retry("upstreamService");
    
    return Decorators.ofSupplier(() -> restClient.get()
                    .uri(backend)
                    .retrieve()
                    .body(Map.class))
            .withRetry(retry)
            .withCircuitBreaker(circuitBreaker)
            .withFallback(throwable -> Collections.emptyMap())
            .get();
}

若偏好Spring原生Retry，也可使用RetryTemplate：

@Bean
public RetryTemplate retryTemplate() {
    SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
    retryPolicy.setMaxAttempts(3);
    
    FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
    backOffPolicy.setBackOffPeriod(500);
    
    RetryTemplate template = new RetryTemplate();
    template.setRetryPolicy(retryPolicy);
    template.setBackOffPolicy(backOffPolicy);
    return template;
}

// 使用示例
public Map<String, Object> fetchUpstreamData(String backend) {
    return retryTemplate.execute(context -> restClient.get()
                    .uri(backend)
                    .retrieve()
                    .body(Map.class));
}

3. 配置代理网关

根据需求选择两种配置方案，推荐使用更灵活的HTTP客户端实现：

方案一：基于SimpleClientHttpRequestFactory配置代理
直接在原有工厂上设置代理：

SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
factory.setConnectTimeout(300);
factory.setReadTimeout(300);

// 设置代理地址与端口
Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("proxy.example.com", 8080));
factory.setProxy(proxy);

// 代理需要认证时配置全局认证器
Authenticator.setDefault(new Authenticator() {
    @Override
    protected PasswordAuthentication getPasswordAuthentication() {
        return new PasswordAuthentication("proxyUser", "proxyPass".toCharArray());
    }
});

RestClient restClient = RestClient.builder()
        .requestFactory(factory)
        .baseUrl("http://...:8080/..")
        .build();

方案二：使用HttpComponentsClientHttpRequestFactory（推荐）
先添加Apache HttpClient依赖：

<dependency>
    <groupId>org.apache.httpcomponents.client5</groupId>
    <artifactId>httpclient5</artifactId>
</dependency>

然后配置带代理的HTTP客户端：

CloseableHttpClient httpClient = HttpClients.custom()
        .setProxy(new HttpHost("proxy.example.com", 8080))
        .setDefaultCredentialsProvider(() -> {
            CredentialsProvider provider = new BasicCredentialsProvider();
            provider.setCredentials(
                    new AuthScope("proxy.example.com", 8080),
                    new UsernamePasswordCredentials("proxyUser", "proxyPass")
            );
            return provider;
        })
        .build();

HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory(httpClient);
factory.setConnectTimeout(300);
factory.setReadTimeout(300);

RestClient restClient = RestClient.builder()
        .requestFactory(factory)
        .baseUrl("http://...:8080/..")
        .build();

额外优化建议 #

• 适配JDK21虚拟线程：将Resilience4j线程池配置为虚拟线程，减少阻塞资源消耗，在application.yml中添加：

  resilience4j.thread-pool-bulkhead:
    instances:
      upstreamService:
        coreThreadPoolSize: 10
        maxThreadPoolSize: 100
        threadFactory: virtual
  

• 全局异常处理：通过RestClient的defaultStatusHandler统一处理HTTP状态码异常：

  RestClient restClient = RestClient.builder()
          .requestFactory(factory)
          .baseUrl("http://...:8080/..")
          .defaultStatusHandler(HttpStatusCode::is5xxServerError, (request, response) -> {
              throw new UpstreamServerException("上游服务异常");
          })
          .build();
  

内容的提问来源于stack exchange，提问作者Md. Hasan Basri