Using redis skillfully to realize the like function, isn't it more fragrant than MySQL?

Mention something like , When you think of it, is it the praise of the circle of friends ？ In fact, praise is no stranger to us , We often see it in web pages or software on mobile phones , Today, let's take a look at its implementation . Our common design ideas can be divided into two types ： One kind of nature is to use MySQL Wait for the database to be stored directly ,  The other is to save the data of likes to Redis Wait in the cache , Brush back after a certain time MySQL Such as the database .

First, let's talk about the advantages and disadvantages of the two methods ： We use MySQL and Redis For example .

1、 Write directly to the database ：

advantage ：

  This method is easy to implement , Just complete the addition, deletion, modification and query of the database ;

shortcoming ：

  Database reading and writing pressure is high , If you encounter a situation where a lot of popular articles are liked in a short time , Directly operating the database will bring great pressure to the database , Affect efficiency .

2、 Use Redis cache ：

advantage ：

  High performance , Fast reading and writing , Ease the pressure of database reading and writing ;

shortcoming ：

  Development is complex , Data security cannot be guaranteed, i.e redis When you hang up, you lose data ,  At the same time, it is not synchronized in time redis Data in ,  May be in redis Memory replacement is eliminated . But we don't need to be so precise about the likes data , It's not a problem to lose a little data .

Next, we will introduce the like function in detail from the following three aspects

•Redis  Cache design • Database design • Enable scheduled task persistence to database

1、Redis Cache design and implementation

Redis The integration of has been introduced in the last article , I won't go into details here . We learned that , We need to record the following types of data when making a compliment ： One is the detailed record of a user being liked by other users , One is . Considering the convenience of query and access , I use Hash Structure for storage , The storage structure is as follows ：

（1） A detailed record of a user being liked by other users ：

MAP_USER_LIKED

Key value ,

Be liked by users id:: Like user id

by filed,

1 perhaps 0

by value

（2） Statistics on the number of likes of a user ：

MAP_USER_LIKED_COUNT

Key value ,

Be liked by users id

by filed,

count

by value

Part of the code is as follows ：

/**
*  Save the data that users like by other users to redis
*/
@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());
}

// Cancel likes
@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());
}

/**
*  Number of users who will be liked +1
*/
@Override
public void incrementLikedCount(String likedUserId) {
 redisTemplate.opsForHash().increment(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT,likedUserId,1);
}

//-1
@Override
public void decrementLikedCount(String likedUserId) {
 redisTemplate.opsForHash().increment(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, likedUserId, -1);
}

/**
*  obtain Redis User likes details record in
*/
@Override
public List<UserLikeDetail> getLikedDataFromRedis() {
 Cursor<Map.Entry<Object,Object>> scan = redisTemplate.opsForHash().scan(RedisKeyUtils.MAP_KEY_USER_LIKED, ScanOptions.NONE);
 List<UserLikeDetail> list = new ArrayList<>();
 while (scan.hasNext()){
 Map.Entry<Object, Object> entry = scan.next();
 String key = (String) entry.getKey();
 String[] split = key.split(&quot;::&quot;);
 String likedUserId = split[0];
 String likedPostId = split[1];
 Integer value = (Integer) entry.getValue();
 // Assemble into  UserLike  object
 UserLikeDetail userLikeDetail = new UserLikeDetail(likedUserId, likedPostId, value);
 list.add(userLikeDetail);
 // Deposit in  list  From  Redis  Delete in
 redisTemplate.opsForHash().delete(RedisKeyUtils.MAP_KEY_USER_LIKED, key);
 }
 return list;
}

/**
*  obtain Redis The number of users like in
*/
@Override
public List<UserLikCountDTO> getLikedCountFromRedis() {
 Cursor<Map.Entry<Object,Object>> cursor = redisTemplate.opsForHash().scan(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, ScanOptions.NONE);
 List<UserLikCountDTO> list = new ArrayList<>();
 while(cursor.hasNext()){
 Map.Entry<Object, Object> map = cursor.next();
 String key = (String) map.getKey();
 Integer value = (Integer) map.getValue();
 UserLikCountDTO userLikCountDTO = new UserLikCountDTO(key,value);
 list.add(userLikCountDTO);
 // Deposit in  list  From  Redis  Delete in
 redisTemplate.opsForHash().delete(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT,key);
 }
 return list;
}


Redis The storage structure is shown in the figure

2、 Database design

Here we can save the likes data to the database directly , Design two tables ：

(1) Detailed records of users being liked by other users :user_like_detail

DROP TABLE IF EXISTS `user_like_detail`;
CREATE TABLE `user_like_detail` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `liked_user_id` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT ' Liked users id',
 `liked_post_id` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT ' Thumb up users id',
 `status` tinyint(1) NULL DEFAULT 1 COMMENT ' Like status ,0 Cancel ,1 give the thumbs-up ',
 `create_time` timestamp(0) NOT NULL DEFAULT CURRENT_TIMESTAMP(0) COMMENT ' Creation time ',
 `update_time` timestamp(0) NOT NULL DEFAULT CURRENT_TIMESTAMP(0) ON UPDATE CURRENT_TIMESTAMP(0) COMMENT ' Modification time ',
 PRIMARY KEY (`id`) USING BTREE,
 INDEX `liked_user_id`(`liked_user_id`) USING BTREE,
 INDEX `liked_post_id`(`liked_post_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 7 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = ' The user likes the watch ' ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;


(2) Statistics on the number of users being liked :user_like_count

DROP TABLE IF EXISTS `user_like_count`;
CREATE TABLE `user_like_count` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `like_num` int(11) NULL DEFAULT 0,
 PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 7 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;


3、 Enable scheduled task persistence to database

We use Quartz To achieve timing tasks , take Redis Store the data in the database , For demonstration , We can set one or two minutes to store data , This depends on the specific business . In the process of synchronizing data , First of all, we need to Redis The data in is checked in the database , Discard duplicate data , In this way, our data will be more accurate .

Part of the code is as follows

// Sync redis The user likes the data to the database
@Override
@Transactional
public void transLikedFromRedis2DB() {
 List<UserLikeDetail> list = redisService.getLikedDataFromRedis();
 list.stream().forEach(item->{
 // Duplicate check
 UserLikeDetail userLikeDetail = userLikeDetailMapper.selectOne(new LambdaQueryWrapper<UserLikeDetail>()
 .eq(UserLikeDetail::getLikedUserId, item.getLikedUserId())
 .eq(UserLikeDetail::getLikedPostId, item.getLikedPostId()));
 if (userLikeDetail == null){
 userLikeDetail = new UserLikeDetail();
 BeanUtils.copyProperties(item, userLikeDetail);
 // There is no record , Deposit directly into
 userLikeDetail.setCreateTime(LocalDateTime.now());
 userLikeDetailMapper.insert(userLikeDetail);
 }else{
 // Records , You need to update
 userLikeDetail.setStatus(item.getStatus());
 userLikeDetail.setUpdateTime(LocalDateTime.now());
 userLikeDetailMapper.updateById(item);
 }
 });
}

@Override
@Transactional
public void transLikedCountFromRedis2DB() {
 List<UserLikCountDTO> list = redisService.getLikedCountFromRedis();
 list.stream().forEach(item->{
 UserLikeCount user = userLikeCountMapper.selectById(item.getKey());
 // The number of likes is irrelevant , You don't need to throw exceptions if you make mistakes
 if (user != null){
 Integer likeNum = user.getLikeNum() + item.getValue();
 user.setLikeNum(likeNum);
 // Update likes
 userLikeCountMapper.updateById(user);
 }
 });
}


So far, we have realized the design based on Redis Like function , We need to pay more attention to ： When querying user likes , You need to query the database at the same time + Data in cache .

o  Q  Will continue to update  java  Practical articles , If you have a different opinion or a better one  idea, Welcome to contact ah  Q.

【 o  Q  Say code 】, Notable official account

The style of the article is changeable , The pictures are easy to understand , The story is vivid and interesting , Let's talk about technology ！