WebClient网络请求工具类

于 2021-11-04 20:28:31 发布
阅读量1k 收藏 3
点赞数
分类专栏： java 文章标签： 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jiangbohao_/article/details/121150745
版权
本文介绍了一个名为WebClientHelper的工具类，它提供了便捷的GET、POST及JSON请求方法，支持字符串、对象解析，并设置了连接和读取超时。通过实例和方法展示了如何使用这些功能进行网络请求操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

网络请求工具类:

package com.xx.xx.xx.helper;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.netty.channel.ChannelOption;
import io.netty.handler.timeout.ReadTimeoutHandler;
import org.springframework.http.MediaType;
import org.springframework.http.client.reactive.ClientHttpConnector;
import org.springframework.http.client.reactive.ReactorClientHttpConnector;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.client.ClientResponse;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;
import reactor.netty.http.client.HttpClient;

import java.time.Duration;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

/**
 * 网络请求工具类
 *
 * @author admin
 */
public class WebClientHelper {

    private static final Integer DEFAULT_CONNECT_TIMEOUT = 3000;

    private static final Integer DEFAULT_REQUEST_TIMEOUT = 10000;

    /**
     * get请求解析成字符串
     *
     * @param url url
     * @return java.lang.String
     * @author admin admin
     * @since 2019/10/30
     */
    public static ClientResponse getResponse(String url) {
        Mono<ClientResponse> resp = createWebClientWithConnectAndReadTimeOuts()
                .get()
                .uri(url)
                .exchange();

        return resp.block();
    }

    /**
     * get请求，解析成对象
     *
     * @param url     url
     * @param tClass  class
     * @param headers 请求头
     * @return T
     * @author admin 
     * @since 2019/10/30
     */
    public static <T> T get(String url, Class<T> tClass, Map<String, String> headers) {
        Mono<T> resp = createWebClientWithConnectAndReadTimeOuts()
                .get()
                .uri(url)
                .headers(t -> t.setAll(headers))
                .retrieve()
                .bodyToMono(tClass).timeout(Duration.ofMillis(DEFAULT_REQUEST_TIMEOUT));
        return resp.block();
    }

    /**
     * get请求，解析成对象
     *
     * @param url     url
     * @param headers 请求头
     * @return T
     * @author admin 
     * @since 2019/10/30
     */
    public static String get(String url, Map<String, String> headers) {
        Mono<String> resp = createWebClientWithConnectAndReadTimeOuts()
                .get()
                .uri(url)
                .headers(t -> t.setAll(headers))
                .retrieve()
                .bodyToMono(String.class).timeout(Duration.ofMillis(DEFAULT_REQUEST_TIMEOUT));
        return resp.block();
    }

    /**
     * get请求，解析成对象
     *
     * @param scheme  协议 http/https
     * @param host    host
     * @param obj     query params
     * @param headers 请求头
     * @return T
     * @author admin 
     * @since 2019/10/30
     */
    public static String get(String scheme, String host, String path, Object obj, Map<String, String> headers) {
        Mono<String> resp = createWebClientWithConnectAndReadTimeOuts()
                .get()
                .uri(uriBuilder -> uriBuilder.scheme(scheme).host(host).path(path).queryParams(getRequestParamMapByObj(obj)).build())
                .headers(t -> t.setAll(headers))
                .retrieve()
                .bodyToMono(String.class).timeout(Duration.ofMillis(DEFAULT_REQUEST_TIMEOUT));
        return resp.block();
    }

    /**
     * get请求，解析成对象
     *
     * @param url    url
     * @param tClass class
     * @return T
     * @author admin 
     * @since 2019/10/30
     */
    public static <T> T get(String url, Object obj, Class<T> tClass) {
        Mono<T> resp = createWebClientWithConnectAndReadTimeOuts()
                .get()
                .uri(uriBuilder -> uriBuilder.path(url).queryParams(getRequestParamMapByObj(obj)).build())
                .retrieve()
                .bodyToMono(tClass).timeout(Duration.ofMillis(DEFAULT_REQUEST_TIMEOUT));
        return resp.block();
    }


    /**
     * get请求，解析成对象
     *
     * @param url    url
     * @param tClass class
     * @return T
     * @author admin 
     * @since 2019/10/30
     */
    public static <T> T get(String url, Class<T> tClass) {
        Mono<T> resp = createWebClientWithConnectAndReadTimeOuts()
                .get()
                .uri(url)
                .retrieve()
                .bodyToMono(tClass).timeout(Duration.ofMillis(DEFAULT_REQUEST_TIMEOUT));
        return resp.block();
    }

    /**
     * get请求解析成字符串
     *
     * @param url url
     * @return java.lang.String
     * @author admin 
     * @since 2019/10/30
     */
    public static String get(String url) {
        Mono<String> resp = createWebClientWithConnectAndReadTimeOuts()
                .get()
                .uri(url)
                .retrieve()
                .bodyToMono(String.class).timeout(Duration.ofMillis(DEFAULT_REQUEST_TIMEOUT));

        return resp.block();
    }

    /**
     * post表单请求返回对象
     *
     * @param url    url
     * @param params 请求参数
     * @param tClass 返回对象
     * @return T
     * @author admin
     * @since 2019/10/30
     */
    public static <T> T post(String url, Map<String, String> params, Class<T> tClass) {
        MultiValueMap<String, String> formData = getRequestParamMap(params);
        Mono<T> resp = createWebClientWithConnectAndReadTimeOuts().post()
                .uri(url)
                .contentType(MediaType.APPLICATION_FORM_URLENCODED)
                .body(BodyInserters.fromFormData(formData))
                .retrieve().bodyToMono(tClass).timeout(Duration.ofMillis(DEFAULT_REQUEST_TIMEOUT));

        return resp.block();
    }

    /**
     * post表单请求返回字符串
     *
     * @param url    url
     * @param params 请求参数
     * @return java.lang.String
     * @author admin 
     * @since 2019/10/30
     */
    public static String post(String url, Map<String, String> params) {
        MultiValueMap<String, String> formData = getRequestParamMap(params);
        Mono<String> resp = createWebClientWithConnectAndReadTimeOuts().post()
                .uri(url)
                .contentType(MediaType.APPLICATION_FORM_URLENCODED)
                .body(BodyInserters.fromFormData(formData))
                .retrieve().bodyToMono(String.class).timeout(Duration.ofMillis(DEFAULT_REQUEST_TIMEOUT));

        return resp.block();
    }

    /**
     * post json请求结果解析成对象
     *
     * @param url      url
     * @param jsonBody 请求body，可以是对象或者是map
     * @param tClass   解析对象
     * @return T
     * @author admin 
     * @since 2019/10/30
     */
    public static <T> T postJson(String url, Object jsonBody, Class<T> tClass) {
        Mono<T> resp = createWebClientWithConnectAndReadTimeOuts().post()
                .uri(url)
                .contentType(MediaType.APPLICATION_JSON_UTF8)
                .body(Mono.just(jsonBody), Object.class)
                .retrieve().bodyToMono(tClass).timeout(Duration.ofMillis(DEFAULT_REQUEST_TIMEOUT));

        return resp.block();
    }

    /**
     * post json请求结果解析成对象
     *
     * @param url      url
     * @param jsonBody 请求body，可以是对象或者是map
     * @param tClass   解析对象
     * @return T
     * @author admin 
     * @since 2019/10/30
     */
    public static <T> T postJson(String url, Map<String, String> headers, Object jsonBody, Class<T> tClass) {
        Mono<T> resp = createWebClientWithConnectAndReadTimeOuts().post()
                .uri(url)
                .contentType(MediaType.APPLICATION_JSON_UTF8)
                .headers(t -> t.setAll(headers))
                .body(Mono.just(jsonBody), Object.class)
                .retrieve().bodyToMono(tClass).timeout(Duration.ofMillis(DEFAULT_REQUEST_TIMEOUT));

        return resp.block();
    }

    /**
     * post json请求结果解析成字符串
     *
     * @param url      url
     * @param jsonBody 请求body，可以是对象或者是map
     * @return java.lang.String
     * @author admin 
     * @since 2019/10/30
     */
    public static String postJson(String url, Object jsonBody) {
        Mono<String> resp = createWebClientWithConnectAndReadTimeOuts().post()
                .uri(url)
                .contentType(MediaType.APPLICATION_JSON_UTF8)
                .body(Mono.just(jsonBody), Object.class)
                .retrieve().bodyToMono(String.class).timeout(Duration.ofMillis(DEFAULT_REQUEST_TIMEOUT));

        return resp.block();
    }

    /**
     * post json请求结果解析成字符串
     *
     * @param url      url
     * @param jsonBody 请求body，可以是对象或者是map
     * @return java.lang.String
     * @author admin 
     * @since 2019/10/30
     */
    public static String postJson(String url, Map<String, String> headers, Object jsonBody) {
        Mono<String> resp = createWebClientWithConnectAndReadTimeOuts().post()
                .uri(url)
                .contentType(MediaType.APPLICATION_JSON_UTF8)
                .headers(t -> t.setAll(headers))
                .body(Mono.just(jsonBody), Object.class)
                .retrieve().bodyToMono(String.class).timeout(Duration.ofMillis(DEFAULT_REQUEST_TIMEOUT));

        return resp.block();
    }

    public static <T> T postRawJson(String url, String jsonBody, Class<T> tClass) {
        Mono<T> resp = createWebClientWithConnectAndReadTimeOuts().post()
                .uri(url)
                .contentType(MediaType.APPLICATION_JSON_UTF8)
                .body(BodyInserters.fromObject(jsonBody))
                .retrieve().bodyToMono(tClass).timeout(Duration.ofMillis(DEFAULT_REQUEST_TIMEOUT));

        return resp.block();
    }

    public static String postRawJson(String url, String jsonBody) {
        Mono<String> resp = createWebClientWithConnectAndReadTimeOuts().post()
                .uri(url)
                .contentType(MediaType.APPLICATION_JSON_UTF8)
                .body(BodyInserters.fromObject(jsonBody))
                .retrieve().bodyToMono(String.class).timeout(Duration.ofMillis(DEFAULT_REQUEST_TIMEOUT));

        return resp.block();
    }

    private static WebClient createWebClientWithConnectAndReadTimeOuts() {
        // create reactor netty HTTP client
        HttpClient httpClient = HttpClient.create()
                .tcpConfiguration(tcpClient -> {
                    tcpClient = tcpClient.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, DEFAULT_CONNECT_TIMEOUT);
                    tcpClient = tcpClient.doOnConnected(conn -> conn
                            .addHandlerLast(new ReadTimeoutHandler(DEFAULT_REQUEST_TIMEOUT, TimeUnit.MILLISECONDS)));
                    return tcpClient;
                });
        // create a client http connector using above http client
        ClientHttpConnector connector = new ReactorClientHttpConnector(httpClient);
        // use this configured http connector to build the web client
        return WebClient.builder().clientConnector(connector).build();
    }

    private static MultiValueMap<String, String> getRequestParamMap(Map<String, String> params) {
        MultiValueMap<String, String> queryParams = new LinkedMultiValueMap<>();
        for (Map.Entry<String, String> entry : params.entrySet()) {
            queryParams.add(entry.getKey(), entry.getValue());
        }

        return queryParams;
    }

    private static MultiValueMap<String, String> getRequestParamMapByObj(Object obj) {
        ObjectMapper objectMapper = new ObjectMapper();
        Map<String, Object> map = objectMapper.convertValue(obj, new TypeReference<Map<String, Object>>() {
        });
        MultiValueMap<String, String> queryParams = new LinkedMultiValueMap<>();
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            if (Objects.isNull(entry.getValue())) {
                continue;
            }
            queryParams.add(entry.getKey(), String.valueOf(entry.getValue()));
        }

        return queryParams;
    }


}
基于WebClient实现的FTP协议上传文件的工具类
Joseph的专栏
03-20 1926
基于WebClient实现的FTP协议上传文件的工具类asp.net实现代码：using System;using System.Collections.Generic;using System.IO;using System.Net;using System.Text;using System.Xml;namespace Joseph.Web{    ///     /// 基于We
Spring框架中使用WebClient发送请求
最新发布
rkmhr_sef的博客
12-13 818
可以使用 .block() 让 WebClient 的调用同步阻塞，方便传统开发者的过渡。通过 Mono 和Flux 支持异步和响应式的编程模型，非常适合处理大量并发请求。可以通过 onStatus() 针对不同的状态码进行错误处理。可以自定义超时、拦截器、连接池等，适应各种复杂场景。
WebService Client 工具类 (JAVA源代码)
12-29
自定义封装的WebService Client 工具包，纯代码版，无任何jar包，基于SOAP协议解析,进行网络流转换为XML，通过属性和节点反复跳转访问数据绑定的节点地址，获取对应数据和发送对应的数据。数据格式内容都已处理好，直接调用，也可以参照学习。下载完解压直接将文件夹复制到项目里，直接引用即可。
J2EE工具类：WebClient.java
gundumw100的专栏
07-02 171
[code="java"] import java.io.BufferedReader; import java.io.DataOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.net.HttpURLCon...
WebFlux实战——WebClent简单实用的工具类封装
SuperWei的博客
02-18 3804
WebClient是WebFlux框架中重要的Http请求框架。同时也是Spring官方的Http请求工具，相当于SpringMVC框架中的RestTemplate。笔者在对日常使用的场景进行抽象后，封装了一个工具类，使得这个工具使用起来更加方便
java网络请求工具类
08-27
Java中常用的网络请求工具有很多，以下是其中一些常见的库： 1. **Apache HttpClient**：这是Apache提供的官方HTTP客户端库，功能强大且稳定，支持HTTP/1.x和HTTP/2协议。 2. **OkHttp**：由Square公司维护，是一...
C#中在WebClient中使用post发送数据实现方法
09-04
在C#编程中，WebClient类是一个非常实用的工具，它提供了向网络资源发送和接收数据的能力。在某些场景下，我们需要使用POST方法来传递数据，比如提交表单或者与Web服务进行交互。POST方法相比于GET方法的优势在于它...
C# WebClient类用法实例
09-03
在C#编程中，WebClient类是一个非常实用的工具，用于执行基本的HTTP操作，如下载、上传文件以及读写数据。这个类简化了与Web资源的交互，尤其适用于需要在后台服务或无用户界面的环境中进行网络通信的情况。下面我们...
网络请求工具类
03-02
NSURLSession网络请求,自定义网络请求，可暂停和开启下载，同时可现实下载速度，进程
kafka消费者进程里如何实现用webclient发起网络请求
08-12
Kafka消费者进程可以通过使用WebClient类，实现通过发起网络请求来进行交互。 首先，我们需要在Kafka消费者的代码中引入WebClient类的相关依赖库。可以使用Maven或者Gradle将以下依赖添加到项目中： ``` ...
WebClient类
ajwqb06628的专栏
02-19 182
WebClient类 WebClient类提供向 URI 标识的资源发送数据和从 URI 标识的资源接收数据的公共方法。 其实就相当于创建一个请求客户端。可以获取网页和各种各样的信息，包括交互。 通过MSDN来看看WebClient类提供的功能。 一、属性 1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值