微服务项目中基于 Servlet 的业务模块与 WebFlux 网关模块的 Redis 统一化配置教程

微服务项目中Servlet模块与WebFlux网关的Redis使用指南

在微服务架构的蓬勃发展浪潮中，Redis凭借其超高的性能、丰富的功能，已然成为缓存、分布式锁、会话存储等场景下的核心支撑技术。然而，在微服务项目里，基于Servlet的普通业务模块和基于WebFlux的网关模块，由于它们底层的技术架构存在显著差异，在使用Redis时也呈现出不同的特点和实现方式。下面，我们就深入探讨这两种场景下Redis的使用之道。

一、技术架构差异简析

在微服务的技术生态中，基于Servlet的普通业务模块和基于WebFlux的网关模块，在处理请求的方式上有着本质区别。

基于Servlet的普通模块，遵循的是同步阻塞的I/O模型。这就意味着当一个请求进入模块后，线程会一直等待I/O操作完成，在这个过程中，线程无法去处理其他请求，容易造成线程资源的浪费，尤其是在高并发场景下，可能会出现线程池耗尽的情况。

而基于WebFlux的网关模块，则采用了异步非阻塞的I/O模型。它能够在一个线程上处理多个请求，当遇到I/O操作时，线程不会阻塞等待，而是会去处理其他请求，待I/O操作完成后再回来继续处理，极大地提高了线程的利用率，非常适合高并发、I/O密集型的网关场景。

这种底层技术架构的差异，直接影响了Redis在这两种模块中的使用方式。

二、基于Servlet的普通模块使用Redis

在基于Servlet的普通模块中，我们通常会选择Spring Data Redis作为操作Redis的框架，它对Redis的各种操作进行了友好封装，让开发者能够更便捷地使用Redis。

（一）引入依赖

在 Maven 项目中，需要在pom.xml文件中引入相关依赖：

<dependency>     <groupId>org.springframework.boot</groupId>     <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency>     <groupId>org.apache.commons</groupId>     <artifactId>commons-pool2</artifactId> </dependency> 

其中，spring-boot-starter-data-redis是Spring Data Redis的 starter 依赖，commons-pool2为Redis连接池提供支持，有助于提高Redis连接的管理效率。

（二）配置Redis连接

在application.properties或application.yml中进行Redis连接信息的配置：

spring:   redis:     host: localhost     port: 6379     password: 123456     lettuce:       pool:         max-active: 8         max-idle: 8         min-idle: 2         max-wait: -1ms 

这里配置了Redis的主机地址、端口、密码以及连接池参数。采用Lettuce作为Redis客户端，它是一个高性能的异步Redis客户端，在Spring Boot 2.x及以上版本中成为了默认的客户端。

（三）Redis操作模板

Spring Data Redis提供了RedisTemplate和StringRedisTemplate两种模板类用于操作Redis。StringRedisTemplate是RedisTemplate的子类，专门用于处理键和值都是字符串的情况，使用起来更加便捷。

@Component @RequiredArgsConstructor public class RedisUtils {      private final RedisTemplate<String, Object> redisTemplate;      public void set(String key, Object value) {         redisTemplate.opsForValue().set(key, value);     }      public void set(String key, Object value, long timeout, TimeUnit unit) {         redisTemplate.opsForValue().set(key, value, timeout, unit);     }      public void set(String key, Object value, long seconds) {         redisTemplate.opsForValue().set(key, value, seconds, TimeUnit.SECONDS);     }      public Object get(String key) {         return redisTemplate.opsForValue().get(key);     }      public String getString(String key) {         Object obj = redisTemplate.opsForValue().get(key);         return obj == null ? null : obj.toString();     }      public Boolean delete(String key) {         return redisTemplate.delete(key);     }      public Boolean hasKey(String key) {         return redisTemplate.hasKey(key);     }      public Boolean setNx(String key, Object value) {         return redisTemplate.opsForValue().setIfAbsent(key, value);     }      public Boolean tryLock(String lockKey, String requestId, long seconds) {         return redisTemplate.opsForValue().setIfAbsent(lockKey, requestId, seconds, TimeUnit.SECONDS);     }      public Boolean tryLock(String lockKey, String requestId, long timeout, TimeUnit unit) {         return redisTemplate.opsForValue().setIfAbsent(lockKey, requestId, timeout, unit);     }      public Boolean releaseLock(String lockKey, String requestId) {         DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();         redisScript.setScriptText(RELEASE_SCRIPT);         redisScript.setResultType(Long.class);         Long result = redisTemplate.execute(redisScript, Collections.singletonList(lockKey), requestId);         return RELEASE_SUCCESS.equals(result);     } } 

在上述代码中，通过Lombok中热@RequireArgsConstructor注入StringRedisTemplate，然后利用其opsForValue()方法获取操作字符串类型数据的ValueOperations对象，进而实现对Redis中字符串数据的增、删、查等操作。

（四）缓存注解的使用

Spring还提供了缓存注解，如@Cacheable、@CachePut、@CacheEvict等，可以更方便地实现缓存功能。

首先，需要在配置类上添加@EnableCaching注解开启缓存功能：

@Configuration @EnableCaching public class RedisCacheConfig {      @Bean     public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {         RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()                 .entryTtl(Duration.ofMinutes(10))                 .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))                 .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))                 .disableCachingNullValues();          return RedisCacheManager.builder(connectionFactory)                 .cacheDefaults(config)                 .build();     } } 

在这个配置中，定义了Redis缓存的默认配置，包括缓存过期时间、键和值的序列化方式等。使用GenericJackson2JsonRedisSerializer对值进行序列化，能够将对象转换为JSON格式存储，方便读取和解析。

然后在Service层的方法上使用缓存注解：

@Service public class UserService {      @Autowired     private UserMapper userMapper;      @Cacheable(value = "user", key = "#id")     public User getUserById(Long id) {         return userMapper.selectById(id);     }      @CachePut(value = "user", key = "#user.id")     public User updateUser(User user) {         userMapper.updateById(user);         return user;     }      @CacheEvict(value = "user", key = "#id")     public void deleteUser(Long id) {         userMapper.deleteById(id);     } } 

@Cacheable表示在调用方法之前，会先从缓存中查询，如果缓存中存在，则直接返回缓存中的数据，不执行方法体；如果缓存中不存在，则执行方法体，并将方法的返回值存入缓存。@CachePut会将方法的返回值存入缓存，无论缓存中是否已存在该数据。@CacheEvict用于删除缓存中的数据。

三、基于WebFlux的Gateway中使用Redis

在基于WebFlux的Gateway中，由于WebFlux是异步非阻塞的，所以需要使用响应式的Redis客户端来操作Redis，以契合其异步非阻塞的特性。Spring提供了spring-boot-starter-data-redis-reactive来支持响应式Redis操作。

（一）引入依赖

在pom.xml中引入响应式Redis的依赖：

<dependency>     <groupId>org.springframework.boot</groupId>     <artifactId>spring-boot-starter-data-redis-reactive</artifactId> </dependency> <dependency>     <groupId>org.apache.commons</groupId>     <artifactId>commons-pool2</artifactId> </dependency> 

spring-boot-starter-data-redis-reactive提供了响应式的Redis操作支持，同样需要commons-pool2来支持连接池。

（二）配置Redis连接

与基于Servlet的模块类似，在application.yml中配置Redis连接信息：

spring:   redis:     host: localhost     port: 6379     password: 123456     lettuce:       pool:         max-active: 8         max-idle: 8         min-idle: 2         max-wait: -1ms 

这里的配置与Servlet模块中的配置基本一致，因为连接Redis的基本信息是相同的。

（三）响应式Redis操作

响应式Redis操作主要通过ReactiveRedisTemplate和ReactiveStringRedisTemplate来实现，它们返回的是Mono或Flux类型的结果，契合WebFlux的响应式编程模型。

@Service public class ReactiveRedisService {      @Autowired     private ReactiveStringRedisTemplate reactiveStringRedisTemplate;      // 设置字符串类型数据     public Mono<Boolean> setString(String key, String value) {         return reactiveStringRedisTemplate.opsForValue().set(key, value);     }      // 获取字符串类型数据     public Mono<String> getString(String key) {         return reactiveStringRedisTemplate.opsForValue().get(key);     }      // 设置带过期时间的字符串数据     public Mono<Boolean> setStringWithExpire(String key, String value, long timeout, TimeUnit unit) {         return reactiveStringRedisTemplate.opsForValue().set(key, value, timeout, unit);     }      // 删除数据     public Mono<Long> delete(String key) {         return reactiveStringRedisTemplate.delete(key);     } } 

在响应式操作中，每个方法返回的都是Mono类型，Mono表示一个包含0或1个元素的异步序列。当调用这些方法时，并不会立即执行Redis操作，而是返回一个操作的承诺，只有当订阅这个Mono时，操作才会真正执行。

（四）在Gateway过滤器中使用Redis

在Gateway中，经常需要在过滤器中使用Redis来实现一些功能，如限流、令牌验证等。下面以一个简单的令牌验证过滤器为例：

@Component public class TokenValidateFilter implements GlobalFilter, Ordered {      @Autowired     private ReactiveRedisService reactiveRedisService;      @Override     public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {         String token = exchange.getRequest().getHeaders().getFirst("token");         if (token == null || token.isEmpty()) {             exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);             return exchange.getResponse().setComplete();         }          return reactiveRedisService.getString("token:" + token)                 .flatMap(userId -> {                     if (userId != null) {                         // 令牌有效，继续执行后续过滤器                         return chain.filter(exchange);                     } else {                         exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);                         return exchange.getResponse().setComplete();                     }                 })                 .switchIfEmpty(Mono.defer(() -> {                     exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);                     return exchange.getResponse().setComplete();                 }));     }      @Override     public int getOrder() {         return -100;     } } 

在这个过滤器中，首先从请求头中获取令牌token，然后通过ReactiveRedisService从Redis中查询该令牌对应的用户ID。如果查询到结果，说明令牌有效，继续执行后续的过滤器；如果未查询到结果或令牌不存在，则返回未授权的响应。

这里充分利用了响应式编程的特性，通过flatMap、switchIfEmpty等操作符来处理异步流，保证了整个操作的异步非阻塞性。

四、两种场景下Redis使用的对比

（一）编程模型

基于Servlet的普通模块采用的是同步阻塞的编程模型，使用RedisTemplate进行Redis操作时，方法的调用会阻塞当前线程，直到操作完成。

基于WebFlux的Gateway采用的是异步非阻塞的编程模型，使用ReactiveRedisTemplate进行Redis操作时，方法返回Mono或Flux对象，不会阻塞线程，开发者通过订阅这些对象来处理操作结果。

（二）性能表现

在高并发场景下，基于WebFlux的Gateway使用响应式Redis客户端能够更高效地利用线程资源，减少线程切换的开销，从而表现出更好的性能。

而基于Servlet的普通模块由于采用同步阻塞的方式，在面对大量并发请求时，可能会因为线程阻塞而导致性能瓶颈。

（三）适用场景

基于Servlet的普通模块的Redis使用方式适用于业务逻辑相对复杂、对响应时间要求不是特别高的场景。

基于WebFlux的Gateway的Redis使用方式适用于高并发、I/O密集型的场景，如网关的限流、令牌验证等，能够更好地应对大量的并发请求。

五、总结

在微服务项目中，基于Servlet的普通模块和基于WebFlux的Gateway在使用Redis时，由于底层技术架构的不同，选择的Redis操作方式也有所差异。

普通模块通过Spring Data Redis的RedisTemplate进行同步操作，简单直观，适合处理复杂的业务逻辑；Gateway则通过spring-boot-starter-data-redis-reactive的ReactiveRedisTemplate进行异步非阻塞操作，能够更好地应对高并发场景。