Redis工具集的实现和使用

1 前言

Redis 基本上是互联网公司必备的工具了，Redis的应用场景实在太多了，但是有很多相似的功能如果每个项目都要实现一遍就显得太麻烦了，所以为了方便，我打算开发一个基于 Redis 的工具集，尽量做到开箱即用。

2 目前实现功能

这个工具集并没有开发完成，实现了部分功能，如下图

简单介绍下已经实现的模块：

common : 整个项目公共模块，比如AOP工具等；

delay: Redis实现的延迟队列；

lock: Redis实现的分布式锁；

mq: Redis实现消息队列；

query: Redis实现分页模糊查询；

web: Redis实现web相关的功能；

duplicate ：防止重复提交；

以上的这些模块都是已经实现的了，还有 社交、限流、幂等相关功能后面会陆续实现。

3 如何使用

1.引入 Maven 依赖

目前可以下载代码上传到自己的私服或者本地仓库，后面会推到 Maven 中央仓库

cn.org.wangchangjiu
redis-util-spring-boot-starter
1.0.0-SNAPSHOT

2.配置文件（application.yaml）开启各模块功能开关

redis:
util:
mq:
enable:true
delay:
enable:true

3.实现消息发送者

MQ消息发送：

延迟消息发送：

4.实现消息监听器

MQ消息监听器：

延迟消息监听器：

4 MQ和delay实现细节

MQ实现细节

容器启动时，简单来说就是通过springboot自动装配，创建一些Bean，如下图：

值得注意的是，springboot3.X 自动装配方式有点变化，需要创建文件 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件，文件内容就直接写 自动配置类

RedisUtilAutoConfiguration 主自动装配类会 import 各个模块的自动装配类：

我们以 RedisStreamAutoConfiguration 为例：

该装配类生效需要显示打开，然后就是创建各种Bean。

最主要的Bean有：

RedisMessageConsumerManager：

该Bean实现了 BeanPostProcessor 接口，主要作用是，获取被注解 RedisMessageListener 修饰的方法，把信息封装在 RedisMessageConsumerContainer 对象里，方便后面反射调用。

StreamMessageListenerContainer：

这个Bean主要是做 redis MQ 的配置，比如配置：一次最多获取多少条消息、没有消息时阻塞时间、执行任务的executor、错误处理器、以及消费组、是否自动ACK等配置，具体代码如下：

@Bean(initMethod="start",destroyMethod="stop")
@DependsOn("redisMessageConsumerManager")
@ConditionalOnMissingBean
publicStreamMessageListenerContainer>streamMessageListenerContainer(@AutowiredRedisMessageConsumerManagerredisMessageConsumerManager,
@AutowiredRedisConnectionFactoryredisConnectionFactory,
@AutowiredErrorHandlererrorHandler){
MyRedisStreamProperties.Optionsoptions=myRedisStreamProperties.getOptions();
StreamMessageListenerContainer.StreamMessageListenerContainerOptions>containerOptions=
StreamMessageListenerContainer.StreamMessageListenerContainerOptions
.builder()
//一次最多获取多少条消息
.batchSize(options.getBatchSize())
//运行Stream的polltask
.executor(getStreamMessageListenerExecutor())
//Stream中没有消息时，阻塞多长时间，需要比`spring.redis.timeout`的时间小
.pollTimeout(options.getPollTimeout())
//获取消息的过程或获取到消息给具体的消息者处理的过程中，发生了异常的处理
.errorHandler(errorHandler)
.build();

StreamMessageListenerContainer>streamMessageListenerContainer=
StreamMessageListenerContainer.create(redisConnectionFactory,containerOptions);

//获取被RedisMessageListener注解修饰的bean
MapconsumerContainerGroups=
redisMessageConsumerManager.getConsumerContainerGroups();

//循环遍历，创建消费组
consumerContainerGroups.forEach((groupQueue,redisMessageConsumerContainer)->{
String[]groupQueues=groupQueue.split("#");

//创建消费组
createGroups(groupQueues);

RedisMessageListenerredisMessageListener=redisMessageConsumerContainer.getRedisMessageListener();
if(!redisMessageListener.useGroup()){
//独立消费不使用组
streamMessageListenerContainer.receive(StreamOffset.fromStart(groupQueues[1]),newDefaultGroupStreamListener(redisMessageConsumerContainer));
}else{
//消费组消费
if(redisMessageListener.autoAck()){
//自动ACK
streamMessageListenerContainer.receiveAutoAck(Consumer.from(groupQueues[0],"consumer:"+UUID.randomUUID()),
StreamOffset.create(groupQueues[1],ReadOffset.lastConsumed()),newDefaultGroupStreamListener(redisMessageConsumerContainer));
}else{
//手动ACK
streamMessageListenerContainer.receive(Consumer.from(groupQueues[0],"consumer:"+UUID.randomUUID()),
StreamOffset.create(groupQueues[1],ReadOffset.lastConsumed()),newDefaultGroupStreamListener(redisMessageConsumerContainer));
}
}
});
returnstreamMessageListenerContainer;
}

/**
*创建消费组
*@paramgroupQueues
*/
privatevoidcreateGroups(String[]groupQueues){
//判断是否存在队列Key
if(stringRedisTemplate.hasKey(groupQueues[1])){
//获取消费组没有则创建
StreamInfo.XInfoGroupsgroups=stringRedisTemplate.opsForStream().groups(groupQueues[1]);
if(groups.isEmpty()){
stringRedisTemplate.opsForStream().createGroup(groupQueues[1],groupQueues[0]);
}else{
AtomicBooleanexists=newAtomicBoolean(false);
groups.forEach(xInfoGroup->{
if(xInfoGroup.groupName().equals(groupQueues[0])){
exists.set(true);
}
});
if(!exists.get()){
stringRedisTemplate.opsForStream().createGroup(groupQueues[1],groupQueues[0]);
}
}
}else{
stringRedisTemplate.opsForStream().createGroup(groupQueues[1],groupQueues[0]);
}
}

//todo后面这个线程池也可以交由用户配置
privateExecutorgetStreamMessageListenerExecutor(){
AtomicIntegerindex=newAtomicInteger(1);
intprocessors=Runtime.getRuntime().availableProcessors();
ThreadPoolExecutorexecutor=newThreadPoolExecutor(processors,processors,0,TimeUnit.SECONDS,
newLinkedBlockingDeque<>(),r->{
Threadthread=newThread(r);
thread.setName("async-stream-consumer-"+index.getAndIncrement());
thread.setDaemon(true);
returnthread;
});
returnexecutor;
}

发送消息流程：

redis 延迟队列的实现原理和这个差不多，主要是 redission延迟队列 + 自定义注解 + 反射，代码都差不多。

审核编辑：汤梓红