攘老嚎悸在微服务架构的蓬勃发展浪潮中，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文件中引入相关依赖：
xml
org.springframework.boot
spring-boot-starter-data-redis
org.apache.commons
commons-pool2
其中，spring-boot-starter-data-redis是Spring Data Redis的 starter 依赖，commons-pool2为Redis连接池提供支持，有助于提高Redis连接的管理效率。
（二）配置Redis连接
在application.properties或application.yml中进行Redis连接信息的配置：
yaml
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的子类，专门用于处理键和值都是字符串的情况，使用起来更加便捷。
java
@Component
@RequiredArgsConstructor
public class RedisUtils {
private final RedisTemplate 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 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注解开启缓存功能：
java
@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层的方法上使用缓存注解：
java
@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的依赖：
xml
org.springframework.boot
spring-boot-starter-data-redis-reactive
org.apache.commons
commons-pool2
spring-boot-starter-data-redis-reactive提供了响应式的Redis操作支持，同样需要commons-pool2来支持连接池。
（二）配置Redis连接
与基于Servlet的模块类似，在application.yml中配置Redis连接信息：
yaml
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的响应式编程模型。
java
@Service
public class ReactiveRedisService {
@Autowired
private ReactiveStringRedisTemplate reactiveStringRedisTemplate;
// 设置字符串类型数据
public Mono setString(String key, String value) {
return reactiveStringRedisTemplate.opsForValue().set(key, value);
}
// 获取字符串类型数据
public Mono getString(String key) {
return reactiveStringRedisTemplate.opsForValue().get(key);
}
// 设置带过期时间的字符串数据
public Mono setStringWithExpire(String key, String value, long timeout, TimeUnit unit) {
return reactiveStringRedisTemplate.opsForValue().set(key, value, timeout, unit);
}
// 删除数据
public Mono delete(String key) {
return reactiveStringRedisTemplate.delete(key);
}
}
在响应式操作中，每个方法返回的都是Mono类型，Mono表示一个包含0或1个元素的异步序列。当调用这些方法时，并不会立即执行Redis操作，而是返回一个操作的承诺，只有当订阅这个Mono时，操作才会真正执行。
（四）在Gateway过滤器中使用Redis
在Gateway中，经常需要在过滤器中使用Redis来实现一些功能，如限流、令牌验证等。下面以一个简单的令牌验证过滤器为例：
java
@Component
public class TokenValidateFilter implements GlobalFilter, Ordered {
@Autowired
private ReactiveRedisService reactiveRedisService;
@Override
public Mono 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操作方式也有所差异。
扫一扫
8564
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
