SpringBoot+Redis实现点赞功能的缓存和定时持久化（附源码）-电子发烧友网

0.前言

本文基于Springboot利用Redis实现点赞功能的缓存和定时持久化接口。

用户对浏览内容进行【点赞/取赞】，并发送【点赞/取赞】请求到后端，这些信息先存入Redis中缓存，再每隔两小时将Redis中的内容直接写入数据库持久化存储。

1.项目目录结构

2.Redis缓存点赞消息

1.设计思路

用户点赞一条数据，设置状态为0，并且更新被点赞内容的likeCount+1

用户取消点赞一条数据，设置状态为1，并且更新被点赞内容的likeCount+0

1.1 Redis键值对设计

选用Hash（散列）存储

点赞信息

key: (String) 浏览信息id和点赞用户id拼接而成, 分隔符为::
value: (HashMap) 存储点赞状态(0: 点赞 1:取消点赞)和更新时间的时间戳
key: "浏览信息id::点赞用户id" value: {status: Integer, updateTime: long}

点赞数量

key: (String) 浏览信息id
value: (Integer) 点赞数量

1.2 点赞

用户点赞信息，发送点赞请求到后端
后端判断该点赞信息在Redis中的状态
- Redis不进行存储，并提醒前端重复存储。
- 更新/新增点赞信息
- 更新/新增点赞量
- 【不存在（没有对应key) 】|| 【取消点赞（即取出的status为1）】
- 【点赞（即取出的status为0，此时相当于重复点赞行为）】
一次点赞请求完毕

1.3 取消点赞

用户取消点赞信息，发送取消点赞请求到后端
后端判断该点赞信息在Redis中的状态
- 更新/新增点赞信息
- 更新/新增点赞量
- Redis不进行存储，并提醒前端重复存储。
- 更新/新增点赞信息
- 增加0条内容点赞量
- 【不存在（没有对应key) 】
- 【取消点赞（即取出的status为1，此时相当于重复取消点赞行为）】
- 【点赞（即取出的status为0）】
一次取消点赞请求完毕

2.核心代码实现

2.1 Redis封装

具体实现参考该博客，不在赘述。

https://www.cnblogs.com/caizhaokai/p/11037610.html

2.2 工具类

1.时间戳转化为LocalDateTime

importjava.time.Instant;
importjava.time.LocalDateTime;
importjava.time.ZoneId;

/**
*工具类：将时间戳转化为LocalDateTime
*主要是因为redis不好存储LocalDateTime，存储timestamp方便一点，而且格式可以随意改变
*/
publicclassLocalDateTimeConvertUtil{
publicstaticLocalDateTimegetDateTimeOfTimestamp(longtimestamp){
Instantinstant=Instant.ofEpochMilli(timestamp);
ZoneIdzone=ZoneId.systemDefault();
returnLocalDateTime.ofInstant(instant,zone);
}
}

2.RedisKey处理类

publicclassRedisKeyUtils{
/**
*
保存用户点赞内容数据的key
*@date2021/9/2614:44
*/
publicstaticfinalStringMAP_KEY_USER_LIKED="MAP_USER_LIKED";
/**
*
保存内容被点赞数量的key
*@date2021/9/2614:44
*/
publicstaticfinalStringMAP_KEY_USER_LIKED_COUNT="MAP_USER_LIKED_COUNT";

/**
*拼接被点赞的内容id和点赞的人的id作为key。格式222222::333333
*@paraminfoId被点赞的内容id
*@paramlikeUserId点赞的人的id
*@return
*/
publicstaticStringgetLikedKey(StringinfoId,StringlikeUserId){
returninfoId+
"::"+
likeUserId;
}
}

2.3 DTO

//UserLikesDTO.java
@Data
@AllArgsConstructor
@NoArgsConstructor
publicclassUserLikesDTO{
privateStringinfoId;
privateStringlikeUserId;
privateIntegerstatus;
privateLocalDateTimeupdateTime;
}

//UserLikeCountDTO.java
@Data
@AllArgsConstructor
@NoArgsConstructor
publicclassUserLikeCountDTO{
privateStringinfoId;
privateIntegerlikeCount;
}

2.4 Service

interface

//RedisService.java

importcom.csu.edu.redisLikeDemo.domain.DTO.UserLikeCountDTO;
importcom.csu.edu.redisLikeDemo.domain.DTO.UserLikesDTO;

importjava.util.List;

/**
*负责将数据写入Redis缓存
*/
publicinterfaceRedisService{
/**
*获取点赞状态
*@paraminfoId
*@paramlikeUserId
*/
IntegergetLikeStatus(StringinfoId,StringlikeUserId);
/**
*点赞。状态为1
*@paraminfoId
*@paramlikeUserId
*/
voidsaveLiked2Redis(StringinfoId,StringlikeUserId);

/**
*取消点赞。将状态改变为0
*@paraminfoId
*@paramlikeUserId
*/
voidunlikeFromRedis(StringinfoId,StringlikeUserId);

/**
*从Redis中删除一条点赞数据
*@paraminfoId
*@paramlikeUserId
*/
voiddeleteLikedFromRedis(StringinfoId,StringlikeUserId);

/**
*该内容的点赞数变化Δdelta
*@paraminfoId
*/
voidin_decrementLikedCount(StringinfoId,Integerdelta);

/**
*获取Redis中存储的所有点赞数据
*@return
*/
ListgetLikedDataFromRedis();

/**
*获取Redis中存储的所有点赞数量
*@return
*/
ListgetLikedCountFromRedis();
}

implement

importcom.csu.edu.redisLikeDemo.common.CONSTANT;
importcom.csu.edu.redisLikeDemo.domain.DTO.UserLikeCountDTO;
importcom.csu.edu.redisLikeDemo.domain.DTO.UserLikesDTO;
importcom.csu.edu.redisLikeDemo.service.RedisService;
importcom.csu.edu.redisLikeDemo.util.LocalDateTimeConvertUtil;
importcom.csu.edu.redisLikeDemo.util.RedisKeyUtils;
importlombok.extern.slf4j.Slf4j;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.data.redis.core.Cursor;
importorg.springframework.data.redis.core.HashOperations;
importorg.springframework.data.redis.core.ScanOptions;
importorg.springframework.stereotype.Service;

importjava.time.LocalDateTime;
importjava.util.ArrayList;
importjava.util.HashMap;
importjava.util.List;
importjava.util.Map;

@Service("redisService")
@Slf4j
publicclassRedisServiceImplimplementsRedisService{

@Autowired
privateHashOperationsredisHash;//RedisHash

@Override
publicIntegergetLikeStatus(StringinfoId,StringlikeUserId){
if(redisHash.hasKey(RedisKeyUtils.MAP_KEY_USER_LIKED,RedisKeyUtils.getLikedKey(infoId,likeUserId))){
HashMapmap=(HashMap)redisHash.get(RedisKeyUtils.MAP_KEY_USER_LIKED,RedisKeyUtils.getLikedKey(infoId,likeUserId));
return(Integer)map.get("status");
}
returnCONSTANT.LikedStatusEum.NOT_EXIST.getCode();
}

@Override
publicvoidsaveLiked2Redis(StringinfoId,StringlikeUserId){
//生成key
Stringkey=RedisKeyUtils.getLikedKey(infoId,likeUserId);
//封装value喜欢状态更新时间
HashMapmap=newHashMap<>();
map.put("status",CONSTANT.LikedStatusEum.LIKE.getCode());
map.put("updateTime",System.currentTimeMillis());

redisHash.put(RedisKeyUtils.MAP_KEY_USER_LIKED,key,map);
}

@Override
publicvoidunlikeFromRedis(StringinfoId,StringlikeUserId){
//生成key
Stringkey=RedisKeyUtils.getLikedKey(infoId,likeUserId);
//封装value喜欢状态更新时间
HashMapmap=newHashMap<>();
map.put("status",CONSTANT.LikedStatusEum.UNLIKE.getCode());
map.put("updateTime",System.currentTimeMillis());//存入当前时间戳

redisHash.put(RedisKeyUtils.MAP_KEY_USER_LIKED,key,map);
}

@Override
publicvoiddeleteLikedFromRedis(StringinfoId,StringlikeUserId){
Stringkey=RedisKeyUtils.getLikedKey(infoId,likeUserId);
redisHash.delete(RedisKeyUtils.MAP_KEY_USER_LIKED,key);
}

@Override
publicvoidin_decrementLikedCount(StringinfoId,Integerdelta){
redisHash.increment(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT,infoId,delta);
}

@Override
publicListgetLikedDataFromRedis(){
//scan读取数据，比key匹配优雅
Cursor>cursor=redisHash.scan(RedisKeyUtils.MAP_KEY_USER_LIKED,ScanOptions.NONE);

Listlist=newArrayList<>();
while(cursor.hasNext()){
Map.Entryentry=cursor.next();
Stringkey=(String)entry.getKey();
//分离出infoId，likedPostId,解析value
String[]split=key.split("::");
StringinfoId=split[0];
StringlikeUserId=split[1];
HashMapmap=(HashMap)entry.getValue();
Integerstatus=(Integer)map.get("status");
longupdateTimeStamp=(long)map.get("updateTime");
LocalDateTimeupdateTime=LocalDateTimeConvertUtil.getDateTimeOfTimestamp(updateTimeStamp);//时间戳转为LocalDateTime

//组装成UserLike对象
UserLikesDTOuserLikesDTO=newUserLikesDTO(infoId,likeUserId,status,updateTime);
list.add(userLikesDTO);

//存到list后从Redis中清理缓存
redisHash.delete(RedisKeyUtils.MAP_KEY_USER_LIKED,key);
}
returnlist;
}

@Override
publicListgetLikedCountFromRedis(){
//scan读取数据，比key匹配优雅
Cursor>cursor=redisHash.scan(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT,ScanOptions.NONE);
Listlist=newArrayList<>();
while(cursor.hasNext()){
Map.Entrymap=cursor.next();
//将点赞数量存储在LikedCountDT
Stringkey=(String)map.getKey();
UserLikeCountDTOdto=newUserLikeCountDTO(key,(Integer)map.getValue());
list.add(dto);
//从Redis中删除这条记录
redisHash.delete(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT,key);
}
returnlist;
}
}

2.5 controller & API

controller

importcom.csu.edu.redisLikeDemo.common.CommonResponse;
importcom.csu.edu.redisLikeDemo.service.LikeService;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.web.bind.annotation.PostMapping;
importorg.springframework.web.bind.annotation.RequestMapping;
importorg.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test/")
publicclassLikeController{
@Autowired
privateLikeServicelikeService;

@PostMapping("like")
publicCommonResponse