响应式发送请求API(WebClinet)使用案例

package luck.spring.boot.webflux;

import cn.hutool.core.thread.ThreadUtil;
import io.netty.handler.timeout.ReadTimeoutHandler;
import io.netty.handler.timeout.WriteTimeoutHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatusCode;
import org.springframework.http.client.reactive.ReactorClientHttpConnector;
import org.springframework.web.reactive.function.client.ClientRequest;
import org.springframework.web.reactive.function.client.ClientResponse;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;
import reactor.core.scheduler.Schedulers;
import reactor.netty.http.client.HttpClient;

import java.util.Map;

import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.web.reactive.function.client.ExchangeFilterFunctions.basicAuthentication;

@Slf4j
public class WebClientDemo {
    public static void main(String[] args) {
        // String res = HttpUtil.get("http://localhost:8080");
        // System.out.println(res);
        WebClient client = WebClient.create("http://localhost:8080");
        client.get()
                .uri("/router/cc")
                .accept(APPLICATION_JSON)
                .httpRequest(req -> {
                    log.error("request url {}", req.getURI().getPath());
                })
                .retrieve()
                .bodyToMono(String.class)
                .subscribeOn(Schedulers.boundedElastic())
                .doOnError(e -> {
                    log.error("error", e);
                })
                .subscribe(System.out::println);
        ThreadUtil.sleep(100000);

    }

    public static void test(String[] args) {
        // 构建一个发送请求的客户端,它就是HttpClient,HttpUtil,发送请求的
        WebClient client = WebClient.builder()
                // 自定义处理请求响应逻辑,是clientConnector+exchangeStrategies的替代方案
                // exchangeFunction完全自己处理请求逻辑,就不会走默认的处理逻辑
                .exchangeFunction(request -> Mono.just(ClientResponse.create(HttpStatusCode.valueOf(400)).build()))
                // 添加基础路径
                .baseUrl("http://localhost:8080")
                // 默认携带的cookie
                .defaultCookie("cookie-luck", "luck")
                // .defaultCookies(cookieMap -> {})
                // 默认携带的header
                .defaultHeader("header-luck", "luck")
                // .defaultHeaders(headers -> {})
                // 默认的请求对象,可以对请求进行数据处理
                // .defaultRequest(req -> {
                //     req.accept(APPLICATION_JSON);
                // })
                // 默认的状态码处理器
                // .defaultStatusHandler(httpStatusCode -> false, clientResponse -> null)
                // 默认的url路径变量值
                .defaultUriVariables(Map.of("uri-variable-luck", "luck"))
                // 添加请求的过滤器
                // .filter((request, next) -> null)
                .filter(basicAuthentication("user", "password"))
                // .filters(filterList -> {})
                // .observationConvention(new DefaultClientRequestObservationConvention())
                // .observationRegistry()
                .build();

        // 定义post请求
        client.get()
                .uri("/luck")
                // .accept(APPLICATION_JSON)
                // .contentType(APPLICATION_JSON)
                // 设置响应体为指定对象
                // .bodyValue(new Person(1, "luck"))
                // 该方法是对请求体进行解码操作
                // 自定义状态码的异常处理
                // 默认WebClientResponseException和WebClientResponseException.BadRequest来处理
                .retrieve()
                .bodyToMono(String.class)
                .subscribe(System.out::println);
    }

    public static void testWebClientApi() {
        // 自定义发送http请求的库
        HttpClient httpClient = HttpClient.create()
                // tcp配置,设置请求超时时间方式一
                .doOnConnected(conn -> {
                    conn.addHandlerLast(new ReadTimeoutHandler(10));
                    conn.addHandlerLast(new WriteTimeoutHandler(10));
                })
                // 设置请求超时时间方式二
                // .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 100000)
                // 设置SSL安全相关
                .secure(sslSpec -> {
                });

        // 构建一个发送请求的客户端
        WebClient client = WebClient.builder()
                // 自定义请求体和响应体的解析器,有两个方法可以处理
                // .exchangeStrategies(new ExchangeStrategies() {
                //     @Override
                //     public List<HttpMessageReader<?>> messageReaders() {
                //         return null;
                //     }
                //     @Override
                //     public List<HttpMessageWriter<?>> messageWriters() {
                //         return null;
                //     }
                // })
                // 使用自定义的httpClient发送请求
                // 要自定义ReactorNetty设置(默认),只需提供一个预配置的HttpClient.clientConnector(new ReactorClientHttpConnector(httpClient))
                // 如果要使用Jetty,则需要new JettyClientHttpConnector(httpClient(Jetty的包))
                .clientConnector(new ReactorClientHttpConnector(httpClient))
                // 自定义处理请求响应逻辑,是clientConnector+exchangeStrategies的替代方案
                // exchangeFunction完全自己处理请求逻辑,就不会走默认的处理逻辑
                // .exchangeFunction(request -> Mono.just(ClientResponse.create(HttpStatusCode.valueOf(400)).build()))
                // 添加自定义的编码解码器
                .codecs(configurer -> {
                    // 使用了ExchangeStrategies来限制默认的解码器缓冲区的大小。这有助于避免处理大型响应时的内存问题。
                    configurer.defaultCodecs().maxInMemorySize(16 * 1024 * 1024);
                })
                // 添加基础路径
                .baseUrl("/luck")
                // 默认携带的cookie
                .defaultCookie("cookie-luck", "luck")
                // .defaultCookies(cookieMap -> {})
                // 默认携带的header
                .defaultHeader("header-luck", "luck")
                // .defaultHeaders(headers -> {})
                // 默认的请求对象,可以对请求进行数据处理
                // .defaultRequest(req -> {
                //     req.accept(APPLICATION_JSON);
                // })
                // 默认的状态码处理器
                // .defaultStatusHandler(httpStatusCode -> false, clientResponse -> null)
                // 默认的url路径变量值
                .defaultUriVariables(Map.of("uri-variable-luck", "luck"))
                // 添加请求的过滤器
                // .filter((request, next) -> null)
                .filter(basicAuthentication("user", "password"))
                // .filters(filterList -> {})
                // .observationConvention(new DefaultClientRequestObservationConvention())
                // .observationRegistry()
                .build();

        // client构建之后就不可变,但是可以使用mutate进行扩展,返回一个新的client
        WebClient webClient = client.mutate().filter((request, next) -> {
            // ,处理指定逻辑并且指定指定下一个过滤器执行
            return next.filter((r, q) -> null).exchange(ClientRequest.from(request).header("luck", "luck").build());
        }).build();

        // 定义post请求
        webClient.post()
                .uri("")
                .accept(APPLICATION_JSON)
                .contentType(APPLICATION_JSON)
                // 设置响应体的类型
                // .contentType(MediaType.APPLICATION_STREAM_JSON)

                // 设置响应体为文件和字段的两种方式
                // MultipartBodyBuilder builder = new MultipartBodyBuilder();
                // builder.part("filePart1", new FileSystemResource("logo.png"));
                // builder.part("jsonPart", new Person());
                // 从请求体中获取的Part资源
                // Part part=req.getParts();
                // builder.part("myPart", part);
                // MultiValueMap<String, HttpEntity<?>> multipartBody = builder.build();
                // .bodyValue(multipartBody)
                // .body(BodyInserters.fromMultipartData("fieldPart", "value").with("filePart", resource))

                // 设置响应体为文件
                // .body(BodyInserters.fromResource(new FileSystemResource(new File(fileDir, "test.png"))))

                // 设置响应体为表单数据
                // .bodyValue(new LinkedMultiValueMap<>())
                // .body(BodyInserters.fromFormData("name", "value"))

                // 设置响应体为指定对象
                // .bodyValue(new Person(1, "luck"))
                // .body(BodyInserters.fromValue(new Person(1, "luck")), Person.class)
                // .body(Flux.just(new Person()), Person.class)

                // 该方法是对请求体进行解码操作
                // 自定义状态码的异常处理
                // 默认WebClientResponseException和WebClientResponseException.BadRequest来处理
                .retrieve()
                // retrieve默认有处理4xx,5xx的异常,但是也可以进行自定义
                .onStatus(HttpStatusCode::is4xxClientError, clientResponse -> null)
                .onStatus(HttpStatusCode::is5xxServerError, clientResponse -> null)
                // 将响应结果转换为Flux
                .bodyToFlux(Person.class)
                // 将Flux结果收集为List类型
                .collectList()
                // 阻塞获取结果
                .block();
        // 创建get请求
        webClient.get()
                .uri("/get")
                // 客户端需要JSON类型
                .accept(APPLICATION_JSON)
                // 将数据转换为Person,方式一: exchange + flatMap
                // .exchange()
                // .flatMap(response -> response.bodyToMono(Person.class))
                // 将数据转换为Person,方式二: 一步到位exchangeToFlux
                // .exchangeToFlux(resp -> resp.bodyToFlux(Person.class));
                // 将数据转换为Person,方式二: 一步到位exchangeToFlux
                .exchangeToMono(clientResponse -> null)
                // 记得一定要订阅
                .subscribe();
    }
}