此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Boot 3.4.0！spring-doc.cn

调用 REST 服务

Spring Boot 提供了多种便捷的方法来调用远程 REST 服务。如果你正在开发一个非阻塞响应式应用程序，并且你正在使用 Spring WebFlux，那么你可以使用 WebClient。如果您更喜欢阻止 API，则可以使用 RestClient 或 RestTemplate。spring-doc.cn

Web客户端

如果您的 Classpath 上有 Spring WebFlux，我们建议您使用WebClient调用远程 REST 服务。 WebClient 接口提供了一个功能式的 API，并且是完全反应式的。您可以在 Spring Framework 文档的专用部分中了解有关 WebClient 的更多信息。spring-doc.cn

如果你不编写反应式 Spring WebFlux 应用程序，则可以使用RestClient而不是WebClient。这提供了类似的功能 API，但 this is blocking instead reactor 。

Spring Boot 为您创建并预配置原型WebClient.Builder Bean。强烈建议将其注入到您的组件中，并使用它来创建 WebClient 实例。 Spring Boot 正在配置该构建器以共享 HTTP 资源并以与服务器相同的方式反映编解码器设置（参见 WebFlux HTTP 编解码器自动配置）等等。spring-doc.cn

以下代码显示了一个典型的示例：spring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

import reactor.core.publisher.Mono;

import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;

@Service
public class MyService {

	private final WebClient webClient;

	public MyService(WebClient.Builder webClientBuilder) {
		this.webClient = webClientBuilder.baseUrl("https://example.org").build();
	}

	public Mono<Details> someRestCall(String name) {
		return this.webClient.get().uri("/{name}/details", name).retrieve().bodyToMono(Details.class);
	}

}

import org.springframework.stereotype.Service
import org.springframework.web.reactive.function.client.WebClient
import reactor.core.publisher.Mono

@Service
class MyService(webClientBuilder: WebClient.Builder) {

	private val webClient: WebClient

	init {
		webClient = webClientBuilder.baseUrl("https://example.org").build()
	}

	fun someRestCall(name: String?): Mono<Details> {
		return webClient.get().uri("/{name}/details", name)
				.retrieve().bodyToMono(Details::class.java)
	}

}

WebClient 运行时

Spring Boot 将根据应用程序 Classpath 上可用的库自动检测使用哪个ClientHttpConnector来驱动WebClient。按优先顺序，支持以下客户端：spring-doc.cn

Reactor Nettyspring-doc.cn
Jetty RS 客户端spring-doc.cn
Apache HttpClientspring-doc.cn
JDK HttpClientspring-doc.cn

如果 Classpath 上有多个 Client 端可用，则将使用最首选的 Client 端。spring-doc.cn

starter 依赖于 by default，它带来了 server 和 client 实现。如果您选择使用 Jetty 作为反应式服务器，则应添加对 Jetty 反应式 HTTP 客户端库的依赖项。对服务器和客户端使用相同的技术有其优势，因为它会自动在客户端和服务器之间共享 HTTP 资源。spring-boot-starter-webfluxio.projectreactor.netty:reactor-nettyorg.eclipse.jetty:jetty-reactive-httpclientspring-doc.cn

开发人员可以通过提供自定义的 ReactorResourceFactory 或 JettyResourceFactory bean 来覆盖 Jetty 和 Reactor Netty 的资源配置——这将应用于客户端和服务器。spring-doc.cn

如果你希望为 Client 端覆盖该选择，你可以定义自己的 ClientHttpConnector Bean 并完全控制 Client 端配置。spring-doc.cn

您可以在 Spring Framework 参考文档中了解有关 WebClient 配置选项的更多信息。spring-doc.cn

WebClient 自定义

WebClient 自定义有三种主要方法，具体取决于您希望自定义应用的范围。spring-doc.cn

要使任何自定义的范围尽可能窄，请注入自动配置的 WebClient.Builder，然后根据需要调用其方法。WebClient.Builder 实例是有状态的：生成器上的任何更改都会反映在随后使用它创建的所有客户端中。如果要使用同一生成器创建多个客户端，还可以考虑使用克隆生成器。WebClient.Builder other = builder.clone();spring-doc.cn

要对所有 WebClient.Builder 实例进行应用程序范围的附加定制，您可以声明 WebClientCustomizer bean 并在注入点本地更改 WebClient.Builder。spring-doc.cn

最后，您可以回退到原始 API 并使用 . 在这种情况下，不会应用自动配置或 WebClientCustomizer。WebClient.create()spring-doc.cn

WebClient SSL 支持

如果你需要在 WebClient 使用的 ClientHttpConnector 上进行自定义 SSL 配置，你可以注入一个 WebClientSsl 实例，该实例可以与构建器的方法一起使用。applyspring-doc.cn

WebClientSsl 接口提供对您在 or 文件中定义的任何 SSL 捆绑包的访问。application.propertiesapplication.yamlspring-doc.cn

以下代码显示了一个典型的示例：spring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

import reactor.core.publisher.Mono;

import org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientSsl;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;

@Service
public class MyService {

	private final WebClient webClient;

	public MyService(WebClient.Builder webClientBuilder, WebClientSsl ssl) {
		this.webClient = webClientBuilder.baseUrl("https://example.org").apply(ssl.fromBundle("mybundle")).build();
	}

	public Mono<Details> someRestCall(String name) {
		return this.webClient.get().uri("/{name}/details", name).retrieve().bodyToMono(Details.class);
	}

}

import org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientSsl
import org.springframework.stereotype.Service
import org.springframework.web.reactive.function.client.WebClient
import reactor.core.publisher.Mono

@Service
class MyService(webClientBuilder: WebClient.Builder, ssl: WebClientSsl) {

	private val webClient: WebClient

	init {
		webClient = webClientBuilder.baseUrl("https://example.org")
				.apply(ssl.fromBundle("mybundle")).build()
	}

	fun someRestCall(name: String?): Mono<Details> {
		return webClient.get().uri("/{name}/details", name)
				.retrieve().bodyToMono(Details::class.java)
	}

}

Rest客户端

如果您没有在应用程序中使用 Spring WebFlux 或 Project Reactor，我们建议您使用 RestClient 调用远程 REST 服务。spring-doc.cn

RestClient 接口提供了一个功能样式的阻塞 API。spring-doc.cn

Spring Boot 为你创建并预配置原型RestClient.Builder Bean。强烈建议将其注入到您的组件中，并使用它来创建 RestClient 实例。 Spring Boot 正在使用HttpMessageConverters和适当的ClientHttpRequestFactory配置该构建器。spring-doc.cn

以下代码显示了一个典型的示例：spring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

import org.springframework.stereotype.Service;
import org.springframework.web.client.RestClient;

@Service
public class MyService {

	private final RestClient restClient;

	public MyService(RestClient.Builder restClientBuilder) {
		this.restClient = restClientBuilder.baseUrl("https://example.org").build();
	}

	public Details someRestCall(String name) {
		return this.restClient.get().uri("/{name}/details", name).retrieve().body(Details.class);
	}

}

import org.springframework.boot.docs.io.restclient.restclient.ssl.Details
import org.springframework.stereotype.Service
import org.springframework.web.client.RestClient

@Service
class MyService(restClientBuilder: RestClient.Builder) {

	private val restClient: RestClient

	init {
		restClient = restClientBuilder.baseUrl("https://example.org").build()
	}

	fun someRestCall(name: String?): Details {
		return restClient.get().uri("/{name}/details", name)
				.retrieve().body(Details::class.java)!!
	}

}

RestClient 自定义

RestClient 自定义有三种主要方法，具体取决于您希望自定义应用的范围。spring-doc.cn

要使任何自定义的范围尽可能窄，请注入自动配置的 RestClient.Builder，然后根据需要调用其方法。RestClient.Builder 实例是有状态的：生成器上的任何更改都会反映在随后使用它创建的所有客户端中。如果要使用同一生成器创建多个客户端，还可以考虑使用克隆生成器。RestClient.Builder other = builder.clone();spring-doc.cn

要对所有 RestClient.Builder 实例进行应用程序范围的附加自定义，您可以声明 RestClientCustomizer bean 并在注入点本地更改 RestClient.Builder。spring-doc.cn

最后，您可以回退到原始 API 并使用 . 在这种情况下，不会应用自动配置或 RestClientCustomizer。RestClient.create()spring-doc.cn

您还可以更改全局 HTTP 客户端配置。

RestClient SSL 支持

如果你需要在 RestClient 使用的 ClientHttpRequestFactory 上进行自定义 SSL 配置，你可以注入一个可以与构建器的方法一起使用的 RestClientSsl 实例。applyspring-doc.cn

RestClientSsl 接口提供对您在 or 文件中定义的任何 SSL 捆绑包的访问。application.propertiesapplication.yamlspring-doc.cn

以下代码显示了一个典型的示例：spring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

import org.springframework.boot.autoconfigure.web.client.RestClientSsl;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestClient;

@Service
public class MyService {

	private final RestClient restClient;

	public MyService(RestClient.Builder restClientBuilder, RestClientSsl ssl) {
		this.restClient = restClientBuilder.baseUrl("https://example.org").apply(ssl.fromBundle("mybundle")).build();
	}

	public Details someRestCall(String name) {
		return this.restClient.get().uri("/{name}/details", name).retrieve().body(Details.class);
	}

}

import org.springframework.boot.autoconfigure.web.client.RestClientSsl
import org.springframework.boot.docs.io.restclient.restclient.ssl.settings.Details
import org.springframework.stereotype.Service
import org.springframework.web.client.RestClient

@Service
class MyService(restClientBuilder: RestClient.Builder, ssl: RestClientSsl) {

	private val restClient: RestClient

	init {
		restClient = restClientBuilder.baseUrl("https://example.org")
				.apply(ssl.fromBundle("mybundle")).build()
	}

	fun someRestCall(name: String?): Details {
		return restClient.get().uri("/{name}/details", name)
				.retrieve().body(Details::class.java)!!
	}

}

如果除了 SSL 捆绑包之外还需要应用其他自定义，则可以将ClientHttpRequestFactorySettings类与ClientHttpRequestFactoryBuilder一起使用：spring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

import java.time.Duration;

import org.springframework.boot.http.client.ClientHttpRequestFactoryBuilder;
import org.springframework.boot.http.client.ClientHttpRequestFactorySettings;
import org.springframework.boot.ssl.SslBundles;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestClient;

@Service
public class MyService {

	private final RestClient restClient;

	public MyService(RestClient.Builder restClientBuilder, SslBundles sslBundles) {
		ClientHttpRequestFactorySettings settings = ClientHttpRequestFactorySettings
			.ofSslBundle(sslBundles.getBundle("mybundle"))
			.withReadTimeout(Duration.ofMinutes(2));
		ClientHttpRequestFactory requestFactory = ClientHttpRequestFactoryBuilder.detect().build(settings);
		this.restClient = restClientBuilder.baseUrl("https://example.org").requestFactory(requestFactory).build();
	}

	public Details someRestCall(String name) {
		return this.restClient.get().uri("/{name}/details", name).retrieve().body(Details.class);
	}

}

import org.springframework.boot.http.client.ClientHttpRequestFactoryBuilder;
import org.springframework.boot.http.client.ClientHttpRequestFactorySettings;
import org.springframework.boot.ssl.SslBundles
import org.springframework.stereotype.Service
import org.springframework.web.client.RestClient
import java.time.Duration

@Service
class MyService(restClientBuilder: RestClient.Builder, sslBundles: SslBundles) {

	private val restClient: RestClient

	init {
		val settings = ClientHttpRequestFactorySettings.defaults()
				.withReadTimeout(Duration.ofMinutes(2))
				.withSslBundle(sslBundles.getBundle("mybundle"))
		val requestFactory = ClientHttpRequestFactoryBuilder.detect().build(settings);
		restClient = restClientBuilder
				.baseUrl("https://example.org")
				.requestFactory(requestFactory).build()
	}

	fun someRestCall(name: String?): Details {
		return restClient.get().uri("/{name}/details", name).retrieve().body(Details::class.java)!!
	}

}

RestTemplate （休息模板）

Spring Framework 的 RestTemplate 类早于 RestClient，是许多应用程序用来调用远程 REST 服务的经典方式。当您有不想迁移到 RestClient 的现有代码，或者因为您已经熟悉 RestTemplate API 时，您可以选择使用 RestTemplate。spring-doc.cn

由于 RestTemplate 实例通常需要在使用之前进行自定义，因此 Spring Boot 不提供任何单个自动配置的 RestTemplate bean。但是，它确实会自动配置RestTemplateBuilder，该实例可用于在需要时创建RestTemplate实例。自动配置的RestTemplateBuilder确保将合理的HttpMessageConverters和适当的ClientHttpRequestFactory应用于RestTemplate实例。spring-doc.cn

以下代码显示了一个典型的示例：spring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class MyService {

	private final RestTemplate restTemplate;

	public MyService(RestTemplateBuilder restTemplateBuilder) {
		this.restTemplate = restTemplateBuilder.build();
	}

	public Details someRestCall(String name) {
		return this.restTemplate.getForObject("/{name}/details", Details.class, name);
	}

}

import org.springframework.boot.web.client.RestTemplateBuilder
import org.springframework.stereotype.Service
import org.springframework.web.client.RestTemplate

@Service
class MyService(restTemplateBuilder: RestTemplateBuilder) {

	private val restTemplate: RestTemplate

	init {
		restTemplate = restTemplateBuilder.build()
	}

	fun someRestCall(name: String): Details {
		return restTemplate.getForObject("/{name}/details", Details::class.java, name)!!
	}

}

RestTemplateBuilder 包含许多可用于快速配置 RestTemplate 的有用方法。例如，要添加 BASIC 身份验证支持，您可以使用 .builder.basicAuthentication("user", "password").build()spring-doc.cn

RestTemplate 自定义

RestTemplate 自定义有三种主要方法，具体取决于您希望自定义应用的范围。spring-doc.cn

要使任何自定义的范围尽可能窄，请注入自动配置的RestTemplateBuilder，然后根据需要调用其方法。每个方法调用都会返回一个新的 RestTemplateBuilder 实例，因此自定义项仅影响构建器的这种使用。spring-doc.cn

要进行应用程序范围的附加自定义，请使用RestTemplateCustomizer Bean。所有这些 bean 都会自动注册到自动配置的RestTemplateBuilder中，并应用于使用它构建的任何模板。spring-doc.cn

以下示例显示了一个定制器，该定制器为除以下主机之外的所有主机配置代理的使用：192.168.0.5spring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

import org.apache.hc.client5.http.classic.HttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClientBuilder;
import org.apache.hc.client5.http.impl.routing.DefaultProxyRoutePlanner;
import org.apache.hc.client5.http.routing.HttpRoutePlanner;
import org.apache.hc.core5.http.HttpException;
import org.apache.hc.core5.http.HttpHost;
import org.apache.hc.core5.http.protocol.HttpContext;

import org.springframework.boot.web.client.RestTemplateCustomizer;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

public class MyRestTemplateCustomizer implements RestTemplateCustomizer {

	@Override
	public void customize(RestTemplate restTemplate) {
		HttpRoutePlanner routePlanner = new CustomRoutePlanner(new HttpHost("proxy.example.com"));
		HttpClient httpClient = HttpClientBuilder.create().setRoutePlanner(routePlanner).build();
		restTemplate.setRequestFactory(new HttpComponentsClientHttpRequestFactory(httpClient));
	}

	static class CustomRoutePlanner extends DefaultProxyRoutePlanner {

		CustomRoutePlanner(HttpHost proxy) {
			super(proxy);
		}

		@Override
		protected HttpHost determineProxy(HttpHost target, HttpContext context) throws HttpException {
			if (target.getHostName().equals("192.168.0.5")) {
				return null;
			}
			return super.determineProxy(target, context);
		}

	}

}

import org.apache.hc.client5.http.classic.HttpClient
import org.apache.hc.client5.http.impl.classic.HttpClientBuilder
import org.apache.hc.client5.http.impl.routing.DefaultProxyRoutePlanner
import org.apache.hc.client5.http.routing.HttpRoutePlanner
import org.apache.hc.core5.http.HttpException
import org.apache.hc.core5.http.HttpHost
import org.apache.hc.core5.http.protocol.HttpContext
import org.springframework.boot.web.client.RestTemplateCustomizer
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory
import org.springframework.web.client.RestTemplate

class MyRestTemplateCustomizer : RestTemplateCustomizer {

	override fun customize(restTemplate: RestTemplate) {
		val routePlanner: HttpRoutePlanner = CustomRoutePlanner(HttpHost("proxy.example.com"))
		val httpClient: HttpClient = HttpClientBuilder.create().setRoutePlanner(routePlanner).build()
		restTemplate.requestFactory = HttpComponentsClientHttpRequestFactory(httpClient)
	}

	internal class CustomRoutePlanner(proxy: HttpHost?) : DefaultProxyRoutePlanner(proxy) {

		@Throws(HttpException::class)
		public override fun determineProxy(target: HttpHost, context: HttpContext): HttpHost? {
			if (target.hostName == "192.168.0.5") {
				return null
			}
			return  super.determineProxy(target, context)
		}

	}

}

最后，你可以定义自己的RestTemplateBuilder bean。这样做将替换自动配置的生成器。如果你希望将任何RestTemplateCustomizer bean 应用于你的自定义构建器，就像自动配置所做的那样，请使用RestTemplateBuilderConfigurer对其进行配置。下面的示例公开了一个RestTemplateBuilder，它与 Spring Boot 的自动配置将执行的操作相匹配，只是还指定了自定义连接和读取超时：spring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

import java.time.Duration;

import org.springframework.boot.autoconfigure.web.client.RestTemplateBuilderConfigurer;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MyRestTemplateBuilderConfiguration {

	@Bean
	public RestTemplateBuilder restTemplateBuilder(RestTemplateBuilderConfigurer configurer) {
		return configurer.configure(new RestTemplateBuilder())
			.connectTimeout(Duration.ofSeconds(5))
			.readTimeout(Duration.ofSeconds(2));
	}

}

import org.springframework.boot.autoconfigure.web.client.RestTemplateBuilderConfigurer
import org.springframework.boot.web.client.RestTemplateBuilder
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import java.time.Duration

@Configuration(proxyBeanMethods = false)
class MyRestTemplateBuilderConfiguration {

	@Bean
	fun restTemplateBuilder(configurer: RestTemplateBuilderConfigurer): RestTemplateBuilder {
		return configurer.configure(RestTemplateBuilder()).connectTimeout(Duration.ofSeconds(5))
			.readTimeout(Duration.ofSeconds(2))
	}

}

最极端（也很少使用）的选项是在不使用配置器的情况下创建自己的 RestTemplateBuilder bean。除了替换自动配置的构建器之外，这还会阻止使用任何RestTemplateCustomizer bean。spring-doc.cn

您还可以更改全局 HTTP 客户端配置。

RestTemplate SSL 支持

如果需要在 RestTemplate 上进行自定义 SSL 配置，则可以将 SSL 捆绑包应用于 RestTemplateBuilder，如以下示例所示：spring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

import org.springframework.boot.docs.io.restclient.resttemplate.Details;
import org.springframework.boot.ssl.SslBundles;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class MyService {

	private final RestTemplate restTemplate;

	public MyService(RestTemplateBuilder restTemplateBuilder, SslBundles sslBundles) {
		this.restTemplate = restTemplateBuilder.sslBundle(sslBundles.getBundle("mybundle")).build();
	}

	public Details someRestCall(String name) {
		return this.restTemplate.getForObject("/{name}/details", Details.class, name);
	}

}

import org.springframework.boot.docs.io.restclient.resttemplate.Details
import org.springframework.boot.ssl.SslBundles
import org.springframework.boot.web.client.RestTemplateBuilder
import org.springframework.stereotype.Service
import org.springframework.web.client.RestTemplate

@Service
class MyService(restTemplateBuilder: RestTemplateBuilder, sslBundles: SslBundles) {

    private val restTemplate: RestTemplate

    init {
        restTemplate = restTemplateBuilder.sslBundle(sslBundles.getBundle("mybundle")).build()
    }

    fun someRestCall(name: String): Details {
        return restTemplate.getForObject("/{name}/details", Details::class.java, name)!!
    }

}

RestClient 和 RestTemplate 的 HTTP 客户端检测

Spring Boot 将根据应用程序 Classpath 上可用的库自动检测要与RestClient和RestTemplate一起使用的 HTTP 客户端。按优先顺序，支持以下客户端：spring-doc.cn

Apache HttpClientspring-doc.cn
Jetty HttpClientspring-doc.cn
Reactor Netty HttpClientspring-doc.cn
JDK 客户端（java.net.http.HttpClient)spring-doc.cn
简单 JDK 客户端（java.net.HttpURLConnection)spring-doc.cn

如果 Classpath 上有多个 Client 端可用，并且未提供全局配置，则将使用最首选的 Client 端。spring-doc.cn

全局 HTTP 客户端配置

如果自动检测到的 HTTP 客户端不能满足您的需求，则可以使用该属性选择特定的工厂。例如，如果您的 Classpath 上有 Apache HttpClient，但您更喜欢 Jetty 的HttpClient，则可以使用以下内容添加：spring.http.client.factoryspring-doc.cn

Propertiesspring-doc.cn
YAMLspring-doc.cn

spring.http.client.factory=jetty

spring:
  http:
    client:
      factory: jetty

您还可以设置属性以更改将应用于所有客户端的默认值。例如，您可能希望更改超时，如果遵循重定向：spring-doc.cn

Propertiesspring-doc.cn
YAMLspring-doc.cn

spring.http.client.connect-timeout=2s
spring.http.client.read-timeout=1s
spring.http.client.redirects=dont-follow

spring:
  http:
    client:
      connect-timeout: 2s
      read-timeout: 1s
      redirects: dont-follow

对于更复杂的自定义，你可以声明自己的ClientHttpRequestFactoryBuilder bean ，这将导致自动配置退缩。当您需要自定义底层 HTTP 库的某些内部结构时，这可能很有用。spring-doc.cn

例如，以下将使用配置了特定 ProxySelector 的 JDK 客户端：spring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

import java.net.ProxySelector;

import org.springframework.boot.http.client.ClientHttpRequestFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MyClientHttpConfiguration {

	@Bean
	ClientHttpRequestFactoryBuilder<?> clientHttpRequestFactoryBuilder(ProxySelector proxySelector) {
		return ClientHttpRequestFactoryBuilder.jdk()
			.withHttpClientCustomizer((builder) -> builder.proxy(proxySelector));
	}

}

import org.springframework.boot.http.client.ClientHttpRequestFactoryBuilder
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import java.net.ProxySelector
import java.net.http.HttpClient

@Configuration(proxyBeanMethods = false)
class MyClientHttpConfiguration {

	@Bean
	fun clientHttpRequestFactoryBuilder(proxySelector: ProxySelector): ClientHttpRequestFactoryBuilder<*>? {
		return ClientHttpRequestFactoryBuilder.jdk()
				.withHttpClientCustomizer { builder -> builder.proxy(proxySelector) }
	}

}