redis过期监听机制方式_Redis

1.修改配置

1.打开conf/redis.conf 文件，取消注释：notify-keyspace-events ex

2.重启redis

3.如果设置了密码需要重置密码：config set requirepass ****

4.验证配置是否生效

步骤一：进入redis客户端：redis-cli
步骤二：执行 config get notify-keyspace-events ，如果有返回值证明配置成功，如果没有执行步骤三
步骤三：执行config set notify-keyspace-events "ex"，再查看步骤二是否有值

注意：重置密码和重置配置是否每次重启redis都需要重新设置看个人需要。

2.redis在yam中的配置

spring:
  redis:
    database: 0
    host: ip
    port: 6379
    password: ***
    #超时时间：单位ms
    timeout: 60000
    pool:
      #最大空闲数：空闲链接数大于maxidle时，将进行回收
      max-idle: 8
      #最小空闲数：低于minidle时，将创建新的链接
      min-idle: 1
      #最大连接数：能够同时建立的“最大链接个数”
      max-active: 20
      #最大等待时间：单位ms
      max-wait: 120000
    lettuce:
      cluster:
        refresh:
          adaptive: true
          period: 20

3.代码实现

3.1.redis的连接配置

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.genericjackson2jsonredisserializer;
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 genericjackson2jsonredisserializer());
    }
 
 
    public redistemplate<serializable, object> getredistemplatebydb(int db){
        return redistemplatemap.get(db);
    }
 
    public redistemplate<serializable, object> getredistemplate(){
        return redistemplatemap.get(defaultdb);
    }
 
}

3.2.redis的监听conf

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;
    }

}

3.3.监听业务代码

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);

    }
}