0
0

spring钟的WebClient 如何设置连接超时时间，读取超时时间

在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();
    }
}

详细说明

  1. 导入所需包：- org.springframework.web.reactive.function.client.WebClient- reactor.netty.http.client.HttpClient- java.time.Duration
  2. 创建HttpClient：- 使用 HttpClient.create() 创建一个新的 HttpClient 实例。- 使用 option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000) 设置连接超时时间为5000毫秒（5秒）。- 使用 responseTimeout(Duration.ofMillis(10000)) 设置读取超时时间为10000毫秒（10秒）。
  3. 配置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();
    }
}

关键点解释

  1. TcpClient：- TcpClient.create() 创建一个新的 TcpClient 实例。- option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000) 设置连接超时时间为 5000 毫秒（5 秒）。- doOnConnected 配置在连接建立后添加 ReadTimeoutHandler 和 WriteTimeoutHandler，分别设置读取超时和写入超时。
  2. HttpClient：- HttpClient.from(tcpClient) 使用配置好的 TcpClient 创建一个 HttpClient 实例。- responseTimeout(Duration.ofMillis(10000)) 设置读取超时时间为 10000 毫秒（10 秒）。
  3. 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 如何设置连接超时时间，和读取超时时间

ChatGPT

在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();
    }
}

详细说明

  1. 导入所需的包：- 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
  2. 配置 TcpClient：- TcpClient.create()：创建一个新的 TcpClient 实例。- option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)：设置连接超时时间为5000毫秒（5秒）。- doOnConnected：配置在连接建立后添加 ReadTimeoutHandler 和 WriteTimeoutHandler，分别设置读取超时和写入超时。
  3. 配置 HttpClient：- HttpClient.from(tcpClient)：使用配置好的 TcpClient 创建一个 HttpClient 实例。- responseTimeout(Duration.ofMillis(10000))：设置读取超时时间为10000毫秒（10秒）。
  4. 配置 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);
    }
}

详细解释

  1. RedisTemplate 和 ZSetOperations：- RedisTemplate<String, String> 是Spring提供的用于与Redis进行同步操作的模板类。- ZSetOperations<String, String> 是专门用于操作有序集合（ZSet）的接口。- rangeByScoreWithScores(key, minScore, Double.MAX_VALUE) 方法用于获取有序集合中分值在minScore和Double.MAX_VALUE之间的所有元素及其分值。
  2. ReactiveRedisTemplate 和 ZSetOperations：- ReactiveRedisTemplate<String, String> 是Spring提供的用于与Redis进行异步操作的模板类。- rangeByScoreWithScores(key, minScore, Double.MAX_VALUE) 方法返回一个Flux<ZSetOperations.TypedTuple<String>>，用于异步流处理。
  3. 控制器层的使用：- 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

作为上限并不会显著影响性能。

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

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

关键点解释

  1. 分页查询：- rangeByScoreWithScores(key, minScore, Double.MAX_VALUE, offset, count) 方法用于获取有序集合中分值在 minScore 和 Double.MAX_VALUE 之间的所有元素及其分值，并且从 offset 开始获取 count 个元素。
  2. 性能优化：- 分页查询避免一次性返回大量数据，可以提升查询性能，特别是在数据量很大的情况下。

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

标签： spring java 后端
本文转载自: https://blog.csdn.net/qq_33192454/article/details/140471413
版权归原作者 qq_33192454 所有， 如有侵权，请联系我们删除。
登录后发布评论

“spring钟的WebClient 如何设置连接超时时间，读取超时时间”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

如何安装Rocky Linux8.5？详细过程及安装包如下

【VScode】VSCode中的智能编程利器，全面揭秘ChatMoss & ChatGPT中文版

【解决办法】无法使用右键“通过VSCode打开文件夹”

使用MFC与Excel交互实现报表打印功能

PHP与MySQL数据库交互：数据录入与输出实战

Axure PR 9 多级下拉选择器 设计&交互

结合人工智能，大数据，物联网等主流技术实现业务流程的闭环整合的智慧快消开源了。

文章导航