消息系统.spring boot redis失效key监听

springboot,idea,jdk8

遇到一个需求,需要每周一向注册用户推送通知,注册用户参与的视频会议开始前60min,15min,5min给其发送通知.用户关注会议开始前5min推送,还有其他两种通知.用户在线,即时收到;用户不在线,登录时收到.

首先需要配置 websocket  ,网上有很多相关资料,这个我就不赘述了.接下来就要完成相关需求了.

第一反应是使用 定时器 ,只要在启动类上加

消息系统.spring boot redis失效key监听

然后创建文件

消息系统.spring boot redis失效key监听

就可解决.???发现自己想的有点多,因为通知类型多种,如果创建多个定时器感觉很繁琐,况且通知时间不固定,定时器就很难满足需求.( java.util 包下的 Timer类 也有类似功能).周期性的,时间固定的任务更适合使用定时器.比如需求中的每周一早上8点发送广播通知,这种比较适合使用定时器.


@Scheduled() 内的参数问题:

  @Scheduled(fixedRate = default -1L ),既 fixedRate = 2000,每两秒执行一次.

  @Scheduled(cron = default ""),corn的值可以自定义,其值有6个,使用空格隔开,按顺序依次为

      秒(0~59)
      分钟(0~59)
      小时(0~23)
      天(0~31)
      月(0~11)
      星期(1~7 1=SUN 或 SUN,MON,TUE,WED,THU,FRI,SAT)
      年份(1970-2099)

  其中年可以省略. 每个元素可以是一个值(如6),一个连续区间(9-12),一个间隔时间(8-18/4)(/表示每隔4小时),一个列表(1,3,5),通配符。由于"月份中的日期"和"星期中的日期"这两个元素互斥的,必须要对其中一个设置 ? .

  例如 corn = "0 0 8 ? * 6L"  表示每月的最后一个星期五上午8:00触发 .

有些表达式能包含一些范围或列表
       例如:子表达式(天(星期))可以为 “MON-FRI”,“MON,WED,FRI”,“MON-WED,SAT”
       “*”字符代表所有可能的值
       “/”字符用来指定数值的增量
       例如:在子表达式(分钟)里的“0/15”表示从第0分钟开始,每15分钟
                在子表达式(分钟)里的“3/20”表示从第3分钟开始,每20分钟(它和“3,23,43”)的含义一样
       “?”字符仅被用于天(月)和天(星期)两个子表达式,表示不指定值
       当2个子表达式其中之一被指定了值以后,为了避免冲突,需要将另一个子表达式的值设为“?”
       “L” 字符仅被用于天(月)和天(星期)两个子表达式,它是单词“last”的缩写
       如果在“L”前有具体的内容,它就具有其他的含义了。例如:“6L”表示这个月的倒数第6天
       注意:在使用“L”参数时,不要指定列表或范围,因为这会导致问题
       W 字符代表着平日(Mon-Fri),并且仅能用于日域中。它用来指定离指定日的最近的一个平日。大部分的商业处理都是基于工作周的,所以 W 字符可能是非常重要的。
       例如,日域中的 15W 意味着 "离该月15号的最近一个平日。" 假如15号是星期六,那么 trigger 会在14号(星期五)触发,因为星期四比星期一离15号更近。
       C:代表“Calendar”的意思。它的意思是计划所关联的日期,如果日期没有被关联,则相当于日历中所有日期。例如5C在日期字段中就相当于日历5日以后的第一天。1C在星期字段中相当于星期日后的第一天。
       字段   允许值   允许的特殊字符
       秒               0-59           , - * /
       分               0-59           , - * /
       小时           0-23           , - * /
       日期           1-31           , - * ? / L W C
       月份           1-12 或者 JAN-DEC           , - * /
       星期           1-7 或者 SUN-SAT           , - * ? / L C #
       年(可选)           留空, 1970-2099           , - * /


需求并未解决,上网查找,发现使用redis过期key监听可以很好地解决问题.订单过期自动取消,比如下单30分钟未支付自动更改订单状态这类问题也可以使用此方法.

pom文件中需要相关依赖消息系统.spring boot redis失效key监听

第一步:

首先在 redis.conf 配置文件里面找到 #  notify-keyspace-events Ex 打开注释,然后重启redis.一定要修改,不然配置无效,启动项目会报错.

第二步:

添加redis监听方法

/**
 * redis过期回调函数
 */
@Component
public class KeyExpiredListener extends KeyExpirationEventMessageListener {

    public KeyExpiredListener(RedisMessageListenerContainer listenerContainer) {
        super(listenerContainer);
    }

    @Override
    public void onMessage(Message message, byte[] pattern) {
        // message.toString()可以返回redis库中失效的 key
        // your code
    }
}

第三步:

添加redis监听配置

@Configuration
public class RedisConfiguration extends RedisMessageListenerContainer {

    @Autowired
    private RedisConnectionFactory redisConnectionFactory;

    @Bean
    public ChannelTopic expiredTopic() {
        return new ChannelTopic("[email protected]__:expired");  // 选择0号数据库
    }

    @Bean
    public RedisMessageListenerContainer redisMessageListenerContainer() {
        RedisMessageListenerContainer redisMessageListenerContainer = new RedisMessageListenerContainer();
        redisMessageListenerContainer.setConnectionFactory(redisConnectionFactory);
        return redisMessageListenerContainer;
    }

    @Bean
    public KeyExpiredListener keyExpiredListener() {
        return new KeyExpiredListener(this.redisMessageListenerContainer());
    }

就可以简单实现redis过期key的监听了.

这种方式需要部署的项目服务器上安装 redis ,不是很合适.而且把不同类型消息存入不同库中比较难做到.所以需要进一步的配置.举一个栗子:

首先是 application.yml 中 redis 的相关配置

 

消息系统.spring boot redis失效key监听

 

接下来同样是配置 redis 失效 key 的回调函数

public class KeyExpiredListener extends KeyExpirationEventMessageListener {

    public KeyExpiredListener(RedisMessageListenerContainer listenerContainer) {
        super(listenerContainer);
    }

    @Override
    public void onMessage(Message message, byte[] pattern) {
        // your code
    }
}

 

然后同样是配置 redis 配置文件

@Configuration
public class RedisConfiguration {

    @Bean
    @ConfigurationProperties(prefix = "spring.redis.lettuce.pool")
    @Scope(value = "prototype")
    public GenericObjectPoolConfig redisPool(){
        return new GenericObjectPoolConfig();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.redis.redis-a")
    public RedisStandaloneConfiguration redisConfigA(){
        return new RedisStandaloneConfiguration();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.redis.redis-b")
    public RedisStandaloneConfiguration redisConfigB(){
        return new RedisStandaloneConfiguration();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.redis.redis-c")
    public RedisStandaloneConfiguration redisConfigC(){
        return new RedisStandaloneConfiguration();
    }

    @Bean
    @Primary
    public LettuceConnectionFactory factoryA(GenericObjectPoolConfig config, RedisStandaloneConfiguration redisConfigA){
        LettuceClientConfiguration clientConfiguration = LettucePoolingClientConfiguration.builder()
                .poolConfig(config).commandTimeout(Duration.ofMillis(config.getMaxWaitMillis())).build();
        return new LettuceConnectionFactory(redisConfigA, clientConfiguration);
    }

    @Bean
    public LettuceConnectionFactory factoryB(GenericObjectPoolConfig config, RedisStandaloneConfiguration redisConfigB){
        LettuceClientConfiguration clientConfiguration = LettucePoolingClientConfiguration.builder()
                .poolConfig(config).commandTimeout(Duration.ofMillis(config.getMaxWaitMillis())).build();
        return new LettuceConnectionFactory(redisConfigB, clientConfiguration);
    }

    @Bean
    public LettuceConnectionFactory factoryC(GenericObjectPoolConfig config, RedisStandaloneConfiguration redisConfigC){
        LettuceClientConfiguration clientConfiguration = LettucePoolingClientConfiguration.builder()
                .poolConfig(config).commandTimeout(Duration.ofMillis(config.getMaxWaitMillis())).build();
        return new LettuceConnectionFactory(redisConfigC, clientConfiguration);
    }

    @Bean
    @Primary
    public StringRedisTemplate redisTemplateA(LettuceConnectionFactory factoryA){
        StringRedisTemplate template = getRedisTemplate();
        template.setConnectionFactory(factoryA);
        return template;
    }

    @Bean
    public StringRedisTemplate redisTemplateB(LettuceConnectionFactory factoryB){
        StringRedisTemplate template = getRedisTemplate();
        template.setConnectionFactory(factoryB);
        return template;
    }

    @Bean
    public StringRedisTemplate redisTemplateC(LettuceConnectionFactory factoryC){
        StringRedisTemplate template = getRedisTemplate();
        template.setConnectionFactory(factoryC);
        return template;
    }

    private StringRedisTemplate getRedisTemplate(){
        StringRedisTemplate template = new StringRedisTemplate();
        template.setValueSerializer(new GenericFastJsonRedisSerializer());
        template.setValueSerializer(new StringRedisSerializer());
        return template;
    }

    @Bean
    public ChannelTopic expiredTopic() {
        return new ChannelTopic("[email protected]__:expired");  // @0选择0号数据库
    }

    @Bean
    public RedisMessageListenerContainer redisMessageListenerContainer(LettuceConnectionFactory factoryA) {
        RedisMessageListenerContainer redisMessageListenerContainer = new RedisMessageListenerContainer();
        redisMessageListenerContainer.setConnectionFactory(factoryA);
        return redisMessageListenerContainer;
    }

    @Bean
    public KeyExpiredListener redisTimerListener(RedisMessageListenerContainer redisMessageListenerContainer) {
        KeyExpiredListener redisTimerListener = new KeyExpiredListener(redisMessageListenerContainer);
        return redisTimerListener;
    }
}

 

这样需求就很好的解决了.