开发者

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

开发 作者： qq_33192454
目录
  • 前言
  • 详细说明
  • 完整的示例类
  • 解释
  • 关键点解释
  • 完整示例类
    • 示例代码
    • 详细说明
  • 使用RedisTemplate
    • 使用ReactiveRedisTemplate
      • 使用示例
      • 详细解释
    • 具体示例：分页查询
      • 使用RedisTemplate进行分页查询
      • 使用ReactiveRedisTemplate进行分页查询
      • 使用示例
      • 关键点解释
    • 总结

      前言

      在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(Dhttp://www.devze.comuration.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)) // 读取超时
    android                              .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.GetMap编程ping;
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提供的用php于与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设置连接超时时间内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！

      继续阅读：spring webclient连接超时时间spring 请求超时springmvc设置请求超时

      更多精彩内容

      0

      上一篇:

      下一篇:

      精彩评论

      暂无评论...
      登录 注册
      Qedev.com
      验证码 换一张
      取 消

      最新开发

      开发排行榜

      法律声明：本站内容均为网友上传，网站举办方负责审核和监督，

      如存在版权或非法内容，欢迎举报，我们将尽快予以删除。

      Copyright © 2018-2020 开发者. All rights reserved.

      Powered by 开发者

      ICP备案号： 京ICP备10032868号-9