<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.client.WebClient;

@Configuration
public class WebClientConfig {
    @Bean
    public WebClient webClient(WebClient.Builder builder) {
        return builder
                .baseUrl("https://api.example.com") // 可配置默認(rèn) baseUrl
                .build();
    }
}

import reactor.netty.http.client.HttpClient;
import reactor.netty.resources.ConnectionProvider;
import java.time.Duration;

@Bean
public WebClient webClient() {
    ConnectionProvider provider = ConnectionProvider.builder("custom")
        .maxConnections(100)
        .pendingAcquireTimeout(Duration.ofSeconds(60))
        .build();

    HttpClient httpClient = HttpClient.create(provider)
        .responseTimeout(Duration.ofSeconds(5));

    return WebClient.builder()
        .clientConnector(new ReactorClientHttpConnector(httpClient))
        .build();
}

@Autowired
private WebClient webClient;

public Mono<String> getDataAsync() {
    return webClient.get()
        .uri("/data")
        .retrieve()
        .bodyToMono(String.class);
}

public Mono<ResponseDto> postDataAsync(RequestDto request) {
    return webClient.post()
        .uri("/submit")
        .bodyValue(request)
        .retrieve()
        .bodyToMono(ResponseDto.class);
}

@RestController
public class DemoController {
    @Autowired
    private WebClient webClient;

    @GetMapping("/call-remote")
    public Mono<String> callRemote() {
        return webClient.get()
            .uri("/remote-api")
            .retrieve()
            .bodyToMono(String.class);
    }
}

Mono<String> call1 = webClient.get().uri("/api1").retrieve().bodyToMono(String.class);
Mono<String> call2 = webClient.get().uri("/api2").retrieve().bodyToMono(String.class);

Mono<Tuple2<String, String>> result = Mono.zip(call1, call2);

webClient.get().uri("/api")
    .retrieve()
    .onStatus(HttpStatus::isError, response -> 
        response.bodyToMono(String.class)
            .flatMap(errorBody -> Mono.error(new RuntimeException(errorBody)))
    )
    .bodyToMono(String.class);

WebClient.builder()
    .filter((request, next) -> {
        System.out.println("Request: " + request.url());
        return next.exchange(request);
    })
    .build();

webClient.get()
    .uri(uriBuilder -> uriBuilder
        .path("/search")
        .queryParam("keyword", "spring")
        .build())
    .header("Authorization", "Bearer xxx")
    .cookie("SESSIONID", "abcdefg")
    .retrieve()
    .bodyToMono(String.class);

@Bean
public WebClient webClient() {
    return WebClient.builder()
        .filter((request, next) -> next.exchange(request)
            .flatMap(response -> {
                if (response.statusCode().isError()) {
                    return response.bodyToMono(String.class)
                        .flatMap(errorBody -> Mono.error(new RuntimeException(errorBody)));
                }
                return Mono.just(response);
            }))
        .build();
}

import reactor.util.retry.Retry;

webClient.get()
    .uri("/unstable-api")
    .retrieve()
    .bodyToMono(String.class)
    .retryWhen(Retry.fixedDelay(3, Duration.ofSeconds(2)));

import org.springframework.core.io.FileSystemResource;

FileSystemResource file = new FileSystemResource("/path/to/file.txt");

webClient.post()
    .uri("/upload")
    .contentType(MediaType.MULTIPART_FORM_DATA)
    .body(BodyInserters.fromMultipartData("file", file))
    .retrieve()
    .bodyToMono(String.class);

webClient.get()
    .uri("/download")
    .retrieve()
    .bodyToFlux(DataBuffer.class)
    .map(dataBuffer -> {
        // 將 DataBuffer 寫入文件
        // 省略具體實(shí)現(xiàn)
        return dataBuffer;
    });

import org.springframework.cloud.client.loadbalancer.LoadBalanced;

@Bean
@LoadBalanced
public WebClient.Builder loadBalancedWebClientBuilder() {
    return WebClient.builder();
}

// 使用
@Autowired
private WebClient.Builder webClientBuilder;

webClientBuilder.build()
    .get()
    .uri("http://service-name/api")
    .retrieve()
    .bodyToMono(String.class);

import org.springframework.security.oauth2.client.web.reactive.function.client.ServerOAuth2AuthorizedClientExchangeFilterFunction;

@Bean
public WebClient webClient(ReactiveOAuth2AuthorizedClientManager manager) {
    ServerOAuth2AuthorizedClientExchangeFilterFunction oauth2 = 
        new ServerOAuth2AuthorizedClientExchangeFilterFunction(manager);
    return WebClient.builder()
        .apply(oauth2.oauth2Configuration())
        .build();
}

logging.level.reactor.netty.http.client=DEBUG