Redis高效實現點贊、取消點贊只需這四步

資料和雲發表於2020-01-13

Redis

來自：掘金，作者： solocoder

連結：https://juejin.im/post/5bdc257e6fb9a049ba410098

本文基於 SpringCloud, 使用者發起點贊、取消點贊後先存入 Redis 中，再每隔兩小時從 Redis 讀取點贊資料寫入資料庫中做持久化儲存。

點贊功能在很多系統中都有，但別看功能小，想要做好需要考慮的東西還挺多的。

點贊、取消點贊是高頻次的操作，若每次都讀寫資料庫，大量的操作會影響資料庫效能，所以需要做快取。

至於多久從 Redis 取一次資料存到資料庫中，根據專案的實際情況定吧，我是暫時設了兩個小時。

專案需求需要檢視都誰點讚了，所以要儲存每個點讚的點贊人、被點贊人，不能簡單的做計數。

文章分四部分介紹：

Redis 快取設計及實現
資料庫設計
資料庫操作
開啟定時任務持久化儲存到資料庫

一、Redis 快取設計及實現

1.1 Redis 安裝及執行

Redis 安裝請自行查閱相關教程。

說下Docker 安裝執行 Redis


docker 
run 
-d 
-p 6379
:6379 
redis
:4.0.8

如果已經安裝了 Redis，開啟命令列，輸入啟動 Redis 的命令

redis-
server

1.2 Redis 與 SpringBoot 專案的整合

1.在 pom.xml 中引入依賴


<
dependency>

    
<
groupId>org.springframework.boot
</
groupId>

    
<
artifactId>spring-boot-starter-data-redis
</
artifactId>


</
dependency>

2.在啟動類上新增註釋 @EnableCaching


@SpringBootApplication


@EnableDiscoveryClient


@EnableSwagger2


@EnableFeignClients(basePackages = 
"com.solo.coderiver.project.client")


@EnableCaching


public 

class 
UserApplication {



    

public 
static 
void 
main
(String[] args) {

        SpringApplication.run(UserApplication.class, args);

    }

}

3.編寫 Redis 配置類 RedisConfig


import com.fasterxml.jackson.
annotation.JsonAutoDetect;


import com.fasterxml.jackson.
annotation.PropertyAccessor;


import com.fasterxml.jackson.databind.ObjectMapper;


import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;


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.core.StringRedisTemplate;


import org.springframework.
data.redis.serializer.Jackson2JsonRedisSerializer;




import java.net.UnknownHostException;






@Configuration


public 

class 
RedisConfig {



    
@Bean

    
@ConditionalOnMissingBean(name = 
"redisTemplate")

    
public RedisTemplate<String, Object> redisTemplate(

            RedisConnectionFactory redisConnectionFactory)

            throws UnknownHostException {



        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.
class);

        ObjectMapper om = new ObjectMapper();

        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        jackson2JsonRedisSerializer.setObjectMapper(om);



        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();

        template.setConnectionFactory(redisConnectionFactory);

        template.setKeySerializer(jackson2JsonRedisSerializer);

        template.setValueSerializer(jackson2JsonRedisSerializer);

        template.setHashKeySerializer(jackson2JsonRedisSerializer);

        template.setHashValueSerializer(jackson2JsonRedisSerializer);

        template.afterPropertiesSet();

        
return template;

    }





    
@Bean

    
@ConditionalOnMissingBean(StringRedisTemplate.class)

    
public StringRedisTemplate stringRedisTemplate(

            RedisConnectionFactory redisConnectionFactory)

            throws UnknownHostException {

        StringRedisTemplate template = new StringRedisTemplate();

        template.setConnectionFactory(redisConnectionFactory);

        
return template;

    }

}

至此 Redis 在 SpringBoot 專案中的配置已經完成，可以愉快的使用了。

1.3 Redis 的資料結構型別

Redis 可以儲存鍵與5種不同資料結構型別之間的對映，這5種資料結構型別分別為String（字串）、List（列表）、Set（集合）、Hash（雜湊）和 Zset（有序集合）。

下面來對這5種資料結構型別作簡單的介紹：

1.4 點贊資料在 Redis 中的儲存格式

用 Redis 儲存兩種資料，一種是記錄點贊人、被點贊人、點贊狀態的資料，另一種是每個使用者被點讚了多少次，做個簡單的計數。

由於需要記錄點贊人和被點贊人，還有點贊狀態（點贊、取消點贊），還要固定時間間隔取出 Redis 中所有點贊資料，分析了下 Redis 資料格式中 Hash 最合適。

因為 Hash 裡的資料都是存在一個鍵裡，可以通過這個鍵很方便的把所有的點贊資料都取出。這個鍵裡面的資料還可以存成鍵值對的形式，方便存入點贊人、被點贊人和點贊狀態。

設點贊人的 id 為 likedPostId，被點贊人的 id 為 likedUserId ，點贊時狀態為 1，取消點贊狀態為 0。將點贊人 id 和被點贊人 id 作為鍵，兩個 id 中間用 :: 隔開，點贊狀態作為值。

所以如果使用者點贊，儲存的鍵為：likedUserId::likedPostId，對應的值為 1 。取消點贊，儲存的鍵為：likedUserId::likedPostId，對應的值為 0 。取資料時把鍵用 :: 切開就得到了兩個id，也很方便。

在視覺化工具 RDM 中看到的是這樣子

1.5 操作 Redis

將具體操作方法封裝到了 RedisService 介面裡

RedisService.java


import com.solo.coderiver.user.dataobject.UserLike;


import com.solo.coderiver.user.dto.LikedCountDTO;




import java.util.List;




public 

interface 
RedisService {



    
/**

     * 點贊。狀態為1

     * 
@param likedUserId

     * 
@param likedPostId

     */

    

void 
saveLiked2Redis
(String likedUserId, String likedPostId);



    
/**

     * 取消點贊。將狀態改變為0

     * 
@param likedUserId

     * 
@param likedPostId

     */

    

void 
unlikeFromRedis
(String likedUserId, String likedPostId);



    
/**

     * 從Redis中刪除一條點贊資料

     * 
@param likedUserId

     * 
@param likedPostId

     */

    

void 
deleteLikedFromRedis
(String likedUserId, String likedPostId);



    
/**

     * 該使用者的點贊數加1

     * 
@param likedUserId

     */

    

void 
incrementLikedCount
(String likedUserId);



    
/**

     * 該使用者的點贊數減1

     * 
@param likedUserId

     */

    

void 
decrementLikedCount
(String likedUserId);



    
/**

     * 獲取Redis中儲存的所有點贊資料

     * 
@return

     */

    
List<UserLike> 
getLikedDataFromRedis
();



    
/**

     * 獲取Redis中儲存的所有點贊數量

     * 
@return

     */

    
List<LikedCountDTO> 
getLikedCountFromRedis
();



}

實現類 RedisServiceImpl.java


import com.solo.coderiver.user.dataobject.UserLike;


import com.solo.coderiver.user.dto.LikedCountDTO;


import com.solo.coderiver.user.enums.LikedStatusEnum;


import com.solo.coderiver.user.service.LikedService;


import com.solo.coderiver.user.service.RedisService;


import com.solo.coderiver.user.utils.RedisKeyUtils;


import lombok.extern.slf4j.Slf4j;


import org.springframework.beans.
factory.annotation.Autowired;


import org.springframework.data.redis.core.Cursor;


import org.springframework.data.redis.core.RedisTemplate;


import org.springframework.data.redis.core.ScanOptions;


import org.springframework.stereotype.Service;




import java.util.ArrayList;


import java.util.
List;


import java.util.
Map;




@Service


@Slf4j

public 

class 
RedisServiceImpl 
implements 
RedisService {



    
@Autowired

    RedisTemplate redisTemplate;



    
@Autowired

    LikedService likedService;



    
@Override

    public 
void saveLiked2Redis(
String likedUserId, 
String likedPostId) {

        
String key = RedisKeyUtils.getLikedKey(likedUserId, likedPostId);

        redisTemplate.opsForHash().put(RedisKeyUtils.MAP_KEY_USER_LIKED, key, LikedStatusEnum.LIKE.getCode());

    }



    
@Override

    public 
void unlikeFromRedis(
String likedUserId, 
String likedPostId) {

        
String key = RedisKeyUtils.getLikedKey(likedUserId, likedPostId);

        redisTemplate.opsForHash().put(RedisKeyUtils.MAP_KEY_USER_LIKED, key, LikedStatusEnum.UNLIKE.getCode());

    }



    
@Override

    public 
void deleteLikedFromRedis(
String likedUserId, 
String likedPostId) {

        
String key = RedisKeyUtils.getLikedKey(likedUserId, likedPostId);

        redisTemplate.opsForHash().delete(RedisKeyUtils.MAP_KEY_USER_LIKED, key);

    }



    
@Override

    public 
void incrementLikedCount(
String likedUserId) {

        redisTemplate.opsForHash().increment(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, likedUserId, 
1);

    }



    
@Override

    public 
void decrementLikedCount(
String likedUserId) {

        redisTemplate.opsForHash().increment(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, likedUserId, 
-1);

    }



    
@Override

    public 
List<UserLike> getLikedDataFromRedis() {

        Cursor<
Map.Entry<
Object, 
Object>> cursor = redisTemplate.opsForHash().scan(RedisKeyUtils.MAP_KEY_USER_LIKED, ScanOptions.NONE);

        
List<UserLike> list = 
new ArrayList<>();

        
while (cursor.hasNext()){

            
Map.Entry<
Object, 
Object> entry = cursor.next();

            
String key = (
String) entry.getKey();

            
//分離出 likedUserId，likedPostId

            
String[] split = key.split(
"::");

            
String likedUserId = split[
0];

            
String likedPostId = split[
1];

            Integer value = (Integer) entry.getValue();



            
//組裝成 UserLike 物件

            UserLike userLike = 
new UserLike(likedUserId, likedPostId, value);

            list.add(userLike);



            
//存到 list 後從 Redis 中刪除

            redisTemplate.opsForHash().delete(RedisKeyUtils.MAP_KEY_USER_LIKED, key);

        }



        
return list;

    }



    
@Override

    public 
List<LikedCountDTO> getLikedCountFromRedis() {

        Cursor<
Map.Entry<
Object, 
Object>> cursor = redisTemplate.opsForHash().scan(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, ScanOptions.NONE);

        
List<LikedCountDTO> list = 
new ArrayList<>();

        
while (cursor.hasNext()){

            
Map.Entry<
Object, 
Object> map = cursor.next();

            
//將點贊數量儲存在 LikedCountDT

            
String key = (
String)map.getKey();

            LikedCountDTO dto = 
new LikedCountDTO(key, (Integer) map.getValue());

            list.add(dto);

            
//從Redis中刪除這條記錄

            redisTemplate.opsForHash().delete(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, key);

        }

        
return list;

    }

}

用到的工具類和列舉類

RedisKeyUtils, 用於根據一定規則生成 key


public 

class 
RedisKeyUtils {



    
//儲存使用者點贊資料的key

    
public 
static 
final String MAP_KEY_USER_LIKED = 
"MAP_USER_LIKED";

    
//儲存使用者被點贊數量的key

    
public 
static 
final String MAP_KEY_USER_LIKED_COUNT = 
"MAP_USER_LIKED_COUNT";



    
/**

     * 拼接被點讚的使用者id和點讚的人的id作為key。格式 222222::333333

     * 
@param likedUserId 被點讚的人id

     * 
@param likedPostId 點讚的人的id

     * 
@return

     */

    

public 
static String 
getLikedKey
(String likedUserId, String likedPostId){

        StringBuilder builder = 
new StringBuilder();

        builder.append(likedUserId);

        builder.append(
"::");

        builder.append(likedPostId);

        
return builder.toString();

    }

}

LikedStatusEnum 使用者點贊狀態的列舉類


package com.solo.coderiver.user.enums;




import lombok.Getter;




/**

 * 使用者點讚的狀態

 */


@Getter


public 
enum LikedStatusEnum {

    LIKE(
1, 
"點贊"),

    UNLIKE(
0, 
"取消點贊/未點贊"),

    ;



    
private Integer code;



    
private String msg;



    LikedStatusEnum(Integer code, String msg) {

        
this.code = code;

        
this.msg = msg;

    }

}

二、資料庫設計

資料庫表中至少要包含三個欄位：被點贊使用者id，點贊使用者id，點贊狀態。再加上主鍵id，建立時間，修改時間就行了。

建表語句


create 
table 
`user_like`(

    
`id` 
int 
not 
null auto_increment,

    
`liked_user_id` 
varchar(
32) 
not 
null 
comment 
'被點讚的使用者id',

    
`liked_post_id` 
varchar(
32) 
not 
null 
comment 
'點讚的使用者id',

    
`status` tinyint(
1) 
default 
'1' 
comment 
'點贊狀態，0取消，1點贊',

    
`create_time` 
timestamp 
not 
null 
default 
current_timestamp 
comment 
'建立時間',

  
`update_time` 
timestamp 
not 
null 
default 
current_timestamp 
on 
update 
current_timestamp 
comment 
'修改時間',

    primary 
key(
`id`),

    
INDEX 
`liked_user_id`(
`liked_user_id`),

    
INDEX 
`liked_post_id`(
`liked_post_id`)

) 
comment 
'使用者點贊表';

對應的物件 UserLike


import com.solo.coderiver.user.enums.LikedStatusEnum;


import lombok.Data;




import javax.persistence.Entity;


import javax.persistence.GeneratedValue;


import javax.persistence.GenerationType;


import javax.persistence.Id;




/**

 * 使用者點贊表

 */


@Entity


@Data


public 

class 
UserLike {



    
//主鍵id

    
@Id

    
@GeneratedValue(strategy = GenerationType.IDENTITY)

    
private Integer id;



    
//被點讚的使用者的id

    
private String likedUserId;



    
//點讚的使用者的id

    
private String likedPostId;



    
//點讚的狀態.預設未點贊

    
private Integer status = LikedStatusEnum.UNLIKE.getCode();



    
public UserLike() {

    }



    
public UserLike(String likedUserId, String likedPostId, Integer status) {

        
this.likedUserId = likedUserId;

        
this.likedPostId = likedPostId;

        
this.status = status;

    }

}

三、資料庫操作

運算元據庫同樣封裝在介面中

LikedService


import com.solo.coderiver.user.dataobject.UserLike;


import org.springframework.data.domain.Page;


import org.springframework.data.domain.Pageable;




import java.util.List;




public 

interface 
LikedService {



    
/**

     * 儲存點贊記錄

     * 
@param userLike

     * 
@return

     */

    
UserLike 
save
(UserLike userLike);



    
/**

     * 批量儲存或修改

     * 
@param list

     */

    
List<UserLike> 
saveAll
(List<UserLike> list);





    
/**

     * 根據被點贊人的id查詢點贊列表（即查詢都誰給這個人點贊過）

     * 
@param likedUserId 被點贊人的id

     * 
@param pageable

     * 
@return

     */

    
Page<UserLike> 
getLikedListByLikedUserId
(String likedUserId, Pageable pageable);



    
/**

     * 根據點贊人的id查詢點贊列表（即查詢這個人都給誰點贊過）

     * 
@param likedPostId

     * 
@param pageable

     * 
@return

     */

    
Page<UserLike> 
getLikedListByLikedPostId
(String likedPostId, Pageable pageable);



    
/**

     * 通過被點贊人和點贊人id查詢是否存在點贊記錄

     * 
@param likedUserId

     * 
@param likedPostId

     * 
@return

     */

    
UserLike 
getByLikedUserIdAndLikedPostId
(String likedUserId, String likedPostId);



    
/**

     * 將Redis裡的點贊資料存入資料庫中

     */

    

void 
transLikedFromRedis2DB
();



    
/**

     * 將Redis中的點贊數量資料存入資料庫

     */

    

void 
transLikedCountFromRedis2DB
();



}

LikedServiceImpl 實現類


import com.solo.coderiver.user.dataobject.UserInfo;


import com.solo.coderiver.user.dataobject.UserLike;


import com.solo.coderiver.user.dto.LikedCountDTO;


import com.solo.coderiver.user.enums.LikedStatusEnum;


import com.solo.coderiver.user.repository.UserLikeRepository;


import com.solo.coderiver.user.service.LikedService;


import com.solo.coderiver.user.service.RedisService;


import com.solo.coderiver.user.service.UserService;


import lombok.extern.slf4j.Slf4j;


import org.springframework.beans.factory.annotation.Autowired;


import org.springframework.data.domain.Page;


import org.springframework.data.domain.Pageable;


import org.springframework.stereotype.Service;


import org.springframework.transaction.annotation.Transactional;




import java.util.List;




@Service


@Slf4j


public 

class 
LikedServiceImpl 
implements 
LikedService {



    
@Autowired

    UserLikeRepository likeRepository;



    
@Autowired

    RedisService redisService;



    
@Autowired

    UserService userService;



    
@Override

    
@Transactional

    

public UserLike 
save
(UserLike userLike) {

        
return likeRepository.save(userLike);

    }



    
@Override

    
@Transactional

    

public List<UserLike> 
saveAll
(List<UserLike> list) {

        
return likeRepository.saveAll(list);

    }



    
@Override

    

public Page<UserLike> 
getLikedListByLikedUserId
(String likedUserId, Pageable pageable) {

        
return likeRepository.findByLikedUserIdAndStatus(likedUserId, LikedStatusEnum.LIKE.getCode(), pageable);

    }



    
@Override

    

public Page<UserLike> 
getLikedListByLikedPostId
(String likedPostId, Pageable pageable) {

        
return likeRepository.findByLikedPostIdAndStatus(likedPostId, LikedStatusEnum.LIKE.getCode(), pageable);

    }



    
@Override

    

public UserLike 
getByLikedUserIdAndLikedPostId
(String likedUserId, String likedPostId) {

        
return likeRepository.findByLikedUserIdAndLikedPostId(likedUserId, likedPostId);

    }



    
@Override

    
@Transactional

    

public 
void 
transLikedFromRedis2DB
() {

        List<UserLike> list = redisService.getLikedDataFromRedis();

        
for (UserLike like : list) {

            UserLike ul = getByLikedUserIdAndLikedPostId(like.getLikedUserId(), like.getLikedPostId());

            
if (ul == 
null){

                
//沒有記錄，直接存入

                save(like);

            }
else{

                
//有記錄，需要更新

                ul.setStatus(like.getStatus());

                save(ul);

            }

        }

    }



    
@Override

    
@Transactional

    

public 
void 
transLikedCountFromRedis2DB
() {

        List<LikedCountDTO> list = redisService.getLikedCountFromRedis();

        
for (LikedCountDTO dto : list) {

            UserInfo user = userService.findById(dto.getId());

            
//點贊數量屬於無關緊要的操作，出錯無需拋異常

            
if (user != 
null){

                Integer likeNum = user.getLikeNum() + dto.getCount();

                user.setLikeNum(likeNum);

                
//更新點贊數量

                userService.updateInfo(user);

            }

        }

    }

}

資料庫的操作就這些，主要還是增刪改查。

四、開啟定時任務持久化儲存到資料庫

定時任務 Quartz 很強大，就用它了。

Quartz 使用步驟：

1.新增依賴


<
dependency>

    
<
groupId>org.springframework.boot
</
groupId>

    
<
artifactId>spring-boot-starter-quartz
</
artifactId>


</
dependency>

2.編寫配置檔案


package com.solo.coderiver.user.config;




import com.solo.coderiver.user.task.LikeTask;


import org.quartz.*;


import org.springframework.context.
annotation.Bean;


import org.springframework.context.
annotation.Configuration;




@Configuration


public 

class 
QuartzConfig {



    
private static 
final String LIKE_TASK_IDENTITY = 
"LikeTaskQuartz";



    
@Bean

    
public JobDetail quartzDetail(){

        
return JobBuilder.newJob(LikeTask.
class).withIdentity(LIKE_TASK_IDENTITY).storeDurably().build();

    }



    
@Bean

    
public Trigger quartzTrigger(){

        SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()


//                .withIntervalInSeconds(10)  //設定時間週期單位秒

                .withIntervalInHours(
2)  
//兩個小時執行一次

                .repeatForever();

        
return TriggerBuilder.newTrigger().forJob(quartzDetail())

                .withIdentity(LIKE_TASK_IDENTITY)

                .withSchedule(scheduleBuilder)

                .build();

    }

}

3.編寫執行任務的類繼承自 QuartzJobBean


package com.solo.coderiver.user.task;




import com.solo.coderiver.user.service.LikedService;


import lombok.extern.slf4j.Slf4j;


import org.apache.commons.lang.time.DateUtils;


import org.quartz.JobExecutionContext;


import org.quartz.JobExecutionException;


import org.springframework.beans.factory.annotation.Autowired;


import org.springframework.scheduling.quartz.QuartzJobBean;




import java.text.SimpleDateFormat;


import java.util.Date;




/**

 * 點讚的定時任務

 */


@Slf4j


public 

class 
LikeTask 
extends 
QuartzJobBean {



    
@Autowired

    LikedService likedService;



    
private SimpleDateFormat sdf = 
new SimpleDateFormat(
"yyyy-MM-dd HH:mm:ss");



    
@Override

    

protected 
void 
executeInternal
(JobExecutionContext jobExecutionContext) 
throws JobExecutionException {



        log.info(
"LikeTask-------- {}", sdf.format(
new Date()));



        
//將 Redis 裡的點贊資訊同步到資料庫裡

        likedService.transLikedFromRedis2DB();

        likedService.transLikedCountFromRedis2DB();

    }

}

在定時任務中直接呼叫 LikedService 封裝的方法完成資料同步。

以上就是點贊功能的設計與實現，不足之處還請各位大佬多多指教。

另外，點贊/取消點贊跟點贊數 +1/ -1 應該保證是原子操作 , 不然出現併發問題就會有兩條重複的點贊記錄 , 所以要給整個原子操作加鎖 . 同時需要在Spring Boot 的系統關閉鉤子函式中補充同步redis中點贊資料到mysql中的過程 . 不然有可能出現距離上一次同步1小時59分的時候伺服器更新 , 把整整兩小時的點贊資料都給清空了 . 如果點贊設計到比較重要活動業務的話這就很尷尬了 .

想了解更多關於資料庫、雲技術的內容嗎？

快來關注“資料和雲"、"雲和恩墨，"公眾號及"雲和恩墨"官方網站，我們期待大家一同學習與進步！