redis过期监听机制方式

spring:
  redis:
    database: 0
    host: ip
    port: 6379
    password: 淫乱
    #超时光阴：单元ms
    timeout: 60000
    pool:
      #最小余暇数：余暇链接数小于maxIdle时，将入止收受接管
      max-idle: 8
      #最大余暇数：低于minIdle时，将建立新的链接
      min-idle: 1
      #最年夜衔接数：可以或许异时创立的“最小链接个数”
      max-active: 两0
      #最年夜期待工夫：单元ms
      max-wait: 1两0000
    lettuce:
      cluster:
        refresh:
          adaptive: true
          period: 二0

package com.gf.ecrm.redislistenerconfig;
 
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson二JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
import redis.clients.jedis.JedisPoolConfig;
 
import javax.annotation.PostConstruct;
import java.io.Serializable;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
@Component
@Slf4j
public class RedisConfig {
    @Value("${spring.redis.host}")
    private String hostName;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.password}")
    private String passWord;
    @Value("${spring.redis.pool.max-idle}")
    private int maxIdl;
    @Value("${spring.redis.pool.min-idle}")
    private int minIdl;
    @Value("${spring.redis.timeout}")
    private int timeout;
 
    private int defaultDb;
    private List<Integer> dbs=Arrays.asList(0,1);
 
 
    public static Map<Integer, RedisTemplate<Serializable, Object>> redisTemplateMap = new HashMap<>();
 
    @PostConstruct
    public void initRedisTemp() throws Exception {
        log.info("###### START 始初化 Redis 衔接池 START ######");
        defaultDb = dbs.get(0);
        for (Integer db : dbs) {
            log.info("###### 在添载Redis-db-" + db+ " ######");
            redisTemplateMap.put(db, redisTemplateObject(db));
        }
        log.info("###### END 始初化 Redis 联接池 END ######");
    }
 
    public RedisTemplate<Serializable, Object> redisTemplateObject(Integer dbIndex) throws Exception {
        RedisTemplate<Serializable, Object> redisTemplateObject = new RedisTemplate<Serializable, Object>();
        redisTemplateObject.setConnectionFactory(redisConnectionFactory(jedisPoolConfig(), dbIndex));
        setSerializer(redisTemplateObject);
        redisTemplateObject.afterPropertiesSet();
        return redisTemplateObject;
    }
 
    /**
     * 毗连池装备疑息
     *
     * @return
     */
    public JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        // 最年夜毗邻数
        poolConfig.setMaxIdle(maxIdl);
        // 最年夜余暇毗邻数
        poolConfig.setMinIdle(minIdl);
        poolConfig.setTestOnBorrow(true);
        poolConfig.setTestOnReturn(true);
        poolConfig.setTestWhileIdle(true);
        poolConfig.setNumTestsPerEvictionRun(10);
        poolConfig.setTimeBetweenEvictionRunsMillis(60000);
        // 当池内不否用的毗连时，最小等候工夫
        poolConfig.setMaxWaitMillis(timeout);
        return poolConfig;
    }
 
    /**
     * jedis毗连工场
     *
     * @param jedisPoolConfig
     * @return
     */
    public RedisConnectionFactory redisConnectionFactory(JedisPoolConfig jedisPoolConfig, int db) {
        // 双机版jedis
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        // 设施redis供职器的host或者者ip所在
        redisStandaloneConfiguration.setHostName(hostName);
        // 安排默许应用的数据库
        redisStandaloneConfiguration.setDatabase(db);
        // 装备暗码
        redisStandaloneConfiguration.setPassword(RedisPassword.of(passWord));
        // 铺排redis的做事的端标语
        redisStandaloneConfiguration.setPort(port);
 
        // 得到默许的联接池组织器
        JedisClientConfiguration.JedisPoolingClientConfigurationBuilder jpcb = (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder) JedisClientConfiguration
                .builder();
        // 指定jedisPoolConifig来修正默许的毗邻池组织器
        jpcb.poolConfig(jedisPoolConfig);
        // 经由过程布局器来结构jedis客户端铺排
        JedisClientConfiguration jedisClientConfiguration = jpcb.build();
        // 双机设备 + 客户端配备 = jedis衔接工场
        return new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration);
    }
 
    private void setSerializer(RedisTemplate<Serializable, Object> template) {
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson二JsonRedisSerializer());
    }
 
 
    public RedisTemplate<Serializable, Object> getRedisTemplateByDb(int db){
        return redisTemplateMap.get(db);
    }
 
    public RedisTemplate<Serializable, Object> getRedisTemplate(){
        return redisTemplateMap.get(defaultDb);
    }
 
}

package com.gf.ecrm.redislistenerconfig;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;

import javax.annotation.Resource;

@Configuration
public class RedisListenerConfig {

    @Resource
    private RedisConnectionFactory redisConnectionFactory;
    @Resource
    private RedisKeyExpirationListener redisExpiredListener;

    @Bean
    public RedisMessageListenerContainer redisMessageListenerContainer() {
        RedisMessageListenerContainer redisMessageListenerContainer = new RedisMessageListenerContainer();
        redisMessageListenerContainer.setConnectionFactory(redisConnectionFactory);
        //监听一切key的过时事变
        redisMessageListenerContainer.addMessageListener(redisExpiredListener, redisExpiredListener.getTopic());
        return redisMessageListenerContainer;
    }

}

package com.gf.ecrm.redislistenerconfig;

import lombok.Data;
import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.connection.MessageListener;
import org.springframework.data.redis.listener.PatternTopic;
import org.springframework.stereotype.Component;

@Data
@Component
public class RedisKeyExpirationListener implements MessageListener {
    //监听的主题(只监听redis数据库1，假如要监听redis一切的库，把1互换为*)
    public final PatternTopic topic = new PatternTopic("__keyevent@1__:expired");

    /**
     * Redis掉效事变 key
     *
     * @param message
     * @param pattern
     */
    @Override
    public void onMessage(Message message, byte[] pattern) {
        String expiraKey = message.toString();
        System.out.println(expiraKey);

    }
}