首先在pom文件中加入redis依赖
<!--redis依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.0.1</version>
</dependency>
在application-dev.yml文件中配置redis属性
然后在springboot项目中配置redis实体类
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
@Value("${spring.redis.host}")
private String host;
@Value("${spring.redis.port}")
private Integer port;
@Value("${spring.redis.password}")
private String password;
@Value("${spring.redis.timeout}")
private Integer timout;
@Value("${spring.redis.jedis.pool.max-idle}")
private Integer maxIdl;//链接池最大空闲数
@Value("${spring.redis.jedis.pool.min-idle}")
private Integer minIdl;//链接池最小空闲数
@Value("${spring.redis.jedis.pool.max-active}")
private Integer maxActive;//链接池最大链接数
@Value("${spring.redis.jedis.pool.max-wait}")
private Integer maxWait;//连接池最大阻塞时间
@Value("${spring.redis.database}")
private Integer database;//redis数据库索引数
@Bean
public RedisConnectionFactory getfactory(){
JedisPoolConfig config=new JedisPoolConfig();
config.setMaxIdle(maxIdl);
config.setMinIdle(minIdl);
config.setMaxWaitMillis(maxWait);
config.setMaxTotal(maxActive);
//获取链接检查有效性
config.setTestOnBorrow(false);
//部署时为true
// config.setTestOnCreate(false);
//返回验证信息
config.setTestOnReturn(false);
//链接最近是否阻塞
config.setBlockWhenExhausted(true);
JedisConnectionFactory jedisConnectionFactory=new JedisConnectionFactory(config);
jedisConnectionFactory.setHostName(host);
jedisConnectionFactory.setPort(port);
jedisConnectionFactory.setDatabase(database);
if(!password.isEmpty()){
jedisConnectionFactory.setPassword(password);
}
jedisConnectionFactory.setTimeout(timout);
return jedisConnectionFactory;
}
@Bean
public RedisTemplate<String,Object> redisTemplate(){
RedisTemplate<String,Object> redisTemplate=new RedisTemplate<>();
//配置链接工厂
redisTemplate.setConnectionFactory(getfactory());
//使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
Jackson2JsonRedisSerializer jsonRedisSerializer=new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om=new ObjectMapper();
// 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
// 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jsonRedisSerializer.setObjectMapper(om);
//值采用json系列化
redisTemplate.setValueSerializer(jsonRedisSerializer);
//使用StringRedisSerializer来序列化和反序列化redis的key值
redisTemplate.setKeySerializer(new StringRedisSerializer());
//设置hash key和value的序列化模式
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
redisTemplate.setHashValueSerializer(jsonRedisSerializer);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
/**
* 对hash类型的数据操作
* @param redisTemplate
* @return
*/
@Bean
public HashOperations<String,String,Object> hashOperations(RedisTemplate<String,Object> redisTemplate){
return redisTemplate.opsForHash();
}
/**
* 对redis字符串类型的操作
* @param redisTemplate
* @return
*/
@Bean
public ValueOperations<String,Object> valueOperations(RedisTemplate<String,Object> redisTemplate){
return redisTemplate.opsForValue();
}
/**
* 对链表类型的操作
* @param redisTemplate
* @return
*/
@Bean
public ListOperations<String,Object> listOperations(RedisTemplate<String,Object> redisTemplate){
return redisTemplate.opsForList();
}
/**
* 对redis无序集合类型的数据操作
* @param redisTemplate
* @return
*/
@Bean
public SetOperations<String,Object> setOperations(RedisTemplate<String,Object> redisTemplate){
return redisTemplate.opsForSet();
}
/**
* 对redis有序集合类型的数据操作
* @param redisTemplate
* @return
*/
public ZSetOperations<String,Object> zSetOperations(RedisTemplate<String,Object> redisTemplate){
return redisTemplate.opsForZSet();
}
}
创建redisUitls工具类import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundListOperations;
import org.springframework.data.redis.core.RedisConnectionUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
@Component
public class RedisUtil {
@Autowired
private RedisTemplate<String,Object> redisTemplate;
public RedisUtil(RedisTemplate<String,Object> redisTemplate) {
this.redisTemplate=redisTemplate;
}
//释放连接池资源
public void backRedis(){
RedisConnectionUtils.unbindConnection(redisTemplate.getConnectionFactory());
}
/**
* 指定缓存失效时间
* @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;
}finally{
backRedis();//释放连接资源
}
}
/**
* 根据key 获取过期时间
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效
*/
public long getExpire(String key){
try {
return redisTemplate.getExpire(key,TimeUnit.SECONDS);
} catch (Exception e) {
e.printStackTrace();
return 0;
}finally{
backRedis();//释放连接资源
}
}
/**
* 判断key是否存在
* @param key 键
* @return true 存在 false不存在
*/
public boolean hasKey(String key){
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
e.printStackTrace();
return false;
}finally{
backRedis();//释放连接资源
}
}
/**
* 删除一个缓存
* @param key 可以传一个值
*/
public void delOne(String key){
try {
redisTemplate.delete(key);
} catch (Exception e) {
e.printStackTrace();
}finally{
backRedis();//释放连接资源
}
}
/**
* 删除多个缓存
* @param keys
*/
public void delKeys(List<String> keys){
try {
redisTemplate.delete(keys);
} catch (Exception e) {
e.printStackTrace();
}finally{
backRedis();//释放连接资源
}
}
//***************** String **********************
/**
* 普通缓存获取
* @param key 键
* @return 值
*/
public Object get(String key){
try {
return key==null?null:redisTemplate.opsForValue().get(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}finally{
backRedis();//释放连接资源
}
}
/**
* 普通缓存放入
* @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;
}finally{
backRedis();//释放连接资源
}
}
/**
* 普通缓存放入并设置时间
* @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;
}finally{
backRedis();
}
}
/**
* 递增
* @param key 键
* @param delta 要增加几(大于0)
* @return
*/
public long incr(String key, long delta){
if(delta<0){
throw new RuntimeException("递增因子必须大于0");
}
try {
return redisTemplate.opsForValue().increment(key, delta);
} catch (Exception e) {
e.printStackTrace();
return 0;
}finally{
backRedis();//释放连接资源
}
}
/**
* 递减
* @param key 键
* @param delta 要减少几(小于0)
* @return
*/
public long decr(String key, long delta){
if(delta<0){
throw new RuntimeException("递减因子必须大于0");
}
try {
return redisTemplate.opsForValue().increment(key, -delta);
} catch (Exception e) {
e.printStackTrace();
return 0;
}finally{
backRedis();//释放连接资源
}
}
//============================== Hash ===============================
/**
* HashGet
* @param key 键 不能为null
* @param item 项 不能为null
* @return 值
*/
public Object hGet(String key,String item){
// return redisTemplate.opsForHash().get(key, item);
try {
return redisTemplate.opsForHash().get(key, item);
} catch (Exception e) {
e.printStackTrace();
return null;
}finally{
backRedis();//释放连接资源
}
}
/**
* 获取hashKey对应的所有键值
* @param key 键
* @return 对应的多个键值
*/
public Map<Object,Object> hmGet(String key){
// return redisTemplate.opsForHash().entries(key);
try {
return redisTemplate.opsForHash().entries(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}finally{
backRedis();//释放连接资源
}
}
/**
* HashSet
* @param key 键
* @param map 对应多个键值
* @return true 成功 false 失败
*/
public boolean hMapSet(String key, Map<String,Object> map){
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}finally{
backRedis();
}
}
/**
* HashSet 并设置时间
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
public boolean hmSetTime(String key, Map<String,Object> map, long time){
try {
redisTemplate.opsForHash().putAll(key, map);
if(time>0){
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}finally{
backRedis();
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
* @param key 键
* @param item 项
* @param value 值
* @return true 成功 false失败
*/
public boolean hSave(String key,String item,Object value) {
try {
redisTemplate.opsForHash().put(key, item, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}finally{
backRedis();
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
* @param key 键
* @param item 项
* @param value 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
public boolean hSaveTime(String key,String item,Object value,long time) {
try {
redisTemplate.opsForHash().put(key, item, value);
if(time>0){
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}finally{
backRedis();
}
}
/**
* 删除hash表中的值
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hDel(String key, Object item){
// redisTemplate.opsForHash().delete(key,item);
try {
redisTemplate.opsForHash().delete(key,item);
} catch (Exception e) {
e.printStackTrace();
}finally{
backRedis();
}
}
/**
* 判断hash表中是否有该项的值
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String item){
// return redisTemplate.opsForHash().hasKey(key, item);
try {
return redisTemplate.opsForHash().hasKey(key, item);
} catch (Exception e) {
e.printStackTrace();
return false;
}finally{
backRedis();
}
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
* @return
*/
public double hIncr(String key, String item,double by){
// return redisTemplate.opsForHash().increment(key, item, by);
try {
return redisTemplate.opsForHash().increment(key, item, by);
} catch (Exception e) {
e.printStackTrace();
return 0;
}finally{
backRedis();
}
}
/**
* hash递减
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
* @return
*/
public double hDecr(String key, String item,double by){
// return redisTemplate.opsForHash().increment(key, item,-by);
try {
return redisTemplate.opsForHash().increment(key, item,-by);
} catch (Exception e) {
e.printStackTrace();
return 0;
}finally{
backRedis();
}
}
//=========================== set ============================
/**
* 根据key获取Set中的所有值
* @param key 键
* @return
*/
public Set<Object> sGet(String key){
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}finally{
backRedis();
}
}
/**
* 根据value从一个set中查询,是否存在
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public boolean sHasKey(String key,Object value){
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
}finally{
backRedis();
}
}
/**
* 将数据放入set缓存
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSet(String key, Object values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
e.printStackTrace();
return 0;
}finally{
backRedis();
}
}
/**
* 将set数据放入缓存
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSetAndTime(String key,long time,Object values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if(time>0) {
expire(key, time);
}
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}finally{
backRedis();
}
}
/**
* 获取set缓存的长度
* @param key 键
* @return
*/
public long sGetSetSize(String key){
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}finally{
backRedis();
}
}
/**
* 移除值为value的
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long setRemove(String key, Object values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}finally{
backRedis();
}
}
//===============================list=================================
/**
* 获取list缓存的内容
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
* @return
*/
public List<Object> lGet(String key, long start, long end){
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}finally{
backRedis();
}
}
/**
* 获取list缓存的长度
* @param key 键
* @return
*/
public long lGetListSize(String key){
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}finally{
backRedis();
}
}
/**
* 通过索引 获取list中的值
* @param key 键
* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
* @return
*/
public Object lGetIndex(String key,long index){
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
e.printStackTrace();
return null;
}finally{
backRedis();
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @return
*/
public boolean lpush(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}finally{
backRedis();
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lpushTime(String key, Object value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}finally{
backRedis();
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @return
*/
public boolean lpushAll(String key, List value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}finally{
backRedis();
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lpushAllTime(String key, List<Object> value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}finally{
backRedis();
}
}
/**
* 根据索引修改list中的某条数据
* @param key 键
* @param index 索引
* @param value 值
* @return
*/
public boolean lUpdateIndex(String key, long index,Object value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}finally{
backRedis();
}
}
/**
* 移除N个值为value
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public long lRemove(String key,long count,Object value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception e) {
e.printStackTrace();
return 0;
}finally{
backRedis();
}
}
/**
* 模糊查询获取key值
* @param pattern
* @return
*/
public Set keys(String pattern){
// return redisTemplate.keys(pattern);
try {
return redisTemplate.keys(pattern);
} catch (Exception e) {
e.printStackTrace();
return null;
}finally{
backRedis();
}
}
/**
* 使用Redis的消息队列
* @param channel
* @param message 消息内容
*/
public void convertAndSend(String channel, Object message){
// redisTemplate.convertAndSend(channel,message);
try {
redisTemplate.convertAndSend(channel,message);
} catch (Exception e) {
e.printStackTrace();
}finally{
backRedis();
}
}
//=========BoundListOperations 用法 start============
/**
*将数据添加到Redis的list中（从右边添加）
* @param listKey
* @param values 待添加的数据
*/
public void addToListRight(String listKey,Object values) {
//绑定操作
BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
//插入数据
boundValueOperations.rightPushAll(values);
//设置过期时间
}
/**
* 根据起始结束序号遍历Redis中的list
* @param listKey
* @param start 起始序号
* @param end 结束序号
* @return
*/
public List<Object> rangeList(String listKey, long start, long end) {
//绑定操作
BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
//查询数据
return boundValueOperations.range(start, end);
}
/**
* 弹出右边的值 --- 并且移除这个值
* @param listKey
*/
public Object rifhtPop(String listKey){
//绑定操作
BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
return boundValueOperations.rightPop();
}
//=========BoundListOperations 用法 End============
}
在方法中注入redisUtils既可使用import com.qh.chat.common.utils.Const;
import com.qh.chat.common.utils.RedisUtil;
import com.qh.chat.system.entity.RecordBroadcast;
import com.qh.chat.system.entity.RecordCustomer;
import com.qh.chat.system.entity.RecordPrivate;
import com.qh.chat.system.entity.RecordRoom;
import com.qh.chat.system.service.IRecordBroadcastService;
import com.qh.chat.system.service.IRecordCustomerService;
import com.qh.chat.system.service.IRecordPrivateService;
import com.qh.chat.system.service.IRecordRoomService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;import javax.annotation.Resource;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;@Component
public class RecordChatTask { @Resource
private RedisUtil redisUtil; @Autowired
private IRecordBroadcastService broadService; @Autowired
private IRecordPrivateService privateService; @Autowired
private IRecordRoomService roomService; @Autowired
private IRecordCustomerService customerService; /**
* 将聊天信息从redis缓存中取出保存到数据中，并将redis中取出的缓存删除
*/
//每隔10分钟执行一次
// @Scheduled(cron="0 */10 * * * ? ")
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT, readOnly = false, rollbackFor = Exception.class)
public void savePrivateChatRecord(){
//从redis缓存中取私聊信息
String privateKey= Const.RECORD_PRIVATE_KEY;
String pp=privateKey+"*";
//模糊查询所有符合规定的key
Set pset = redisUtil.keys(pp);
//取私聊信息，分别获取所有的私聊key
List<RecordPrivate> privatelist=new ArrayList();
if (pset.size()==0||pset.isEmpty()){
return ;
}
for (Object obj:pset) {
//根据key之获取对应的list集合
String key= (String)obj;
//获取key对应的链表
List<Object> plist = redisUtil.lGet(key,0,-1);
String from_to=key.substring(9);
String [] arr=from_to.split("-");
RecordPrivate pchat=new RecordPrivate();
//设置pchat的属性
pchat.setPcontent(plist);
//设置发送人和接收人
pchat.setSendId(Long.parseLong(arr[0]));
pchat.setReceiveId(Long.parseLong(arr[1]));
// 设置当天日期
pchat.setPtime(LocalDate.now());
privatelist.add(pchat);
} if(!privatelist.isEmpty()&&privatelist.size()>0) {
boolean presult = privateService.saveBatch(privatelist);
if (presult) {
//如果插入数据库成功,则将对应的链表从缓存中删除掉
List list = new ArrayList(pset);
redisUtil.delKeys(list);
}
} }
/**
* 每隔10分钟将聊天室记录保存并删除
*/
// @Scheduled(cron="0 */10 * * * ? ")
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT, readOnly = false, rollbackFor = Exception.class)
public void saveRoomChatRecord(){
//取聊天室信息获取所有的聊天室key
String roomKey=Const.RECORD_ROOM_KEY;
String rr=roomKey+"*";
Set rset = redisUtil.keys(rr);
List<RecordRoom> roomlist=new ArrayList<>();
if (rset.isEmpty()||rset.size()==0){
return ;
}
for (Object obj:rset) {
String key=(String)obj;
//获取key对应的链表内容
List<Object> rlist = redisUtil.lGet(key, 0, -1);
String roomNo=key.substring(9);
RecordRoom roomchat=new RecordRoom();
roomchat.setRoomNo(Long.parseLong(roomNo));
roomchat.setRcontent(rlist);
roomchat.setRtime(LocalDate.now());
roomlist.add(roomchat);
} if(!roomlist.isEmpty()&&roomlist.size()>0) {
boolean result = roomService.saveBatch(roomlist);
if (result) {
//如果插入数据库成功,则将对应的链表从缓存中删除掉
List list = new ArrayList(rset);
redisUtil.delKeys(list);
}
}
} /**
* 每天晚上凌晨2点执行清除缓存等待操作
*/
@Scheduled(cron="0 0 2 * * ?")
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT, readOnly = false, rollbackFor = Exception.class)
public void saveBroadChatRecord(){
//取通知信息，分别获取所有的广播key
String broadKey=Const.RECORD_BROADCAST_KEY;
String bb=broadKey+"*";
Set bset = redisUtil.keys(bb);
List<RecordBroadcast> broadlist=new ArrayList();
if (bset.isEmpty()||bset.size()==0){
return ;
}
//便利bset集合，分别获取所有的通知key
for (Object obj:bset) {
String key = (String) obj;
//根据key获取链表内容
List<Object> blist = redisUtil.lGet(key, 0, -1);
String from=key.substring(9);
RecordBroadcast broadcast=new RecordBroadcast();
broadcast.setBcontent(blist);
broadcast.setSendId(Long.parseLong(from));
broadcast.setBtime(LocalDate.now());
}
//将聊天内容批量插入数据库中并将所有取出的聊天key从redis缓存中删除掉
if(!broadlist.isEmpty()&&broadlist.size()>0){
boolean bresult=broadService.saveBatch(broadlist);
if(bresult){
//如果插入数据库成功,则将对应的链表从缓存中删除掉
List list=new ArrayList(bset);
redisUtil.delKeys(list);
}
}
} /**
* 每天晚上凌晨1点执行清除缓存等待操作
*/
@Scheduled(cron="0 0 1 * * ?")
public void clearWaitRedis(){
String key=Const.WAIT_CUSTOMER_KEY;
redisUtil.delOne(key);
} /**
* 每天晚上凌晨1点执行清除缓存等待操作
*/ @Scheduled(cron="0 0 1 * * ?")
public void saveCustomerRecord(){
String customkey=Const.RECORD_CUSTOMER_KEY;
String bb=customkey+"*";
Set cset = redisUtil.keys(bb);
List<RecordCustomer> customlist=new ArrayList<>();
if (cset.isEmpty()||cset.size()==0){
return ;
}
//便利bset集合，分别获取所有的通知key
for (Object obj:cset) {
String key = (String) obj;
//根据key获取链表内容
List<Object> clist = redisUtil.lGet(key, 0, -1);
String from_to=key.substring(10);
String [] arr=from_to.split("-");
RecordCustomer customer=new RecordCustomer();
customer.setContent(clist);
customer.setCustomerId(Long.parseLong(arr[0]));
customer.setUserId(Long.parseLong(arr[1]));
// 设置当天日期
customer.setCtime(LocalDate.now());
customlist.add(customer);
}
//将聊天内容批量插入数据库中并将所有取出的聊天key从redis缓存中删除掉
if(!customlist.isEmpty()&&customlist.size()>0){
boolean cresult=customerService.saveBatch(customlist);
if(cresult){
//如果插入数据库成功,则将对应的链表从缓存中删除掉
List list=new ArrayList(cset);
redisUtil.delKeys(list);
}
}
}}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
