redis值过期监听

misaki乀

已于 2023-09-14 09:45:02 修改

阅读量504

点赞数

文章标签： redis java 前端

于 2023-08-04 13:37:07 首次发布

本文链接：https://blog.csdn.net/weixin_53472539/article/details/132102467

版权

<dependency>
   <groupId>org.redisson</groupId>
   <artifactId>redisson-spring-boot-starter</artifactId>
   <version>3.13.6</version>
</dependency>

1.创建监听类

package com.moc.common.utils.util;

import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.connection.MessageListener;
import org.springframework.data.redis.listener.KeyExpirationEventMessageListener;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class RedisKeyExpirationListener implements MessageListener {

    /**
     * 针对redis数据失效事件，进行数据处理
     * @param message
     * @param pattern
     */
    @Override
    public void onMessage(Message message, byte[] pattern) {
            String key = message.toString();
//        System.out.println(key+"111111111");
    }
}

1.在RedisUtils类里面添加初始方法

@Bean
    RedisMessageListenerContainer  container(RedisConnectionFactory connectionFactory,
                                             RedisKeyExpirationListener redisKeyExpirationListener) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.addMessageListener(redisKeyExpirationListener,new PatternTopic("__keyevent@0__:expired"));
        return container;
    }

redis集群版监听：

1.配置文件

redis:
      # 地址
      # host: 128.168.11.93
      # 端口，默认为6379
      # port: 6379
      # 数据库索引
    database: 0
    cluster:
      nodes: 128.168.11.111:6379,128.168.11.112:6379,128.168.11.113:6379,128.168.11.111:6380,128.168.11.112:6380,128.168.11.113:6380
    # 密码
    password:
    # 连接超时时间
    timeout: 10s
    lettuce:
      pool:
        # 连接池中的最小空闲连接
        min-idle: 0
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池的最大数据库连接数
        max-active: 8
        # #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1ms

2.创建spring工具类

package com.example.socket_test.util;

import org.springframework.aop.framework.AopContext;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

/**
 * spring工具类 方便在非spring管理环境中获取bean
 * 
 * @author ruoyi
 */
@Component
public final class SpringUtils implements BeanFactoryPostProcessor, ApplicationContextAware 
{
    /** Spring应用上下文环境 */
    private static ConfigurableListableBeanFactory beanFactory;

    private static ApplicationContext applicationContext;

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException 
    {
        SpringUtils.beanFactory = beanFactory;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException 
    {
        SpringUtils.applicationContext = applicationContext;
    }

    /**
     * 获取对象
     *
     * @param name
     * @return Object 一个以所给名字注册的bean的实例
     * @throws BeansException
     *
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) throws BeansException
    {
        return (T) beanFactory.getBean(name);
    }

    /**
     * 获取类型为requiredType的对象
     *
     * @param clz
     * @return
     * @throws BeansException
     *
     */
    public static <T> T getBean(Class<T> clz) throws BeansException
    {
        T result = (T) beanFactory.getBean(clz);
        return result;
    }

    /**
     * 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
     *
     * @param name
     * @return boolean
     */
    public static boolean containsBean(String name)
    {
        return beanFactory.containsBean(name);
    }

    /**
     * 判断以给定名字注册的bean定义是一个singleton还是一个prototype。 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
     *
     * @param name
     * @return boolean
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.isSingleton(name);
    }

    /**
     * @param name
     * @return Class 注册对象的类型
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static Class<?> getType(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.getType(name);
    }

    /**
     * 如果给定的bean名字在bean定义中有别名，则返回这些别名
     *
     * @param name
     * @return
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static String[] getAliases(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.getAliases(name);
    }

    /**
     * 获取aop代理对象
     * 
     * @param invoker
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T getAopProxy(T invoker)
    {
        return (T) AopContext.currentProxy();
    }

    /**
     * 获取当前的环境配置，无配置返回null
     *
     * @return 当前的环境配置
     */
    public static String[] getActiveProfiles()
    {
        return applicationContext.getEnvironment().getActiveProfiles();
    }

    /**
     * 获取当前的环境配置，当有多个环境配置时，只获取第一个
     *
     * @return 当前的环境配置
     */
    public static String getActiveProfile()
    {
        final String[] activeProfiles = getActiveProfiles();
        return StringKit.isNotEmpty(activeProfiles) ? activeProfiles[0] : null;
    }

    /**
     * 获取配置文件中的值
     *
     * @param key 配置文件的key
     * @return 当前的配置文件的值
     *
     */
    public static String getRequiredProperty(String key)
    {
        return applicationContext.getEnvironment().getRequiredProperty(key);
    }
}

3.创建监听类

package com.moc.common.utils.util;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.connection.MessageListener;
import org.springframework.data.redis.listener.KeyExpirationEventMessageListener;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;

import javax.annotation.Resource;

@Slf4j
public class ExpirationListener extends  KeyExpirationEventMessageListener   {

    @Resource
    private RedisUtils redisUtils;

    /**
     * Creates new {@link MessageListener} for {@code __keyevent@*__:expired} messages.
     *
     * @param listenerContainer must not be {@literal null}.
     */
    public ExpirationListener(RedisMessageListenerContainer listenerContainer) {
        super(listenerContainer);
    }

    /**
     * 针对redis数据失效事件，进行数据处理
     * @param message
     * @param pattern
     */
    @Override
    public void onMessage(Message message, byte[] pattern) {
        System.out.println(message);
    }
}

4.连接redis集群并监听

package com.example.socket_test.util;

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import redis.clients.jedis.JedisPoolConfig;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@Configuration
public class RedissonConfig {
    @Value("${spring.redis.cluster.nodes}")
    private String nodes;

//    @Value("${spring.redis.host}")
//    private String host;
//
//    @Value("${spring.redis.port}")
//    private String port;

//    @Value("${spring.redis.password}")
//    private String password;

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        List<String> addresses = new ArrayList<String>();
        if (!nodes.contains(",")) {
            addresses.add(nodes);
        } else {
            String[] a = nodes.split(",");
            addresses.addAll(Arrays.asList(a));
        }
        String[] newAddresses = new String[addresses.size()];
        for (int a = 0; a < addresses.size(); a++) {
            String addr = "redis://" + addresses.get(a);
            newAddresses[a] = addr;
        }
        config.useClusterServers().addNodeAddress(newAddresses); // 分片集群方式
        config.setLockWatchdogTimeout(5 * 1000L);

//        SingleServerConfig server = config.useSingleServer();
//        server.setAddress("redis://" + host + ":" + port);
//        server.setPassword(password);
        return Redisson.create(config);
    }

    @Bean
    JedisPoolConfig jedisPoolConfig(){
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(100);
        jedisPoolConfig.setMaxWaitMillis(1000);
        return jedisPoolConfig;
    }

    @Bean
    RedisMessageListenerContainer redisContainer1() {
        String[] split = nodes.split(",")[0].split(":");
        final RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
        jedisConnectionFactory.setHostName(split[0]);
        jedisConnectionFactory.setPort(Integer.valueOf(split[1]));
        jedisConnectionFactory.setPoolConfig(jedisPoolConfig());
        jedisConnectionFactory.afterPropertiesSet();
        container.setConnectionFactory(jedisConnectionFactory);
        return container;
    }

    @Bean
    ExpirationListener redisKeyExpirationListener1() {
        RedisMessageListenerContainer redisContainer= SpringUtils.getBean("redisContainer1");
        return new ExpirationListener(redisContainer);
    }

    @Bean
    RedisMessageListenerContainer redisContainer2() {
        String[] split = nodes.split(",")[1].split(":");
        final RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
        jedisConnectionFactory.setHostName(split[0]);
        jedisConnectionFactory.setPort(Integer.valueOf(split[1]));
        jedisConnectionFactory.setPoolConfig(jedisPoolConfig());
        jedisConnectionFactory.afterPropertiesSet();
        container.setConnectionFactory(jedisConnectionFactory);
        return container;
    }

    @Bean
    ExpirationListener redisKeyExpirationListener2() {
        RedisMessageListenerContainer redisContainer=SpringUtils.getBean("redisContainer2");
        return new ExpirationListener(redisContainer);
    }


    @Bean
    RedisMessageListenerContainer redisContainer3() {
        String[] split = nodes.split(",")[2].split(":");
        final RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
        jedisConnectionFactory.setHostName(split[0]);
        jedisConnectionFactory.setPort(Integer.valueOf(split[1]));
        jedisConnectionFactory.setPoolConfig(jedisPoolConfig());
        jedisConnectionFactory.afterPropertiesSet();
        container.setConnectionFactory(jedisConnectionFactory);
        return container;
    }

    @Bean
    ExpirationListener redisKeyExpirationListener3() {
        RedisMessageListenerContainer redisContainer=SpringUtils.getBean("redisContainer3");
        return new ExpirationListener(redisContainer);
    }


    @Bean
    RedisMessageListenerContainer redisContainer4() {
        String[] split = nodes.split(",")[3].split(":");
        final RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
        jedisConnectionFactory.setHostName(split[0]);
        jedisConnectionFactory.setPort(Integer.valueOf(split[1]));
        jedisConnectionFactory.setPoolConfig(jedisPoolConfig());
        jedisConnectionFactory.afterPropertiesSet();
        container.setConnectionFactory(jedisConnectionFactory);
        return container;
    }

    @Bean
    ExpirationListener redisKeyExpirationListener4() {
        RedisMessageListenerContainer redisContainer=SpringUtils.getBean("redisContainer4");
        return new ExpirationListener(redisContainer);
    }

    @Bean
    RedisMessageListenerContainer redisContainer5() {
        String[] split = nodes.split(",")[4].split(":");
        final RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
        jedisConnectionFactory.setHostName(split[0]);
        jedisConnectionFactory.setPort(Integer.valueOf(split[1]));
        jedisConnectionFactory.setPoolConfig(jedisPoolConfig());
        jedisConnectionFactory.afterPropertiesSet();
        container.setConnectionFactory(jedisConnectionFactory);
        return container;
    }

    @Bean
    ExpirationListener redisKeyExpirationListener5() {
        RedisMessageListenerContainer redisContainer=SpringUtils.getBean("redisContainer5");
        return new ExpirationListener(redisContainer);
    }

    @Bean
    RedisMessageListenerContainer redisContainer6() {
        String[] split = nodes.split(",")[5].split(":");
        final RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
        jedisConnectionFactory.setHostName(split[0]);
        jedisConnectionFactory.setPort(Integer.valueOf(split[1]));
        jedisConnectionFactory.setPoolConfig(jedisPoolConfig());
        jedisConnectionFactory.afterPropertiesSet();
        container.setConnectionFactory(jedisConnectionFactory);
        return container;
    }

    @Bean
    ExpirationListener redisKeyExpirationListener6() {
        RedisMessageListenerContainer redisContainer=SpringUtils.getBean("redisContainer6");
        return new ExpirationListener(redisContainer);
    }
}