为了方便开发，我打算实现一个Redis 工具集

代码库房

gitee: gitee.com/listen_w/re…
github: github.com/jettwangcj/…

前言

Redis 基本上是互联网公司必备的东西了，Redis的使用场景实在太多了，但是有很多相似的功用如果每个项目都要完成一遍就显得太麻烦了，所以为了便利，我计划开发一个根据 Redis 的东西集，尽量做到开箱即用。

目前完成功用

这个东西集并没有开发完成，完成了部分功用，如下图

• common : 整个项目公共模块，比方AOP东西等；
• delay: Redis完成的推迟行列；
• lock: Redis完成的分布式锁；
• mq: Redis完成音讯行列；
• query: Redis完成分页模糊查询；
• web: Redis完成web相关的功用；
  • duplicate ：避免重复提交；、

以上的这些模块都是现已完成的了，还有 社交、限流、幂等相关功用后边会连续完成。

怎么使用

1. 引入 Maven 依赖（目前可以下载代码上传到自己的私服或许本地库房，后边会推到 Maven 中心库房）

    <dependency>
           <groupId>cn.org.wangchangjiu</groupId>
           <artifactId>redis-util-spring-boot-starter</artifactId>
           <version>1.0.0-SNAPSHOT</version>
       </dependency>
   

2. 装备文件（application.yaml）敞开各模块功用开关

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

3. 完成音讯发送者

   • MQ音讯发送：

     

   • 推迟音讯发送：

     

4. 完成音讯监听器

   • MQ音讯监听器：

     

   • 推迟音讯监听器：

     

MQ和delay完成细节

MQ完成细节

容器启动时，简略来说便是经过springboot主动安装，创立一些Bean，如下图：

值得注意的是，springboot3.X 主动安装方法有点改变，需求创立文件 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件，文件内容就直接写 主动装备类

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

咱们以 RedisStreamAutoConfiguration 为例：

最首要的Bean有：

• RedisMessageConsumerManager：

  

  该Bean完成了 BeanPostProcessor 接口，首要作用是，获取被注解 RedisMessageListener 润饰的方法，把信息封装在 RedisMessageConsumerContainer 对象里，便利后边反射调用。

  

• StreamMessageListenerContainer：
  这个Bean首要是做 redis MQ 的装备，比方装备：一次最多获取多少条音讯、没有音讯时堵塞时间、执行任务的executor、错误处理器、以及消费组、是否主动ACK等装备，详细代码如下：

@Bean(initMethod = "start", destroyMethod = "stop")
@DependsOn("redisMessageConsumerManager")
@ConditionalOnMissingBean
public StreamMessageListenerContainer<String, MapRecord<String, String, String>> streamMessageListenerContainer(@Autowired RedisMessageConsumerManager redisMessageConsumerManager,
                                                                                                                @Autowired RedisConnectionFactory redisConnectionFactory,
                                                                                                                @Autowired ErrorHandler errorHandler) {
    MyRedisStreamProperties.Options options = myRedisStreamProperties.getOptions();
    StreamMessageListenerContainer.StreamMessageListenerContainerOptions<String, MapRecord<String, String, String>> containerOptions =
            StreamMessageListenerContainer.StreamMessageListenerContainerOptions
                    .builder()
                    // 一次最多获取多少条音讯
                    .batchSize(options.getBatchSize())
                    // 运转 Stream 的 poll task
                    .executor(getStreamMessageListenerExecutor())
                    // Stream 中没有音讯时，堵塞多长时间，需求比 `spring.redis.timeout` 的时间小
                    .pollTimeout(options.getPollTimeout())
                    // 获取音讯的进程或获取到音讯给详细的音讯者处理的进程中，发生了异常的处理
                    .errorHandler(errorHandler)
                    .build();
    StreamMessageListenerContainer<String, MapRecord<String, String, String>> streamMessageListenerContainer =
            StreamMessageListenerContainer.create(redisConnectionFactory, containerOptions);
    // 获取 被 RedisMessageListener 注解润饰的 bean
    Map<String, RedisMessageConsumerContainer> consumerContainerGroups =
            redisMessageConsumerManager.getConsumerContainerGroups();
    // 循环遍历，创立 消费组
    consumerContainerGroups.forEach((groupQueue, redisMessageConsumerContainer) -> {
        String[] groupQueues = groupQueue.split("#");
        // 创立消费组
        createGroups(groupQueues);
        RedisMessageListener redisMessageListener = redisMessageConsumerContainer.getRedisMessageListener();
        if(!redisMessageListener.useGroup()){
            // 独立消费 不使用组
            streamMessageListenerContainer.receive(StreamOffset.fromStart(groupQueues[1]), new DefaultGroupStreamListener(redisMessageConsumerContainer));
        } else {
            // 消费组 消费
            if(redisMessageListener.autoAck()){
                // 主动ACK
                streamMessageListenerContainer.receiveAutoAck(Consumer.from(groupQueues[0], "consumer:" + UUID.randomUUID()),
                        StreamOffset.create(groupQueues[1], ReadOffset.lastConsumed()), new DefaultGroupStreamListener(redisMessageConsumerContainer));
            } else {
                // 手动 ACK
                streamMessageListenerContainer.receive(Consumer.from(groupQueues[0], "consumer:" + UUID.randomUUID()),
                        StreamOffset.create(groupQueues[1], ReadOffset.lastConsumed()), new DefaultGroupStreamListener(redisMessageConsumerContainer));
            }
        }
    });
    return streamMessageListenerContainer;
}
/**
 *  创立消费组
 * @param groupQueues
 */
private void createGroups(String[] groupQueues) {
    // 判断是否存在行列Key
    if (stringRedisTemplate.hasKey(groupQueues[1])) {
        // 获取消费组 没有则创立
        StreamInfo.XInfoGroups groups = stringRedisTemplate.opsForStream().groups(groupQueues[1]);
        if (groups.isEmpty()) {
            stringRedisTemplate.opsForStream().createGroup(groupQueues[1], groupQueues[0]);
        } else {
            AtomicBoolean exists= new AtomicBoolean(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 后边这个线程池也可以交由用户装备
private Executor getStreamMessageListenerExecutor() {
    AtomicInteger index = new AtomicInteger(1);
    int processors = Runtime.getRuntime().availableProcessors();
    ThreadPoolExecutor executor = new ThreadPoolExecutor(processors, processors, 0, TimeUnit.SECONDS,
            new LinkedBlockingDeque<>(), r -> {
        Thread thread = new Thread(r);
        thread.setName("async-stream-consumer-" + index.getAndIncrement());
        thread.setDaemon(true);
        return thread;
    });
    return executor;
}

发送音讯流程：

redis 推迟行列的完成原理和这个差不多，首要是 redission推迟行列 + 自定义注解 + 反射，代码都差不多，我之前写过一篇根据 redission + kafka的推迟行列完成方法类似，只是把kafka那部分除去了，详细可以看那篇博文，地址： 根据 Redisson 和 Kafka 的推迟行列设计方案

跋文

其他模块的设计细节后边再说，欢迎我们使用，也请我们多多提建议以及好的功用点，我都可以整合上去。