寻求 RestClient 配置的增强功能

Question

我正在使用 RestClient 进行上游通信，并希望添加一些增强功能以使其更加健壮。这是我当前的设置：

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

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

    Map<String, Object> response = restClient.get()
                .uri(backend)
                .retrieve()
                .body(Map.class);

关于环境：

1. JDK21
2. org.springframework.boot:3.2.0-M3
3. spring.threads.virtual.enabled=true

我希望得到以下方面的建议：

1. 将 断路器 与 RestClient 集成。
2. 实施重试机制。
3. 将客户端配置为使用代理网关。

有人以前做过这个或者可以给我指出相关资源吗？

Answer 1

这是我的工作解决方案。

/**
 * A service class responsible for processing backend requests with 
 * retry and circuit breaker mechanisms.
 */
@Service
public class Processor {

    private final RestClient restClient;
    private final ExecutorService executor;
    private final RetryTemplate retryTemplate;
    private static final String RESULT = "result";
    private static CircuitConfig circuit;

    /**
     * Constructor for the Processor class.
     *
     * @param circuit The circuit breaker configuration.
     */
    @Autowired
    public Processor(CircuitConfig circuit) {
        this.circuit = circuit;
        
        // Setting up client request factory with timeouts
        SimpleClientHttpRequestFactory simpleClientHttpRequestFactory = new SimpleClientHttpRequestFactory();
        simpleClientHttpRequestFactory.setConnectTimeout(300);
        simpleClientHttpRequestFactory.setReadTimeout(300);
        
        this.restClient = RestClient.builder()
                                    .requestFactory(simpleClientHttpRequestFactory)
                                    .baseUrl("http://...:8080/../")
                                    .build();

        this.executor = Executors.newVirtualThreadPerTaskExecutor();
        this.retryTemplate = createRetryTemplate();
        System.out.println("CompletableFuture...");
    }

    /**
     * Creates a retry template with exponential back-off policy.
     *
     * @return A configured RetryTemplate instance.
     */
    private RetryTemplate createRetryTemplate() {
        RetryTemplate retryTemplate = new RetryTemplate();
        
        // Setting exponential back-off policy
        ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
        backOffPolicy.setInitialInterval(100);
        backOffPolicy.setMultiplier(2.0);
        backOffPolicy.setMaxInterval(1000);
        retryTemplate.setBackOffPolicy(backOffPolicy);

        // Setting simple retry policy with max attempts
        SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
        retryPolicy.setMaxAttempts(3);
        retryTemplate.setRetryPolicy(retryPolicy);

        return retryTemplate;
    }

    /**
     * Retrieves backend response with retry mechanism.
     *
     * @param backend The backend URI.
     * @return A map representing the backend response.
     */
    public Map getBackendResp(String backend) {
        return retryTemplate.execute(retryContext ->
                restClient
                .get()
                .uri(backend)
                .retrieve()
                .body(Map.class));
    }

    /**
     * Wraps the backend request within a CompletableFuture for asynchronous processing.
     *
     * @param backend The backend URI.
     * @return A CompletableFuture containing a map representing the backend response.
     */
    private CompletableFuture<Map> getFuture(String backend) {
        return CompletableFuture.supplyAsync(() -> circuit.circuitBreaker.executeSupplier(() -> getBackendResp(backend)));
    }
}

我想了解是否一切都在虚拟线程范例下运行，但这方面对我来说仍然不明确。