RedirectClient client = RestClientBuilder.newBuilder()
                                         .baseUri(someUri)
                                         .followRedirects(true)
                                         .build(RedirectClient.class);

ProxiedClient client = RestClientBuilder.newBuilder()
                                        .baseUri(someUri)
                                        .proxyAddress("myproxy.mycompany.com", 8080)
                                        .build(ProxiedClient.class);

public interface QueryClient {
    Response sendMultiValues(@QueryParam("myParam") List<String> values);
}

QueryClient client = RestClientBuilder.newBuilder()
                                      .baseUri(someUri)
                                      .queryParamStyle(QueryParamStyle.COMMA_SEPARATED)
                                      .build(QueryClient.class);
Response response = client.sendMultiValues(Collections.asList("abc", "mno", "xyz"));

private static final List<String> HELLO_SERVICE_URLS = List.of(
            "http://localhost:7002", // japanese hello service
            "http://localhost:7003", // english hello service
            "http://localhost:7004"  // chinese hello service
        );
private List<HelloRestClient> helloClients;

@PostConstruct
public void init() {
    // URLごとにRestClientインスタンスを生成
    helloClients = HELLO_SERVICE_URLS.stream()
            .map(url ->
                RestClientBuilder.newBuilder()     // 1. 
                    .baseUri(URI.create(url))      // 2. 
                    .build(HelloRestClient.class)) // 3.
            .toList();
}

@Path("/hello")
public interface HelloRestClient extends AutoCloseable {
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    @ClientHeaderParam(name="X-Requested-Timestamp", value="{generateTimestamp}")
    String hello();
    default String generateTimestamp() {
        var formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss,SSS");
        return formatter.format(LocalDateTime.now());
    }
}

public class TimestampHeaderFactory implements ClientHeadersFactory {
    @Override
    public MultivaluedMap<String, String> update(
              MultivaluedMap<String, String> incomingHeaders,         // 1.
              MultivaluedMap<String, String> clientOutgoingHeaders) { // 2.
        var newHeadersMap = new MultivaluedHashMap<String, String>(clientOutgoingHeaders); // 3.
        if (!incomingHeaders.containsKey("X-Suppress-Timestamp")) {   // 4.
            newHeadersMap.add("X-Requested-Timestamp", generateTimestamp());
        }
        return newHeadersMap; // 5.
    }
    private String generateTimestamp() {
        var formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss,SSS");
        return formatter.format(LocalDateTime.now());
    }
}

@Path("/hello")
@RegisterClientHeaders(TimestampHeaderFactory.class)
public interface HelloRestClient extends AutoCloseable {
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    String hello();
}

@Path("/hello")
@RegisterClientHeaders(TimestampHeaderFactory.class)
public interface HelloRestClient extends AutoCloseable {
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    String hello();
}

@RequestScoped
@Path("/aggregate")
public class HelloAggregateResource {
    ...
    @GET
    @Path("/sync")
    @Produces(MediaType.TEXT_PLAIN)
    public String aggregateHello() {
        return helloClients.stream()                // 1.
                .map(HelloRestClient::hello)        // 2.
                .collect(Collectors.joining(", ")); // 3.
    }
    ...

@RequestScoped
@Path("/hello")
public class HelloServiceResource {
    private static Logger LOG = LoggerFactory.getLogger(HelloServiceResource.class);
    @Inject
    @ConfigProperty(name = "hello.message", defaultValue = "Hello!")
    private String hello;
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello(@HeaderParam("X-Requested-Timestamp") String timestamp) throws Exception {
        LOG.info("Requested-Timestamp:{}/{}-service:request recieved", timestamp, this.hello);
        Thread.sleep(1000L);
        return this.hello;
    }
}

$ curl localhost:7001/aggregate/sync
[helidon-server-2] - Requested-Timestamp:2022-10-03 20:25:56,788/こんにちは-service:request recieved
[helidon-server-2] - Requested-Timestamp:2022-10-03 20:25:57,850/Hello-service:request recieved
[helidon-server-2] - Requested-Timestamp:2022-10-03 20:25:58,928/ニイハオ-service:request recieved
こんにちは, Hello, ニイハオ

@Path("/hello")
@RegisterClientHeaders(TimestampHeaderFactory.class)
public interface HelloRestClient extends AutoCloseable {
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    CompletionStage<String> asyncHello(); // 結果のStringをCompletionStageで受け取る
}

@RequestScoped
@Path("/aggregate")
public class HelloAggregateResource {
    ...
    @GET
    @Path("/async")
    @Produces(MediaType.TEXT_PLAIN)
    public String asyncAggregateHello() {
        // 非同期処理の実行
        final CompletableFuture<String>[] futures = helloClients.stream()
                .map(HelloRestClient::asyncHello)   // 1.
                .toArray(CompletableFuture[]::new); // 2.
        // 非同期処理の結果受け取り
        CompletableFuture<Void> promise 
                = CompletableFuture.allOf(futures); // 3.
        return promise.thenApply(dummy ->           // 4.
            Stream.of(futures)
                    .map(CompletableFuture::join)   // 5.
                    .collect(Collectors.joining(", "))
        ).join();                                   // 6.
    }

$ curl localhost:7001/aggregate/async
[helidon-server-9] - Requested-Timestamp:2022-10-03 20:27:10,422/こんにちは-service:request recieved
[helidon-server-4] - Requested-Timestamp:2022-10-03 20:27:10,435/Hello-service:request recieved
[helidon-server-6] - Requested-Timestamp:2022-10-03 20:27:10,454/ニイハオ-service:request recieved
こんにちは, Hello, ニイハオ

@RequestScoped
@Path("/aggregate")
public class HelloAggregateResource {
    private static Logger LOG = LoggerFactory.getLogger(HelloAggregateResource.class);
    private static final List<String> HELLO_SERVICE_URLS = List.of(
                "http://localhost:7002", // japanese hello service
                "http://localhost:7003", // english hello service
                "http://localhost:7004"  // chinese hello service
            );
    private List<HelloRestClient> helloClients;
    @PostConstruct
    public void init() {
        // URLごとのRestClientインスタンスを生成
        helloClients = HELLO_SERVICE_URLS.stream()
                .map(url ->
                    RestClientBuilder.newBuilder()
                        .baseUri(URI.create(url))
                        .build(HelloRestClient.class))
                .toList();
    }
    @GET
    @Path("/sync")
    @Produces(MediaType.TEXT_PLAIN)
    public String aggregateHello() {
        return helloClients.stream()
                .map(HelloRestClient::hello)
                .collect(Collectors.joining(", "));
    }
    @GET
    @Path("/async")
    @Produces(MediaType.TEXT_PLAIN)
    public String asyncAggregateHello() {
        // 非同期処理の実行
        @SuppressWarnings({ "unchecked" })
        final CompletableFuture<String>[] futures = helloClients.stream()
                .map(HelloRestClient::asyncHello)
                .toArray(CompletableFuture[]::new);
        // 非同期処理の結果受け取り
        CompletableFuture<Void> promise 
                = CompletableFuture.allOf(futures);
        return promise.thenApply(dummy ->
            Stream.of(futures)
                    .map(CompletableFuture::join)
                    .collect(Collectors.joining(", "))
        ).join();
    }
    @PreDestroy
    public void destroy() {
        // RestClientインスタンスに対するclose
        if (helloClients != null) {
            helloClients.forEach(client -> {
                try {
                    client.close();
                } catch (Exception e) {
                    LOG.warn("exception occurred during close processing..", e);
                }
            });
        }
    }
}