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

最新推荐文章于 2024-09-18 18:01:56 发布
最新推荐文章于 2024-09-18 18:01:56 发布
阅读量2.3k 收藏 3
点赞数
分类专栏： Spring Redis

springboot,idea,jdk8

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

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

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

然后创建文件

就可解决.???发现自己想的有点多,因为通知类型多种,如果创建多个定时器感觉很繁琐,况且通知时间不固定,定时器就很难满足需求.( 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”表示这个月的倒数第６天
       注意：在使用“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文件中需要相关依赖

第一步:

首先在 redis安装包下 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("__keyevent@0__: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 的相关配置

 

接下来配置 redis-a 失效 key 的回调函数

public class KeyExpiredListenerA extends KeyExpirationEventMessageListener {

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

    @Override
    public void onMessage(Message message, byte[] pattern) {
        System.out.println(message.toString() + "过期了........................................");
    }
}

 

再配置redis-b 失效key的回调函数

public class KeyExpiredListenerB extends KeyExpirationEventMessageListener {
    public KeyExpiredListenerB(RedisMessageListenerContainer listenerContainer) {
        super(listenerContainer);
    }

    @Override
    public void onMessage(Message message, byte[] pattern) {
        System.out.println(message.toString() + "过期了........................................");
    }
}

 

然后配置 redis 配置文件

@Configuration
public class RedisConfiguration {

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

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

    // a redis连接
    @Bean
    @Primary
    public JedisConnectionFactory getJedisConnectionFactoryA() {
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(redisConfigA());
        return jedisConnectionFactory;
    }

    // a redis监听
    @Bean
    @Primary
    public RedisMessageListenerContainer redisMessageListenerContainerA() {
        RedisMessageListenerContainer redisMessageListenerContainer = new RedisMessageListenerContainer();
        redisMessageListenerContainer.setConnectionFactory(getJedisConnectionFactoryA());
        return redisMessageListenerContainer;
    }

    // a redis监听回调函数注入
    @Bean
    public KeyExpiredListenerA redisTimerListenerA() {
        KeyExpiredListenerA KeyExpiredListenerA = new KeyExpiredListenerA(redisMessageListenerContainerA());
        return KeyExpiredListenerA;
    }

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

    // b redis连接
    @Bean
    public JedisConnectionFactory getJedisConnectionFactoryB() {
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(redisConfigB());
        return jedisConnectionFactory;
    }

    // b redis监听
    @Bean
    public RedisMessageListenerContainer redisMessageListenerContainerB() {
        RedisMessageListenerContainer redisMessageListenerContainer = new RedisMessageListenerContainer();
        redisMessageListenerContainer.setConnectionFactory(getJedisConnectionFactoryB());
        return redisMessageListenerContainer;
    }

    // b redis监听回调函数注入
    @Bean
    public KeyExpiredListenerB redisTimerListenerB() {
        KeyExpiredListenerB KeyExpiredListenerB = new KeyExpiredListenerB(redisMessageListenerContainerB());
        return KeyExpiredListenerB;
    }

    // a 连接 RedisTemplate 配置
    @Bean
    public RedisTemplate<String, Object> redisTemplateA() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(getJedisConnectionFactoryA());
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }

    // b 连接RedisTemplate
    @Bean
    public RedisTemplate<String, Object> redisTemplateB() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(getJedisConnectionFactoryB());
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }

//    // 监听数据库?此时监听所有
//    @Bean
//    public ChannelTopic expiredTopic() {
//        return new ChannelTopic("__keyevent@0__:expired");
//    }
}

 

接口测试文件

@RestController
@RequestMapping(value = "ce")
public class RedisListenerTest {

    @Autowired
    @Resource(name = "redisTemplateA")  // 选择需要的RedisTemplate,此处与redis配置文件中的相对应
    private RedisTemplate redisTemplateA;

    @Autowired
    @Resource(name = "redisTemplateB")
    private RedisTemplate redisTemplateB;


    @GetMapping(value = "shi")
    public void ceShi() {
        // 向 a redis库添加
        redisTemplateA.opsForValue().set("a号数据库", "1", 5, TimeUnit.SECONDS);
        // 向 b redis 库添加
        redisTemplateB.opsForValue().set("b号数据库", "1", 5, TimeUnit.SECONDS);
    }
}

执行测试文件5秒后

 

做这个需求的时候看到了kafka,JMS相关,需要继续学习

MR_L_0927
关注
专栏目录
springboot整合redis+连接池+配置redis key过期事件监听 demo代码
闲走天涯的博客
08-09 576
一、pom文件引入依赖和application.yml文件配置 1.pom文件引入依赖 <!-- 阿里fastjson 依赖-> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.31</version>
springBoot 项目spring -data-redis监听key过期事件
m0_57891856的博客
06-11 857
springDataRedis 监听
SpringBoot中监听redis失效key
Crisf的博客
05-21 808
需求 在线考试的一个交卷功能（商城的超时未支付订单也类似，不同之处在于商城的处理比较简单，失效就可以了，考试功能还需要在key失效后取回value做业务处理），用户整个答题流程中产生的数据存在redis中，当用户点交卷时，从redis中取出数据，做后续的评分、统计、存数据库等处理。如果用户未答完就非正常退出，要在到达考试结束时间时清除掉redis里面的数据，并执行后续的评分等操作。 处理方式 方式一：（本文采用的方式） redis中对每次考试存两份数据（key1根据考试时长设定失效时间，key2永久
redis监听key过期
最新发布
HongRi_的博客
09-18 550
【代码】Redis监听key过期。
Spring boot Redis 失效监听 记录
何xiao树
11-29 430
超时监听： 开启，键事件通知（key-event notification），在key失效时，会发布事件； 开启配置： 注意： 因为你 reids 失效的key 有很多，最好把需要监听的 key 放在指定的 db里，监听那个db，最业务处理。 import org.springframework.data.redis.connection.Message; import org.spring...
springBoot监听redis失效key事件
zwrlj527的专栏
03-28 6844
序： 这次遇到的场景是需要对redis的失效key做比对判断，增加电业务逻辑。 废话不多说，直接说重点，我也赶着回家呢。 redis配置文件修改，我是win系统。这个是对redis版本有要求的，所以先查看版本信息。 查看redis版本信息，redis安装目录下，黑框框（你懂的）下运行redis-cli.exe，然后再输入info 这个实...
Spring boot 实现监听 Redis key 失效事件
Young Lee
02-19 2714
方式一：修改配置文件方式二：命令行开启。
spring boot+redis 监听过期Key的操作方法
08-18
使用 Spring Boot 和 Redis 监听过期 Key 需要引入依赖，修改 Boot 的 Redis 配置，修改 Redis 配置文件，并创建一个 Redis 监控类。 引入依赖 需要引入 Spring Boot 的 Redis 依赖： ```xml <groupId>org....
一看就懂！Springboot和Spring整合Redis 监听KEY失效事件
大誌的博客
07-10 4050
redis 监听key失效回调事件是一个非常有用的监听事件。本文就来快速实现一下。下面将会介绍两种版本，一种是Springboot的版本，另一种是Spring的版本。
java如何判断redis的key过期_spring boot+redis 监听过期Key的操作方法
weixin_39991222的博客
03-02 3381
前言：在订单业务中，有时候需要对订单设置有效期，有效期到了后如果还未支付，就需要修改订单状态。对于这种业务的实现，有多种不同的办法，比如：1、使用querytz，每次生成一个订单，就创建一个定时任务，到期后执行业务代码；2、rabbitMq中的延迟队列；3、对Redis的Key进行监控；1、引入依赖org.springframework.bootspring-boot-starter-data-r...
spring boot 集成redis监听Key值事件失效
xuejue8260的博客
05-16 2108
有时需要监听Redis的事件从而在Redis事件发生时添加一些后续操作；在实际开发过程中，有这么一个需求，监听Redis中的键状态，从而去更改程序中数据的状态；实现方法如下： 方法一: 实现redis提供的MessageListener接口 首先开启Redis的监听事件，大约在Redis配置文件的889行，或者直接搜索notify-keyspace-events，将其更改为你需要监听的类型 ...
SpringBoot集成Redis过期时间监听事件失效
qq_43090226的博客
08-28 757
前几天，在给公司测试环境部署新项目时，出现了一个问题。有一个“订单三十分钟未支付自动取消”的业务，用到了Redis的过期时间监听事件的技术。但是项目成功启动，创建完订单时，过了三十分钟，订单却迟迟没有取消。我们的开发人员在监听事件代码中打log，也一直没有看到日志。浏览了一些文章，终于解决了这个问题，做一下记录。
SpringBoot实现监听Redis key失效事件
专业的计算机毕业设计指南
04-23 993
1.需求 处理订单过期自动取消，比如下单30分钟未支付自动更改订单状态 2.方案 可以利用redis天然的key自动过期机制，下单时将订单id写入redis，过期时间30分钟，30分钟后检查订单状态，如果未支付，则进行处理但是key过期了redis有通知吗？答案是肯定的。 3.试验步骤 3.1.开启redis key过期提醒 修改redis相关事件配置。找到redis配置文件redis.conf，...
Redis事件通知（keyspace notification）
04-05 552
Keyspace 通知使得客户端可以通过订阅频道或模式，来接收那些以某种方式改动了 Redis 数据集的事件（触发某些事件后可以向指定的频道发送通知），该功能需要 Redis 版本大于 2.8。 事件通过 Redis 的订阅与发布功能（pub/sub）来进行分发，因此所有支持订阅与发布功能的客户端都可以在无须做任何修改的情况下，直接使用此功能。 因为 Redis 目前的订阅与发布...
spring data redis key失效监听
点滴记录
08-10 413
@Configuration public class RedisListenerConfig { @Bean RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory) { RedisMessageListenerContainer container = new RedisMessageListenerContainer(); container.s.
spring boot整合Redis监听数据变化
小小白的博客
04-12 2174
介绍了spring boot实现监听redis数据变化的方案
SpringBoot配置redis以及设置监听
工作随记
09-12 2182
SpringBoot配置redis以及设置监听
redis的监听实现及遇到的问题(监听失效)
qiaosaifei的博客
08-25 5453
需求:监听redis的新增(set)方法,新增时将数据同步到内存中. 1,添加redis依赖(忽略); 2,创建监听类实现MessageListener,并重写onMessage方法. public class MobileRedisMessageListener implements MessageListener { @Autowired private StringRedisTemplate redisTemplate; @Override public
java redis监听问题_springboot+redis过期事件监听实现过程解析
weixin_39923806的博客
02-13 397
1 修改 redis.conf配置文件：K Keyspace events, published with keyspace@ prefix事件E Keyevent events, published with keyevent@ prefixg Generic commands (non-type specific) like DEL, EXPIRE, RENAME, …$ String com...
Spring Boot + Redis 实现过期Key监听：实战教程与配置详解
为了监听过期Key，需要修改Redis服务器的配置文件`redis.conf`，增加`notify-keyspace-events Ex`参数，这将启用键空间事件通知，仅监听键的过期事件。 接下来，创建一个专门用于处理过期Key的监控类，这个类需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值