spring中WebClient如何设置连接超时时间以及读取超时时间

更新时间：2024年08月09日 11:27:15 作者：qq_33192454

这篇文章主要给大家介绍了关于spring中WebClient如何设置连接超时时间以及读取超时时间的相关资料,WebClient是Spring框架5.0引入的基于响应式编程模型的HTTP客户端,它提供一种简便的方式来处理HTTP请求和响应,需要的朋友可以参考下

前言

在Spring WebFlux中，WebClient 提供了一种灵活的方式来配置连接超时时间和读取超时时间。你可以使用 reactor.netty.http.client.HttpClient 来进行这些配置。以下是如何设置连接超时和读取超时的示例代码：

import org.springframework.web.reactive.function.client.WebClient;
import reactor.netty.http.client.HttpClient;
import java.time.Duration;

public class WebClientConfig {

    public WebClient createWebClient() {
        HttpClient httpClient = HttpClient.create()
                .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000) // 连接超时
                .responseTimeout(Duration.ofMillis(10000)); // 读取超时

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

详细说明

导入所需包：

org.springframework.web.reactive.function.client.WebClient
reactor.netty.http.client.HttpClient
java.time.Duration

创建HttpClient：

使用 HttpClient.create() 创建一个新的 HttpClient 实例。
使用 option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000) 设置连接超时时间为5000毫秒（5秒）。
使用 responseTimeout(Duration.ofMillis(10000)) 设置读取超时时间为10000毫秒（10秒）。

配置WebClient：

使用 WebClient.builder() 创建一个新的 WebClient.Builder 实例。
使用 clientConnector(new ReactorClientHttpConnector(httpClient)) 将自定义的 HttpClient 设置为 WebClient 的客户端连接器。
使用 build() 方法构建 WebClient 实例。

完整的示例类

import org.springframework.web.reactive.function.client.WebClient;
import reactor.netty.http.client.HttpClient;
import reactor.netty.tcp.TcpClient;
import io.netty.channel.ChannelOption;
import java.time.Duration;

public class WebClientConfig {

    public WebClient createWebClient() {
        TcpClient tcpClient = TcpClient.create()
                .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)
                .doOnConnected(connection ->
                        connection.addHandlerLast(new ReadTimeoutHandler(10))
                                  .addHandlerLast(new WriteTimeoutHandler(10)));

        HttpClient httpClient = HttpClient.from(tcpClient);

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

解释

TcpClient：用于配置底层的TCP连接参数，包括连接超时。
ReadTimeoutHandler 和 WriteTimeoutHandler：用于设置读取和写入的超时时间（以秒为单位）。

通过上述配置，你可以成功地设置 WebClient 的连接超时时间和读取超时时间。在生产环境中，可以根据需要调整这些超时时间，以适应不同的网络条件和服务端性能。

HttpClient httpClient = HttpClient.create() .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000) // 连接超时 .responseTimeout(Duration.ofMillis(10000)); // 读取超时这一段 HttpClient 没有这个方法的啊，尤其是option

对于 Spring WebFlux 中的 WebClient 配置连接超时和读取超时，最新版本的 reactor.netty.http.client.HttpClient 可能不再直接支持 option 方法。你可以通过 TcpClient 来设置这些超时选项。以下是使用 TcpClient 和 HttpClient 来设置连接超时和读取超时的完整示例：

import org.springframework.web.reactive.function.client.WebClient;
import reactor.netty.http.client.HttpClient;
import reactor.netty.tcp.TcpClient;
import io.netty.channel.ChannelOption;
import io.netty.handler.timeout.ReadTimeoutHandler;
import io.netty.handler.timeout.WriteTimeoutHandler;

import java.time.Duration;

public class WebClientConfig {

    public WebClient createWebClient() {
        // 配置连接超时和读取超时
        TcpClient tcpClient = TcpClient.create()
                .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000) // 连接超时
                .doOnConnected(connection ->
                        connection.addHandlerLast(new ReadTimeoutHandler(10)) // 读取超时
                                  .addHandlerLast(new WriteTimeoutHandler(10))); // 写入超时

        // 使用自定义的 TcpClient 创建 HttpClient
        HttpClient httpClient = HttpClient.from(tcpClient)
                .responseTimeout(Duration.ofMillis(10000)); // 读取超时

        // 创建 WebClient 并设置自定义的 HttpClient
        return WebClient.builder()
                .clientConnector(new ReactorClientHttpConnector(httpClient))
                .build();
    }
}

关键点解释

TcpClient：

TcpClient.create() 创建一个新的 TcpClient 实例。
option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000) 设置连接超时时间为 5000 毫秒（5 秒）。
doOnConnected 配置在连接建立后添加 ReadTimeoutHandler 和 WriteTimeoutHandler，分别设置读取超时和写入超时。

HttpClient：

HttpClient.from(tcpClient) 使用配置好的 TcpClient 创建一个 HttpClient 实例。
responseTimeout(Duration.ofMillis(10000)) 设置读取超时时间为 10000 毫秒（10 秒）。

WebClient：

使用 WebClient.builder() 创建一个新的 WebClient.Builder 实例。
使用 clientConnector(new ReactorClientHttpConnector(httpClient)) 将自定义的 HttpClient 设置为 WebClient 的客户端连接器。
使用 build() 方法构建 WebClient 实例。

完整示例类

import org.springframework.web.reactive.function.client.WebClient;
import reactor.netty.http.client.HttpClient;
import reactor.netty.tcp.TcpClient;
import io.netty.channel.ChannelOption;
import io.netty.handler.timeout.ReadTimeoutHandler;
import io.netty.handler.timeout.WriteTimeoutHandler;

import java.time.Duration;

public class WebClientConfig {

    public WebClient createWebClient() {
        // 配置连接超时和读取超时
        TcpClient tcpClient = TcpClient.create()
                .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000) // 连接超时
                .doOnConnected(connection ->
                        connection.addHandlerLast(new ReadTimeoutHandler(10)) // 读取超时
                                  .addHandlerLast(new WriteTimeoutHandler(10))); // 写入超时

        // 使用自定义的 TcpClient 创建 HttpClient
        HttpClient httpClient = HttpClient.from(tcpClient)
                .responseTimeout(Duration.ofMillis(10000)); // 读取超时

        // 创建 WebClient 并设置自定义的 HttpClient
        return WebClient.builder()
                .clientConnector(new ReactorClientHttpConnector(httpClient))
                .build();
    }
}

通过这种方式，你可以设置 WebClient 的连接超时时间和读取超时时间。注意，这里的读取超时是通过 ReadTimeoutHandler 配置的，它会在指定时间内没有数据读取时触发超时。

SPring 5.2.8 版本，使用WebClient 如何设置连接超时时间，和读取超时时间

在Spring 5.2.8版本中，WebClient 的配置可以通过 TcpClient 和 HttpClient 来设置连接超时和读取超时。以下是一个完整的示例，展示如何在Spring 5.2.8中配置 WebClient 的连接超时时间和读取超时时间。

示例代码

import org.springframework.web.reactive.function.client.WebClient;
import reactor.netty.http.client.HttpClient;
import reactor.netty.tcp.TcpClient;
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 java.time.Duration;

public class WebClientConfig {

    public WebClient createWebClient() {
        // 配置 TcpClient
        TcpClient tcpClient = TcpClient.create()
                .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000) // 连接超时
                .doOnConnected(connection -> 
                        connection.addHandlerLast(new ReadTimeoutHandler(10)) // 读取超时
                                  .addHandlerLast(new WriteTimeoutHandler(10))); // 写入超时

        // 配置 HttpClient
        HttpClient httpClient = HttpClient.from(tcpClient)
                .responseTimeout(Duration.ofMillis(10000)); // 读取超时

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

详细说明

导入所需的包：

org.springframework.web.reactive.function.client.WebClient
reactor.netty.http.client.HttpClient
reactor.netty.tcp.TcpClient
io.netty.channel.ChannelOption
io.netty.handler.timeout.ReadTimeoutHandler
io.netty.handler.timeout.WriteTimeoutHandler
org.springframework.http.client.reactive.ReactorClientHttpConnector
java.time.Duration

配置 TcpClient：

TcpClient.create()：创建一个新的 TcpClient 实例。
option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)：设置连接超时时间为5000毫秒（5秒）。
doOnConnected：配置在连接建立后添加 ReadTimeoutHandler 和 WriteTimeoutHandler，分别设置读取超时和写入超时。

配置 HttpClient：

HttpClient.from(tcpClient)：使用配置好的 TcpClient 创建一个 HttpClient 实例。
responseTimeout(Duration.ofMillis(10000))：设置读取超时时间为10000毫秒（10秒）。

配置 WebClient：

WebClient.builder()：创建一个新的 WebClient.Builder 实例。
clientConnector(new ReactorClientHttpConnector(httpClient))：将自定义的 HttpClient 设置为 WebClient 的客户端连接器。
build()：构建 WebClient 实例。

通过以上配置，你可以在Spring 5.2.8中成功地设置 WebClient 的连接超时时间和读取超时时间。注意，这里的读取超时是通过 ReadTimeoutHandler 配置的，它会在指定时间内没有数据读取时触发超时。

spring 操作Redis中的Zset ，我要获取大于某个分值的所有数据，如何操作

在Spring Data Redis中，你可以使用RedisTemplate或ReactiveRedisTemplate来操作Redis中的Zset，并获取大于某个分值的所有数据。下面是如何使用这两种方式来实现这一需求的示例。

使用RedisTemplate

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Service;

import java.util.Set;

@Service
public class RedisZSetService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    public Set<ZSetOperations.TypedTuple<String>> getZSetByMinScore(String key, double minScore) {
        ZSetOperations<String, String> zSetOps = redisTemplate.opsForZSet();
        return zSetOps.rangeByScoreWithScores(key, minScore, Double.MAX_VALUE);
    }
}

使用ReactiveRedisTemplate

如果你使用的是Spring WebFlux，并希望使用反应式编程模型，你可以使用ReactiveRedisTemplate。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ReactiveRedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;

@Service
public class ReactiveRedisZSetService {

    @Autowired
    private ReactiveRedisTemplate<String, String> reactiveRedisTemplate;

    public Flux<ZSetOperations.TypedTuple<String>> getZSetByMinScore(String key, double minScore) {
        ZSetOperations<String, String> zSetOps = reactiveRedisTemplate.opsForZSet();
        return zSetOps.rangeByScoreWithScores(key, minScore, Double.MAX_VALUE);
    }
}

使用示例

假设你有一个RedisZSetService实例，以下是如何使用它来获取大于某个分值的所有数据：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.data.redis.core.ZSetOperations.TypedTuple;

import java.util.Set;

@RestController
public class RedisController {

    @Autowired
    private RedisZSetService redisZSetService;

    @GetMapping("/getZSetByMinScore")
    public Set<TypedTuple<String>> getZSetByMinScore(@RequestParam String key, @RequestParam double minScore) {
        return redisZSetService.getZSetByMinScore(key, minScore);
    }
}

详细解释

RedisTemplate 和 ZSetOperations：

RedisTemplate<String, String> 是Spring提供的用于与Redis进行同步操作的模板类。
ZSetOperations<String, String> 是专门用于操作有序集合（ZSet）的接口。
rangeByScoreWithScores(key, minScore, Double.MAX_VALUE) 方法用于获取有序集合中分值在minScore和Double.MAX_VALUE之间的所有元素及其分值。

ReactiveRedisTemplate 和 ZSetOperations：

ReactiveRedisTemplate<String, String> 是Spring提供的用于与Redis进行异步操作的模板类。
rangeByScoreWithScores(key, minScore, Double.MAX_VALUE) 方法返回一个Flux<ZSetOperations.TypedTuple<String>>，用于异步流处理。

控制器层的使用：

RedisController 类提供一个RESTful接口，调用RedisZSetService获取大于某个分值的所有数据。

通过这些配置和代码，你可以在Spring应用程序中方便地操作Redis中的有序集合，并获取大于某个分值的所有数据。

return zSetOps.rangeByScoreWithScores(key, minScore, Double.MAX_VALUE); 使用Double.Max 是否影响性能呢，

在使用 Double.MAX_VALUE 作为 Redis ZSet 操作的最大值时，一般情况下性能不会受到显著影响。Redis 是一个高性能的内存数据库，处理范围查询时会利用跳表（skip list）数据结构的特性来快速定位和遍历元素。因此，对于大多数应用场景，使用 Double.MAX_VALUE 作为上限并不会显著影响性能。

然而，在极端情况下，如果有非常多的元素在这个范围内，查询的性能可能会受到影响。为了解决这种潜在的性能问题，可以采取以下措施：

分页查询：如果查询的结果集可能非常大，可以使用分页（通过 ZRangeByScore 和 LIMIT 参数）来逐步获取结果，避免一次性返回大量数据。
索引优化：确保 Redis 服务器有足够的内存，并且没有进行其他阻塞操作，可以提升查询性能。
限制结果集：如果知道合理的最大值范围，可以使用一个具体的最大值而不是 Double.MAX_VALUE。

具体示例：分页查询

以下是使用分页查询的示例代码：

使用RedisTemplate进行分页查询

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Service;

import java.util.Set;

@Service
public class RedisZSetService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    public Set<ZSetOperations.TypedTuple<String>> getZSetByMinScoreWithPagination(String key, double minScore, long offset, long count) {
        ZSetOperations<String, String> zSetOps = redisTemplate.opsForZSet();
        return zSetOps.rangeByScoreWithScores(key, minScore, Double.MAX_VALUE, offset, count);
    }
}

使用ReactiveRedisTemplate进行分页查询

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ReactiveRedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;

@Service
public class ReactiveRedisZSetService {

    @Autowired
    private ReactiveRedisTemplate<String, String> reactiveRedisTemplate;

    public Flux<ZSetOperations.TypedTuple<String>> getZSetByMinScoreWithPagination(String key, double minScore, long offset, long count) {
        ZSetOperations<String, String> zSetOps = reactiveRedisTemplate.opsForZSet();
        return zSetOps.rangeByScoreWithScores(key, minScore, Double.MAX_VALUE, offset, count);
    }
}

使用示例

假设你有一个 RedisZSetService 实例，以下是如何使用它来进行分页查询：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.data.redis.core.ZSetOperations.TypedTuple;

import java.util.Set;

@RestController
public class RedisController {

    @Autowired
    private RedisZSetService redisZSetService;

    @GetMapping("/getZSetByMinScoreWithPagination")
    public Set<TypedTuple<String>> getZSetByMinScoreWithPagination(
            @RequestParam String key, 
            @RequestParam double minScore, 
            @RequestParam long offset, 
            @RequestParam long count) {
        return redisZSetService.getZSetByMinScoreWithPagination(key, minScore, offset, count);
    }
}

关键点解释

分页查询：

rangeByScoreWithScores(key, minScore, Double.MAX_VALUE, offset, count) 方法用于获取有序集合中分值在 minScore 和 Double.MAX_VALUE 之间的所有元素及其分值，并且从 offset 开始获取 count 个元素。

性能优化：

分页查询避免一次性返回大量数据，可以提升查询性能，特别是在数据量很大的情况下。

通过以上方式，可以更有效地处理大数据量的查询，提升应用的响应速度和性能。

总结

到此这篇关于spring中WebClient如何设置连接超时时间以及读取超时时间的文章就介绍到这了,更多相关spring WebClient设置连接超时时间内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Spring Feign超时设置深入了解

SpringBoot添加License的多种方式
License指的是版权许可证，当我们开发完系统后，如果不想让用户一直白嫖使用，比如说按时间续费，License的作用就有了。我们可以给系统指定License的有效期，控制系统的可用时间。
2021-06-06
Spring Boot集成Quartz注入Spring管理的类的方法
本篇文章主要介绍了Spring Boot集成Quartz注入Spring管理的类的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2018-04-04
详解mybatis中association和collection的column传入多个参数问题
这篇文章主要介绍了详解mybatis中association和collection的column传入多个参数问题，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2019-10-10
springboot项目中后端接收前端传参的方法示例详解
这篇文章主要介绍了springboot项目中一些后端接收前端传参的方法,本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2023-06-06
SpringBoot整合EasyExcel实现Excel表格导出功能
这篇文章主要介绍了SpringBoot整合EasyExcel实现Excel表格导出功能，文章围绕主题展开详细的内容介绍，具有一定的参考价值，需要的朋友可以参考一下
2022-07-07
解决java.util.NoSuchElementException异常的问题
这篇文章主要介绍了解决java.util.NoSuchElementException异常的问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2020-09-09
java ant包中的org.apache.tools.zip实现压缩和解压缩实例详解
这篇文章主要介绍了java ant包中的org.apache.tools.zip实现压缩和解压缩实例详解的相关资料,需要的朋友可以参考下
2017-04-04
基于JWT实现SSO单点登录流程图解
这篇文章主要介绍了基于JWT实现SSO单点登录流程图解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2020-07-07
Mybatis-Plus自动填充更新操作相关字段的实现
这篇文章主要介绍了Mybatis-Plus自动填充更新操作相关字段的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2020-12-12
eclipse启动出现“failed to load the jni shared library”问题解决
这篇文章主要介绍了eclipse启动出现“failed to load the jni shared library”问题解决,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2019-11-11