spring boot+redis 监听过期Key的操作方法_Java

前言：

在订单业务中，有时候需要对订单设置有效期，有效期到了后如果还未支付，就需要修改订单状态。对于这种业务的实现，有多种不同的办法，比如：

1、使用querytz，每次生成一个订单，就创建一个定时任务，到期后执行业务代码；

2、rabbitmq中的延迟队列；

3、对redis的key进行监控；

1、引入依赖

 <dependency>
   <groupid>org.springframework.boot</groupid>
   <artifactid>spring-boot-starter-data-redis</artifactid>
  </dependency>

2、修改boot的redis配置

spring:
 #redis
 redis:
 database: 0
 host: 127.0.0.1
 password: redis_123456
 port: 6379

3、在服务器中修改redis.conf配置文件（原来notify-keyspace-events 属性是" " 空的，我们只需要填上“ex”就行了）

notify-keyspace-events "ex"

4、创建一个redis监控类，用于监控过期的key，该类需继承keyexpirationeventmessagelistener

import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.data.redis.connection.message;
import org.springframework.data.redis.listener.keyexpirationeventmessagelistener;
import org.springframework.data.redis.listener.redismessagelistenercontainer;
 
import java.nio.charset.standardcharsets;
 
/**
 * @program: springcloud
 * @description: redis key过期监听
 * @author: zhang yi
 * @create: 2020-03-24 14:14
 */
public class keyexpiredlistener extends keyexpirationeventmessagelistener {
 
 public keyexpiredlistener(redismessagelistenercontainer listenercontainer) {
  super(listenercontainer);
 }
 
 @override
 public void onmessage(message message, byte[] pattern) {
  system.out.println("过期key:" + message.tostring());
 }
}

5、创建redis配置类

import com.zy.rabbitmq.base.listener.keyexpiredlistener;
import org.springframework.beans.factory.annotation.autowired;
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;
 
/**
 * @program: springcloud
 * @description: redis配置类
 * @author: zhang yi
 * @create: 2020-03-24 14:17
 */
@configuration
public class redisconfiguration {
 
 @autowired
 private redisconnectionfactory redisconnectionfactory;
 
 @bean
 public redismessagelistenercontainer redismessagelistenercontainer() {
  redismessagelistenercontainer redismessagelistenercontainer = new redismessagelistenercontainer();
  redismessagelistenercontainer.setconnectionfactory(redisconnectionfactory);
  return redismessagelistenercontainer;
 }
 
 @bean
 public keyexpiredlistener keyexpiredlistener() {
  return new keyexpiredlistener(this.redismessagelistenercontainer());
 }
 
}

6、这里提供一个redis工具类，用于存储值，获取值，获取过期时间等操作。

import org.springframework.data.redis.core.redistemplate;
import org.springframework.stereotype.component;
import org.springframework.util.collectionutils;
 
import javax.annotation.resource;
import java.util.concurrent.timeunit;
/**
 * redis 工具类
 * @author zhangyi
 */
@component
public class redisutil {
 
	@resource
	private redistemplate<string, object> redistemplate;
 
	/**
	 * 指定缓存失效时间
	 * 
	 * @param key 键
	 * @param time 时间(秒)
	 * @return
	 */
	public boolean expire(string key, long time) {
		try {
			if (time > 0) {
				redistemplate.expire(key, time, timeunit.seconds);
			}
			return true;
		} catch (exception e) {
			e.printstacktrace();
			return false;
		}
	}
 
	/**
	 * 根据key 获取过期时间
	 * 
	 * @param key 键 不能为null
	 * @return 时间(秒) 返回0代表为永久有效
	 */
	public long getexpire(string key) {
		return redistemplate.getexpire(key, timeunit.seconds);
	}
 
	/**
	 * 判断key是否存在
	 * 
	 * @param key 键
	 * @return true 存在 false不存在
	 */
	public boolean haskey(string key) {
		try {
			return redistemplate.haskey(key);
		} catch (exception e) {
			e.printstacktrace();
			return false;
		}
	}
 
	/**
	 * 删除缓存
	 * 
	 * @param key 可以传一个值 或多个
	 */
	@suppresswarnings("unchecked")
	public void del(string... key) {
		if (key != null && key.length > 0) {
			if (key.length == 1) {
				redistemplate.delete(key[0]);
			} else {
				redistemplate.delete(collectionutils.arraytolist(key));
			}
		}
	}
 
	// ============================string=============================
	/**
	 * 普通缓存获取
	 * 
	 * @param key 键
	 * @return 值
	 */
	public object get(string key) {
		return key == null ? null : redistemplate.opsforvalue().get(key);
	}
 
	/**
	 * 普通缓存放入
	 * 
	 * @param key 键
	 * @param value 值
	 * @return true成功 false失败
	 */
	public boolean set(string key, object value) {
		try {
			redistemplate.opsforvalue().set(key, value);
			return true;
		} catch (exception e) {
			e.printstacktrace();
			return false;
		}
 
	}
 
	/**
	 * 普通缓存放入并设置时间
	 * 
	 * @param key 键
	 * @param value 值
	 * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
	 * @return true成功 false 失败
	 */
	public boolean set(string key, object value, long time) {
		try {
			if (time > 0) {
				redistemplate.opsforvalue().set(key, value, time, timeunit.seconds);
			} else {
				set(key, value);
			}
			return true;
		} catch (exception e) {
			e.printstacktrace();
			return false;
		}
	}
}

7、测试。（这里开放两个接口，一个set值，并设置过期时间为10秒，一个获取值和过期时间，当到达过期时间，看是否回去到过期key）

@getmapping("/put")
 public string demo(){
  redisutil.set("name","zhangyi",10);
  return "aaa";
 }
 
 @getmapping("/get")
 public map<string,object> get(){
  map<string,object> m =new hashmap<>();
  m.put("time",redisutil.getexpire("name"));
  m.put("val",redisutil.get("name"));
  return m;
 }