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

👉 这是一个或许对你有用的社群

🐱 一对一交流/面试小册/简历优化/求职解惑，欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料： 

• 《项目实战（视频）》：从书中学，往事上“练”

• 《互联网高频面试题》：面朝简历学习，春暖花开

• 《架构 x 系统设计》：摧枯拉朽，掌控面试高频场景题

• 《精进 Java 学习指南》：系统学习，互联网主流技术栈

• 《必读 Java 源码专栏》：知其然，知其所以然

👉这是一个或许对你有用的开源项目

国产 Star 破 10w+ 的开源项目，前端包括管理后台 + 微信小程序，后端支持单体和微服务架构。

功能涵盖 RBAC 权限、SaaS 多租户、数据权限、商城、支付、工作流、大屏报表、微信公众号等等功能：

• Boot 地址：https://gitee.com/zhijiantianya/ruoyi-vue-pro

• Cloud 地址：https://gitee.com/zhijiantianya/yudao-cloud

• 视频教程：https://doc.iocoder.cn

来源：juejin.cn/post/
7254574621898686521

• 1 前言

• 2 目前实现功能

• 3 如何使用

• 4 MQ和delay实现细节

• 5 工具地址

---

1 前言

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

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

• 项目地址：https://github.com/YunaiV/ruoyi-vue-pro

• 视频教程：https://doc.iocoder.cn/video/

2 目前实现功能

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

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

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

• delay: Redis实现的延迟队列；

• lock: Redis实现的分布式锁；

• mq: Redis实现消息队列；

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

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

  • duplicate ：防止重复提交；

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

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

• 项目地址：https://github.com/YunaiV/yudao-cloud

• 视频教程：https://doc.iocoder.cn/video/

3 如何使用

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消息监听器：

延迟消息监听器：

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
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延迟队列 + 自定义注解 + 反射，代码都差不多。

5 工具地址

https://gitee.com/listen_w/redis-util-spring-boot-starter

https://github.com/jettwangcj/redis-util-spring-boot-starter

---

欢迎加入我的知识星球，全面提升技术能力。

👉 加入方式，“长按”或“扫描”下方二维码噢：

星球的内容包括：项目实战、面试招聘、源码解析、学习路线。

文章有帮助的话，在看，转发吧。
谢谢支持哟 (*^__^*）