Initial redis experience

For the first time in a project redis, The like function I wrote is frequently used , So I chose to use redis. This is the beginning of my pain , I thought the like function was very easy to write, and the result was so troublesome , Because save to redis Inside key Value problem , I thought about it for a long time , It's finally settled . But I found that the post was like , Collection of Posts , Like the album , Album Collection , These are similar . It's a lot faster in the back .
Use redis There are some problems .
Because I didn't give it at first redis encryption key , And in root Run on user , This will lead to the behavior of attacking the port , And then my 6379 The port was blocked for a day . So I changed the port number , Run on another user . however …, Because you didn't give the other user enough permission , Always reporting errors frequently . In the end, it was solved .
Think about this solution redis Like the code to show .

First you need a RedisKeyUtils, Get to exist redis Inside key value

public class RedisKeyUtils {
    

    // Save the user's favorite data key
    public static final String MAP_KEY_USER_LIKED = "MAP_USER_LIKED";
    // Save the number of likes the user has key
    public static final String MAP_KEY_USER_LIKED_COUNT = "MAP_USER_LIKED_COUNT";
    // Save popular recommended posts 
    /** *  Splicing the likes of posts id With someone who likes it id As key. Format  222222::333333 * @param likedUserId  Someone who likes id * @param likedPostId  Like the post id * @return */
    public static String getLikedKey(String likedUserId, String likedPostId){
    
        StringBuilder builder = new StringBuilder();
        builder.append(likedPostId);
        builder.append("::");
        builder.append(likedUserId);

        return builder.toString();
    }
   

Entity classes that users like UserLike ：

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class UserLike {
    
    /** * id */
    private int id;

    /** *  Like people id */
    private Integer userId;

    /** *  Like the post id */
    private Integer postId;
    /** *  Time  */
    private String time;

    /** *  Like status  */
    private Integer status;

    public UserLike(Integer userId,Integer postId,Integer status){
    
        this.userId = userId;
        this.status = status;
        this.postId = postId;
    }
}

Like quantity entity class LikedCountDTO ：

package future.image.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class LikedCountDTO {
    

    /** *  post id */
    private String id;

    /** *  Number of likes  */
    private int count;
}

One redis Of service, It defines the methods needed for likes .

import future.image.pojo.*;
import future.image.utils.Result;

import java.util.List;

/** * @author zrl */
public interface RedisService {
    

    /** *  give the thumbs-up . Status as 1 * @param likedUserId * @param likedPostId */
    void saveLiked2Redis(String likedUserId, String likedPostId);


    /** *  Cancel likes . Change the state to 0 * @param likedUserId * @param likedPostId */
    void unlikeFromRedis(String likedUserId, String likedPostId);

    /** *  from Redis Delete a likes data in  * @param likedUserId * @param likedPostId */
    void deleteLikedFromRedis(String likedUserId, String likedPostId);

    /** *  The number of likes of the user plus 1 * @param likedPostId */
    void incrementLikedCount(String likedPostId);

    /** *  The user's likes are decreased 1 * @param likedPostId */
    void decrementLikedCount(String likedPostId);

    /** *  obtain Redis All likes stored in  * @return */
    List<UserLike> getLikedDataFromRedis();

    /** *  obtain Redis All likes stored in  * @return */
    List<LikedCountDTO> getLikedCountFromRedis();


    /** *  Thumb up number  */
    Result getThumbUpCount(Integer postId);
}

And its implementation class RedisServiceImpl

import future.image.dao.CollectMapper;
import future.image.dao.ForumMapper;
import future.image.pojo.*;
import future.image.service.LikedService;
import future.image.service.RedisService;
import future.image.utils.RedisKeyUtils;
import future.image.utils.RedisUtil;
import future.image.utils.Result;
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 javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/** * @author zrl */
@Service("redisService")
public class RedisServiceImpl implements RedisService {
    

    @Resource
    RedisTemplate redisTemplate;

    @Resource
    LikedService likedService;

    @Resource
    ForumMapper forumMapper;

    @Resource
    RedisUtil redisUtil;

    @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 likedPostId) {
    
        boolean flag = redisTemplate.opsForHash().hasKey(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT,likedPostId);
        if(flag){
    
            redisTemplate.opsForHash().increment(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, likedPostId, 1);
        }else{
    
            int count = forumMapper.getThumbUpCount(Integer.parseInt(likedPostId));
            redisTemplate.opsForHash().increment(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, likedPostId, count+1);
        }
    }




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

    @Override
    public void decrementCollectForumCount(String postId) {
    
        boolean flag = redisTemplate.opsForHash().hasKey(RedisKeyUtils.MAP_KEY_COLLECT_FORUM_COUNT,postId);
        if(flag){
    
            redisTemplate.opsForHash().increment(RedisKeyUtils.MAP_KEY_COLLECT_FORUM_COUNT, postId, -1);
        }else{
    
            int count = collectMapper.getCollectForumCount(Integer.parseInt(postId));
            redisTemplate.opsForHash().increment(RedisKeyUtils.MAP_KEY_COLLECT_FORUM_COUNT, postId, count-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();
            // Separate out  likedUserId,likedPostId
            String[] split = key.split("::");
            String likedPostId = split[0];
            String likedUserId = split[1];
            Integer value = (Integer) entry.getValue();

            // Assemble into  UserLike  object 
            UserLike userLike = new UserLike(Integer.parseInt(likedUserId), Integer.parseInt(likedPostId), value);
            list.add(userLike);

            // Deposit in  list  From  Redis  Delete in 
            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();
            // Store the number of likes in  LikedCountDT
            String key = (String)map.getKey();
            LikedCountDTO dto = new LikedCountDTO(key, (Integer) map.getValue());
            list.add(dto);
            // from Redis Delete this record 
            redisTemplate.opsForHash().delete(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, key);
        }
        return list;
    }

    @Override
    public Result getThumbUpCount(Integer postId) {
    
        boolean flag = redisTemplate.opsForHash().hasKey(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT,String.valueOf(postId));
        if(flag){
    
            Object hget = redisUtil.hget(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, String.valueOf(postId));
            return Result.success(hget);
        }else{
    
            int count = forumMapper.getThumbUpCount(postId);
            redisTemplate.opsForHash().put(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, String.valueOf(postId), count);
            return Result.success(count);
        }
    }

Users like service LikedService：

package future.image.service;

import future.image.pojo.UserLike;
import future.image.utils.Result;
import org.apache.ibatis.annotations.Param;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;

import java.util.List;

public interface LikedService {
    

    /** *  Save some likes  * @param userLike * @return */
    Result saveUserLike(UserLike userLike);



    /** *  According to the person who was praised id Query likes list （ That is to say, whoever inquires has praised this person ） * @param postId pageSize pageNum * @return Result */
    Result getLikedListByPostId(Integer postId, Integer pageSize,Integer pageNum);



    /** *  By being praised and praised id Check whether there is a like record  * @param likedUserId * @param likedPostId * @return */
    UserLike getByLikedUserIdAndLikedPostId(Integer likedUserId, Integer likedPostId);

    /** *  take Redis Like data in the database  */
    void transLikedFromRedis2DB();

    /** *  take Redis The number of likes in is stored in the database  */
    void transLikedCountFromRedis2DB();

    /** *  give the thumbs-up  * */
    Result thumbUpForum(@Param("userId")Integer userId, @Param("postId")Integer postId);

    /** *  Get users' likes  */
    Result likeStatus(Integer postId,Integer userId);

}

And likedServiceImpl：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.pagehelper.PageHelper;
import future.image.dao.ForumMapper;
import future.image.dao.LikedMapper;
import future.image.dao.UserMapper;
import future.image.pojo.*;
import future.image.service.LikedService;
import future.image.service.RedisService;
import future.image.utils.RedisKeyUtils;
import future.image.utils.RedisUtil;
import future.image.utils.Result;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@Service("likedService")
public class LikedServiceImpl implements LikedService {
    


    @Resource
    RedisService redisService;

    @Resource
    LikedMapper likedMapper;

    @Resource
    UserMapper userMapper;

    @Resource
    ForumMapper forumMapper;

    @Resource
    RedisUtil redisUtil;


    @Override
    public Result saveUserLike(UserLike userLike) {
    
        int f = likedMapper.savaUserLike(userLike);
        if(f != 1){
    
            return Result.fail(" Save failed ");
        }
        return Result.success();
    }



    @Override
    public Result getLikedListByPostId(Integer postId,Integer pageSize,Integer pageNum) {
    
        PageHelper.startPage(pageNum, pageSize);
        List<UserLike> list = likedMapper.getLikedListByPostId(postId);
        return Result.success(list);
    }



    @Override
    public UserLike getByLikedUserIdAndLikedPostId(Integer likedUserId, Integer likedPostId) {
    
        UserLike userlike = likedMapper.getByLikedUserIdAndLikedPostId(likedUserId,likedPostId);
        return userlike;
    }

    @Override
    public void transLikedFromRedis2DB() {
    
        List<UserLike> list = redisService.getLikedDataFromRedis();
        for (UserLike like : list) {
    
            UserLike ul = getByLikedUserIdAndLikedPostId(like.getUserId(), like.getPostId());
            if (ul == null){
    
                // There is no record , Deposit directly into 
                saveUserLike(like);
            }else{
    
                // Records , You need to update 
                ul.setStatus(like.getStatus());
                likedMapper.updateUserLike(ul);
            }
        }

    }

    @Override
    public void transLikedCountFromRedis2DB() {
    
        List<LikedCountDTO> list = redisService.getLikedCountFromRedis();
        if(list.size() == 0){
    
            return;
        }
        for (LikedCountDTO dto : list) {
    
            // The number of likes is irrelevant , You don't need to throw exceptions if you make mistakes 
            Integer likeNum = dto.getCount();
            // Update likes 
            forumMapper.updateForumThumbUp(Integer.parseInt(dto.getId()),likeNum);
        }
    }

    @Override
    public Result thumbUpForum(Integer userId, Integer postId) {
    
        Object hget = redisUtil.hget(RedisKeyUtils.MAP_KEY_USER_LIKED, postId + "::" + userId);
        if(hget == null){
    
            redisService.saveLiked2Redis(String.valueOf(userId),String.valueOf(postId));
            redisService.incrementLikedCount(String.valueOf(postId));
            return Result.success(1);
        }else if("1".equals(hget.toString())){
    
            redisService.unlikeFromRedis(String.valueOf(userId),String.valueOf(postId));
            redisService.decrementLikedCount(String.valueOf(postId));
            return Result.success(0);
        }else{
    
            redisService.saveLiked2Redis(String.valueOf(userId),String.valueOf(postId));
            redisService.incrementLikedCount(String.valueOf(postId));
            return Result.success(1);
        }
    }

    @Override
    public Result likeStatus(Integer postId, Integer userId) {
    
        Object hget = redisUtil.hget(RedisKeyUtils.MAP_KEY_USER_LIKED, postId + "::" + userId);
        if(hget == null){
    
            Integer like = likedMapper.getUserLikeStatus(postId,userId);
            if(like == null){
    
                return  Result.success(0);
            }
            redisService.saveLiked2Redis(String.valueOf(postId),String.valueOf(userId));
            return Result.success(like);
        }else if("1".equals(hget.toString())){
    
            return Result.success(1);
        }else{
    
            return Result.success(0);
        }
    }
}

There are also some like functions mapper, Operation on Database LikedMapper：

import future.image.pojo.UserLike;

import java.util.List;

/** * @author zrl */
public interface LikedMapper {
    
    /** *  Click like to save  */
    int savaUserLike(UserLike userLike);

    int saveAllUserLike(List<UserLike> userLike);

    int updateUserLike(UserLike userLike);

    List<UserLike> getLikedListByPostId(Integer likedUserId);

    UserLike getByLikedUserIdAndLikedPostId(Integer userId,Integer postId);

    Integer getUserLikeStatus(Integer postId,Integer userId);
}

summary ：
Each assessment is an improvement of one's own skills , I also have practical experience of what I have learned before , The memory is more profound . Exercise your ability in the examination .