redis key过期监听

1.首先将redis的配置文件中的 notify-keyspace-events改成 notify-keyspace-events Ex
这里的 EX代表 expire 和 evicted 过期和驱逐 的时间监听 ，注意：改了配置要重启Redis

2.配置redis监听器

import cn.hutool.core.util.StrUtil;
import com.joolun.mall.listener.RedisKeyExpirationListener;
import com.joolun.mall.service.OrderInfoService;
import lombok.AllArgsConstructor;
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.PatternTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;

/**
 * @author www.joolun.com
 */
@Configuration
@AllArgsConstructor
public class RedisListenerConfig {

   private final RedisTemplate<String, String> redisTemplate;
   private final RedisConfigProperties redisConfigProperties;
   private final OrderInfoService orderInfoService;

   @Bean
    RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory) {

      RedisMessageListenerContainer container = new RedisMessageListenerContainer();
      container.setConnectionFactory(connectionFactory);
      container.addMessageListener(new RedisKeyExpirationListener(redisTemplate, redisConfigProperties, orderInfoService), new PatternTopic(StrUtil.format("__keyevent@{}__:expired", redisConfigProperties.getDatabase())));
      return container;
   }
}

RedisConfigProperties


/**
 * reids相关配置
 *
 * @author
 */
@Data
@Configuration
@ConfigurationProperties(prefix = "spring.redis")
public class RedisConfigProperties {

	private String host = "host";
	private String port = "port";
	private String password = "password";
	private String database = "database";

}

3.过期监听

import cn.hutool.core.util.StrUtil;
import com.joolun.mall.config.CommonConstants;
import com.joolun.mall.config.RedisConfigProperties;
import com.joolun.mall.constant.MallConstants;
import com.joolun.mall.entity.OrderInfo;
import com.joolun.mall.enums.OrderInfoEnum;
import com.joolun.mall.service.OrderInfoService;
import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.connection.MessageListener;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Component;

/**
 * redis过期监听
 * 1、自动取消订单
 * 2、自动收货
 */
@Component
public class RedisKeyExpirationListener implements MessageListener {

	private RedisTemplate<String, String> redisTemplate;
	private RedisConfigProperties redisConfigProperties;
	private OrderInfoService orderInfoService;

	public RedisKeyExpirationListener(RedisTemplate<String, String> redisTemplate,
                                      RedisConfigProperties redisConfigProperties,
                                      OrderInfoService orderInfoService){
		this.redisTemplate = redisTemplate;
		this.redisConfigProperties = redisConfigProperties;
		this.orderInfoService = orderInfoService;
	}
	@Override
	public void onMessage(Message message, byte[] bytes) {
		RedisSerializer<?> serializer = redisTemplate.getValueSerializer();
		String channel = String.valueOf(serializer.deserialize(message.getChannel()));
		String body = String.valueOf(serializer.deserialize(message.getBody()));
		System.out.println("------------------------------------------------------");
		//key过期监听
		if(StrUtil.format("__keyevent@{}__:expired", redisConfigProperties.getDatabase()).equals(channel)){
			//订单自动取消
			if(body.contains(MallConstants.REDIS_ORDER_KEY_IS_PAY_0)) {
				body = body.replace(MallConstants.REDIS_ORDER_KEY_IS_PAY_0, "");
				String[] str = body.split(":");
				String wxOrderId = str[1];
				OrderInfo orderInfo = orderInfoService.getById(wxOrderId);
				if(orderInfo != null && CommonConstants.NO.equals(orderInfo.getIsPay())){//只有待支付的订单能取消
					orderInfoService.orderCancel(orderInfo);
				}
			}
			//订单自动收货
			if(body.contains(MallConstants.REDIS_ORDER_KEY_STATUS_2)) {
				body = body.replace(MallConstants.REDIS_ORDER_KEY_STATUS_2, "");
				String[] str = body.split(":");
				String orderId = str[1];
				OrderInfo orderInfo = orderInfoService.getById(orderId);
				if(orderInfo != null && OrderInfoEnum.STATUS_2.getValue().equals(orderInfo.getStatus())){//只有待收货的订单能收货
					orderInfoService.orderReceive(orderInfo);
				}
			}
		}
	}
}

使用方法

//订单自动取消时间 30分钟
long orderTimeOut = MallConstants.ORDER_TIME_OUT_0;
//加入redis，30分钟自动取消
String keyRedis = String.valueOf(StrUtil.format("{}:{}",MallConstants.REDIS_ORDER_KEY_IS_PAY_0, orderInfo.getId()));
redisTemplate.opsForValue().set(keyRedis, orderInfo.getOrderNo() , orderTimeOut, TimeUnit.MINUTES);//设置过期时间

//获取倒计时时间戳
@Override
public OrderInfo getById2(Serializable id) {
    OrderInfo orderInfo = baseMapper.selectById2(id);
    if(orderInfo != null){
        String keyRedis = null;
        //获取自动取消倒计时
        if(CommonConstants.NO.equals(orderInfo.getIsPay())){
            keyRedis = String.valueOf(StrUtil.format("{}:{}", MallConstants.REDIS_ORDER_KEY_IS_PAY_0,orderInfo.getId()));
        }
        //获取自动收货倒计时
        if(OrderInfoEnum.STATUS_2.getValue().equals(orderInfo.getStatus())){
            keyRedis = String.valueOf(StrUtil.format("{}:{}",MallConstants.REDIS_ORDER_KEY_STATUS_2,orderInfo.getId()));
        }
        if(keyRedis != null){
            Long outTime = redisTemplate.getExpire(keyRedis);
            if(outTime != null && outTime > 0){
                orderInfo.setOutTime(outTime);
            }
        }
    }
    return orderInfo;
}