webclient封装

package com.istrong.guarantee.component;

import cn.hutool.core.collection.CollUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.collections4.MultiValuedMap;
import org.apache.commons.collections4.multimap.ArrayListValuedHashMap;
import org.apache.hc.core5.http.message.BasicNameValuePair;
import org.apache.hc.core5.net.URIBuilder;
import org.apache.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

import java.net.URI;
import java.net.URISyntaxException;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Map;

/**
 * @program: sm_guarantee_platform
 * @ClassName WebClientService
 * @description:webclient封装，官方推荐使用webclient，restTemplate已经被淘汰了
 * @author: 黄涛
 * @create: 2025-01-24 08:14
 * @Version 1.0
 **/
@Component
public final class WebClientService {


//    public static void main(String[] args) {
//        Map<String,Object> paramsMap = new HashMap<>(2);
//        paramsMap.put("a",1);
//        paramsMap.put("b","2");
//        //psot请求,json
//        String str1 = sendGet("https://www.baidu.com",new HashMap<String,String>(),String.class);
//        //psot请求,json
//        String str2 = sendPostByJson("https://www.baidu.com",paramsMap,String.class);
//        //psot请求,form
//        String str3 = sendPostByForm("https://www.baidu.com",paramsMap,String.class);
//    }



    /**
     * 发送get请求，同步请求
     * @param url
     * @param paramsMap 请求入参
     * @param responseDataClass
     * @param <T>
     * @return
     */
    public final <T> T sendGet(String url,Map<String,String> paramsMap,Class<T> responseDataClass){

        java.util.List<org.apache.hc.core5.http.NameValuePair> nameValuePairList = new ArrayList<>();
        if(CollUtil.isNotEmpty(paramsMap)){
            paramsMap.forEach((k,v)->nameValuePairList.add(new BasicNameValuePair(k,v)));
        }

        URI uri;
        try {
            uri = new URIBuilder(url)
                    //设置URL的字符集
                    .setCharset(StandardCharsets.UTF_8)
                    //参数会被拼接到URL后面，中文会被自动编码，特殊字符也会被编码，如url?param1=vaue1&param2=value2
                    .addParameters(nameValuePairList)
                    .build();
        } catch (URISyntaxException e) {
            e.printStackTrace();
            throw new RuntimeException(e.getMessage());
        }

        Mono<T> mono = WebClient
                //创建WebClient实例
                .create()
                //设置请求内容类型未：Content-Type=application/json
                //请求方式
                .method(HttpMethod.GET)
                //请求url
                .uri(uri)
                //获取响应结果
                .retrieve()
                //将结果转化未响应类型
                .bodyToMono(responseDataClass)
                //超时等待，毫秒级，这里是8秒超时
                .timeout(Duration.ofMillis(8000))
                .onErrorResume(e -> {
//                    if (e instanceof WebClientResponseException) {
//                        WebClientResponseException ex = (WebClientResponseException) e;
//                    }
                    return Mono.error(e); // 重新抛出异常或者返回其他Mono错误信号
                });
        //block方法返回最终调用结果，block方法是阻塞的
        T responseData = mono.block();
        return responseData;
    }

    /**
     * 发送psot请求（JSON数据），同步请求
     * @param url
     * @param params 请求入参，Map或JSON
     * @param responseDataClass
     * @param <T>
     * @return
     */
    public final <T> T sendPostByJson(String url,Object params,Class<T> responseDataClass){
        String paramsJsonStr;
        if(params instanceof JSONObject){
            paramsJsonStr = ((JSONObject) params).toJSONString();
        }else {
            paramsJsonStr = JSON.toJSONString(params);
        }
        Mono<T> mono = WebClient
                //创建WebClient实例
                .builder()
                //设置请求内容类型未：Content-Type=application/json
                .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
                .build()
                //请求方式
                .method(HttpMethod.POST)
                //请求url
                .uri(url)
                //请求参数
                .bodyValue(paramsJsonStr)
                //获取响应结果
                .retrieve()
                //将结果转化未响应类型
                .bodyToMono(responseDataClass)
                //超时等待，毫秒级，这里是8秒超时
                .timeout(Duration.ofMillis(8000))
                //异常处理
                .onErrorResume(e -> {
//                    if (e instanceof WebClientResponseException) {
//                        WebClientResponseException ex = (WebClientResponseException) e;
//                    }
                    return Mono.error(e); // 重新抛出异常或者返回其他Mono错误信号
                });
        T responseData = mono.block();
        return responseData;
    }

    /**
     * 发送psot请求（form表单），同步请求
     * @param url
     * @param map 请求入参
     * @param responseDataClass
     * @param <T>
     * @return
     */
    public final <T> T sendPostByForm(String url,Map<String,Object> map,Class<T> responseDataClass){

        //请求参数必须放到MultiValueMap当中
        MultiValuedMap<String,Object> paramsMap = new ArrayListValuedHashMap<>(map.size());
        //将Map中的数据复制到MultiValuedMap当中
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            paramsMap.put(entry.getKey(), entry.getValue());
        }
        //当传递的请求体对象是一个MultiValuedMap对象时，WebClient默认发起的是Form提交，即：application/x-www-form-urlencoded
        Mono<T> mono = WebClient
                //创建WebClient实例
                .create()
                //设置请求内容类型未：Content-Type=application/json
                //请求方式
                .method(HttpMethod.POST)
                //请求url
                .uri(url)
                //请求参数
                .bodyValue(paramsMap)
                //获取响应结果
                .retrieve()
                //将结果转化未响应类型
                .bodyToMono(responseDataClass)
                //超时等待，毫秒级，这里是8秒超时
                .timeout(Duration.ofMillis(8000))
                .onErrorResume(e -> {
//                    if (e instanceof WebClientResponseException) {
//                        WebClientResponseException ex = (WebClientResponseException) e;
//                    }
                    return Mono.error(e); // 重新抛出异常或者返回其他Mono错误信号
                });
        //block方法返回最终调用结果，block方法是阻塞的
        T responseData = mono.block();
        return responseData;
    }


    /**
     * 发送psot请求（JSON数据），异步请求
     * @param url
     * @param params
     * @param responseDataClass
     * @param <T>
     * @return
     */
    public final <T> void sendPostByPostAsync(String url,Object params,Class<T> responseDataClass){
        String paramsJsonStr;
        if(params instanceof JSONObject){
            paramsJsonStr = ((JSONObject) params).toJSONString();
        }else {
            paramsJsonStr = JSON.toJSONString(params);
        }
        WebClient
            //创建WebClient实例
            .builder()
            //设置请求内容类型未：Content-Type=application/json
            .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
            .build()
            //请求方式
            .method(HttpMethod.POST)
            //请求url
            .uri(url)
            //请求参数
            .bodyValue(paramsJsonStr)
            //获取响应结果
            .retrieve()
            //将结果转化未响应类型
            .bodyToMono(responseDataClass)
            //超时等待，毫秒级，这里是8秒超时
            .timeout(Duration.ofMillis(8000))
            //异步处理
            .subscribe(response->{
                //处理响应
                System.out.println(response);
            },error->{
                //处理错误
                System.out.println(error.getMessage());
            });
    }


}

 

maven引入包

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