redis过期监听

1. 修改配置

# redis.conf下的配置
notify-keyspace-event Ex

或者

# 进入redis命令行
redis-cli
CONFIG SET notify-keyspace-events "Ex"
# 查看配置
CONFIG GET notify-keyspace-events

2. springboot + redis

pom.xml

<!-- redis -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
	<exclusions>
		<exclusion>
			<groupId>io.lettuce</groupId>
			<artifactId>lettuce-core</artifactId>
		</exclusion>
	</exclusions>
</dependency>
<!-- 使用jedis -->
<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
</dependency>

application.yml

spring:
  redis:
    host: 127.0.0.1
    jedis:
      pool:
        max-active: 8   #最大连接数据库连接数,设 -1 为没有限制
        max-idle: 8     #最大等待连接中的数量,设 0 为没有限制
        max-wait: -1ms  #最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
        min-idle: 0     #最小等待连接中的数量,设 0 为没有限制
      shutdown-timeout: 100ms
    password: ''
    port: 6379

配置类 RedisConfig.java

import com.google.gson.JsonObject;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig extends CachingConfigurerSupport {    //Rdis配置工具，包括序列器配置等
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String, Object> template=new RedisTemplate<>();

        //关联
        template.setConnectionFactory(factory);
        //设置key的序列化器
        template.setKeySerializer(new StringRedisSerializer());
        //设置value的序列器
        // 通过配置改造为Jackson2JsonRedisSerializer即转换为了json串
        template.setValueSerializer(new Jackson2JsonRedisSerializer<Object>(Object.class));
        return template;
    }
	
	/**
	 * 过期监听
	 */
    @Bean
    RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory) {

        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        return container;
    }

}

实体类 UserEntity.java

import lombok.Data;

@Data
public class UserEntity{
    private Integer userId;
    private String userName;
    private Integer userAge;
}

监听逻辑类

import lombok.SneakyThrows;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.listener.KeyExpirationEventMessageListener;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

@Component
public class RedisKeyExpirationListener extends KeyExpirationEventMessageListener {
    @Autowired
    private RedisTemplate<String,String> redisTemplateStr;

    @Autowired      //手动配置了RedisConfig之后，在spring上下文就存在了RedisTemplate<String,Object>类型的Bean
    private RedisTemplate<String, Object> redisTemplate;     

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

    @Override
    public void onMessage(Message message, byte[] pattern) {
        try {
            String expiredKey = message.toString();//获取所有key
            if(expiredKey.startsWith("user_")){
            	// TODO 过期监听后的具体逻辑
            }

        }catch (Exception e){
            e.printStackTrace();
        }

    }
	
	/**
     * 设置key-value并设置过期时间(秒)
     * @param key
     * @param value
     * @param timeout
     */
    private void setExpireKeyValue(String key, Object value, long timeout){
        redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
        System.out.println("vehicleNo: 当前存储键值对为=>key="+key+",value="+value);
    }

    /**
     * 设置不过期键值对
     * @param key
     * @param endTime
     * @param entity
     */
    private void setKeyValue(String key, Object value){
        redisTemplate.opsForValue().set(key, value);
        System.out.println("vehicleNo: 当前存储键值对为=>key="+key+",value="+entity);
    }

	/**
	 * 返回某个ket的value
	 */ 
    public UserEntity getVehicleRedisEntity(String key){
        Object value = redisTemplate.opsForValue().get(key);
        UserEntity entity = null;
        if (value != null) {
            Gson gson = new GsonBuilder().create();
            entity = gson.fromJson(JsonParser.parseString(value.toString()).getAsJsonObject(), UserEntity .class);
        }
        return entity;
    }

    /**
     * 返回 key 的剩余的过期时间
     */
    private Long getExpire(String key, TimeUnit unit) {
        System.out.println("key:" + key + ", expire: " + redisTemplate.getExpire(key, unit));
        return redisTemplate.getExpire(key, unit);
    }

	/**
	 * 删除某个key
	 */ 
    public void deleteRedisKey(String key){
        redisTemplate.delete(key);
    }
}