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

import org.springframework.web.reactive.function.client.WebClient;
public class WebClientExample {
    private final WebClient webClient = WebClient.create("https://api.example.com");
    // 或者使用 builder 自定義配置
    private final WebClient customWebClient = WebClient.builder()
        .baseUrl("https://api.example.com")
        .defaultHeader("Content-Type", "application/json")
        .build();
}

import reactor.core.publisher.Mono;
public class WebClientGetExample {
    public Mono<String> fetchData() {
        return webClient.get()
            .uri("/resource")
            .retrieve()
            .bodyToMono(String.class);
    }
}

// 異步調(diào)用
Mono<User> userMono = webClient.get()
    .uri("/users/{id}", 1)
    .retrieve()
    .bodyToMono(User.class);
// 同步調(diào)用（不推薦在響應(yīng)式代碼中使用）
User user = userMono.block();

import reactor.core.publisher.Flux;
public class WebClientStreamExample {
    public Flux<DataChunk> streamData() {
        return webClient.get()
            .uri("/stream")
            .retrieve()
            .bodyToFlux(DataChunk.class);
    }
}

import reactor.util.retry.Retry;
import java.time.Duration;
public class WebClientRetryExample {
    public Mono<String> fetchWithRetry() {
        return webClient.get()
            .uri("/resource")
            .retrieve()
            .bodyToMono(String.class)
            .timeout(Duration.ofSeconds(5))
            .retryWhen(Retry.fixedDelay(3, Duration.ofSeconds(1)));
    }
}

import org.springframework.web.reactive.function.client.ClientRequest;
import org.springframework.web.reactive.function.client.ClientResponse;
import org.springframework.web.reactive.function.client.ExchangeFilterFunction;
import reactor.core.publisher.Mono;
public class WebClientFilterExample {
    private final WebClient webClient = WebClient.builder()
        .baseUrl("https://api.example.com")
        .filter(logRequest())
        .filter(logResponse())
        .build();
    private ExchangeFilterFunction logRequest() {
        return (clientRequest, next) -> {
            System.out.println("Request: " + clientRequest.url());
            return next.exchange(clientRequest);
        };
    }
    private ExchangeFilterFunction logResponse() {
        return (clientRequest, next) -> {
            return next.exchange(clientRequest)
                .doOnNext(response -> 
                    System.out.println("Response status: " + response.statusCode())
                );
        };
    }
}

import org.springframework.stereotype.Service;
import reactor.core.publisher.Mono;
@Service
public class UserService {
    private final WebClient webClient;
    public UserService(WebClient.Builder webClientBuilder) {
        this.webClient = webClientBuilder.baseUrl("https://api.github.com").build();
    }
    public Mono<User> getUser(String username) {
        return webClient.get()
            .uri("/users/{username}", username)
            .retrieve()
            .bodyToMono(User.class);
    }
}

import org.springframework.http.MediaType;
import reactor.core.publisher.Flux;
public class ComplexRequestExample {
    public Flux<Order> searchOrders(String keyword, int page, int size) {
        return webClient.post()
            .uri(uriBuilder -> uriBuilder
                .path("/orders/search")
                .queryParam("page", page)
                .queryParam("size", size)
                .build())
            .contentType(MediaType.APPLICATION_JSON)
            .bodyValue(new SearchRequest(keyword))
            .retrieve()
            .bodyToFlux(Order.class);
    }
}

import io.netty.channel.ChannelOption;
import io.netty.handler.timeout.ReadTimeoutHandler;
import io.netty.handler.timeout.WriteTimeoutHandler;
import org.springframework.http.client.reactive.ReactorClientHttpConnector;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.netty.http.client.HttpClient;
import java.time.Duration;
import java.util.concurrent.TimeUnit;
public class WebClientConnectionPoolExample {
    public WebClient createWebClientWithPool() {
        HttpClient httpClient = HttpClient.create()
            .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)
            .responseTimeout(Duration.ofSeconds(10))
            .doOnConnected(conn -> 
                conn.addHandlerLast(new ReadTimeoutHandler(5, TimeUnit.SECONDS))
                    .addHandlerLast(new WriteTimeoutHandler(5, TimeUnit.SECONDS))
            );
        return WebClient.builder()
            .clientConnector(new ReactorClientHttpConnector(httpClient))
            .build();
    }
}

public class WebClientErrorHandlingExample {
    public Mono<User> getUserWithErrorHandling(String username) {
        return webClient.get()
            .uri("/users/{username}", username)
            .retrieve()
            .onStatus(HttpStatus::is4xxClientError, response -> 
                Mono.error(new ClientException("Client error: " + response.statusCode()))
            )
            .onStatus(HttpStatus::is5xxServerError, response -> 
                Mono.error(new ServerException("Server error: " + response.statusCode()))
            )
            .bodyToMono(User.class)
            .onErrorResume(NotFoundException.class, e -> Mono.empty());
    }
}

import brave.Tracer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.client.ExchangeFilterFunction;
import org.springframework.web.reactive.function.client.WebClient;
@Configuration
public class WebClientConfig {
    private final Tracer tracer;
    public WebClientConfig(Tracer tracer) {
        this.tracer = tracer;
    }
    @Bean
    public WebClient webClient() {
        return WebClient.builder()
            .filter(logRequest())
            .filter(traceRequest())
            .build();
    }
    private ExchangeFilterFunction traceRequest() {
        return (clientRequest, next) -> {
            tracer.currentSpan().tag("http.url", clientRequest.url().toString());
            return next.exchange(clientRequest);
        };
    }
    // 其他配置...
}