Shulou(Shulou.com)05/31 Report--

This article mainly explains the steps for Redis to efficiently like and cancel likes. Friends who are interested may wish to take a look. The method introduced in this paper is simple, fast and practical. Next, let the editor take you to learn "the steps of Redis to efficiently like and cancel likes".

1. Design and implementation of Redis cache 1.1 Redis installation and operation

Please refer to the relevant tutorials for Redis installation.

Talk about Docker installation and run Redis

Docker run-d-p 6379 6379 redis:4.0.8

If Redis is already installed, open the command line and enter the command to start Redis

Redis-server

1.2 Integration of Redis and SpringBoot projects

1. Introducing dependencies into pom.xml

Org.springframework.boot

Spring-boot-starter-data-redis

two。 Add a comment @ EnableCaching to the startup class

@ 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. Write the Redis configuration class 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 redisTemplate (

RedisConnectionFactory redisConnectionFactory)

Throws UnknownHostException {

Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer (Object.class)

ObjectMapper om = new ObjectMapper ()

Om.setVisibility (PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY)

Om.enableDefaultTyping (ObjectMapper.DefaultTyping.NON_FINAL)

Jackson2JsonRedisSerializer.setObjectMapper (om)

RedisTemplate template = new RedisTemplate ()

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

}

}

At this point, the configuration of Redis in the SpringBoot project is complete, and you can use it happily.

1.3 data structure types of Redis

Redis can store the mapping between keys and five different types of data structures, namely String (string), List (list), Set (collection), Hash (hash), and Zset (ordered set).

Here is a brief introduction to these five types of data structures:

1.4 Storage format of like data in Redis

Use Redis to store two kinds of data, one is to record the status of likes, likes, and likes, and the other is to make a simple count of how many times each user has been liked.

Due to the need to record likes and likes, as well as the like status (like and cancel likes), and to take out all the like data in Redis at regular intervals, it is analyzed that Hash is the most appropriate Redis data format.

Because the data in Hash is stored in a key, you can easily take out all the like data through this key. The data in this key can also be stored in the form of key-value pairs, which is convenient for people to be liked, liked and liked.

Set the admirable id as likedPostId, the id of the liked person as likedUserId, the status of likes as 1, and the status of canceling likes as 0. Id and id are used as keys, the two id are separated by::, and the like status is used as the value.

So if the user likes it, the stored key is: likedUserId::likedPostId, and the corresponding value is 1. To cancel giving likes, the key stored is: likedUserId::likedPostId, and the corresponding value is 0. When fetching data, use the key:: cut to get two id, which is also very convenient.

What you see in the visualization tool RDM is like this.

1.5 Operation Redis

The specific operation method is encapsulated in the RedisService interface.

RedisService.java

Import com.solo.coderiver.user.dataobject.UserLike

Import com.solo.coderiver.user.dto.LikedCountDTO

Import java.util.List

Public interface RedisService {

/ * *

* like it. Status is 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)

/ * *

* Delete a like data from Redis

* @ param likedUserId

* @ param likedPostId

, /

Void deleteLikedFromRedis (String likedUserId, String likedPostId)

/ * *

* add 1 to the number of likes given by this user

* @ param likedUserId

, /

Void incrementLikedCount (String likedUserId)

/ * *

* the number of likes of this user minus 1

* @ param likedUserId

, /

Void decrementLikedCount (String likedUserId)

/ * *

* get all the like data stored in Redis

* @ return

, /

List getLikedDataFromRedis ()

/ * *

* get the number of likes stored in Redis

* @ return

, /

List getLikedCountFromRedis ()

}

Implementation class 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 getLikedDataFromRedis () {

Cursor cursor = redisTemplate.opsForHash () .scan (RedisKeyUtils.MAP_KEY_USER_LIKED, ScanOptions.NONE)

List list = new ArrayList ()

While (cursor.hasNext ()) {

Map.Entry entry = cursor.next ()

String key = (String) entry.getKey ()

/ / isolate the likedUserId,likedPostId

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

String likedUserId = split [0]

String likedPostId = split [1]

Integer value = (Integer) entry.getValue ()

/ / assembled into UserLike objects

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

List.add (userLike)

/ / Delete from Redis after saving to list

RedisTemplate.opsForHash () .delete (RedisKeyUtils.MAP_KEY_USER_LIKED key)

}

Return list

}

@ Override

Public List getLikedCountFromRedis () {

Cursor cursor = redisTemplate.opsForHash () .scan (RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, ScanOptions.NONE)

List list = new ArrayList ()

While (cursor.hasNext ()) {

Map.Entry 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)

/ / Delete this record from Redis

RedisTemplate.opsForHash () .delete (RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT key)

}

Return list

}

}

Tool classes and enumeration classes used

RedisKeyUtils, used to generate key according to certain rules

Public class RedisKeyUtils {

/ / key that saves the data of users' likes

Public static final String MAP_KEY_USER_LIKED = "MAP_USER_LIKED"

/ / Save the key of the number of users being liked

Public static final String MAP_KEY_USER_LIKED_COUNT = "MAP_USER_LIKED_COUNT"

/ * *

* splice the id of the liked user and the id of the person who likes it as key. Format 222222virtual virtual 333333

* @ param likedUserId id of the person who is liked

* @ param likedPostId's id of the person who likes

* @ return

, /

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

StringBuilder builder = new StringBuilder ()

Builder.append (likedUserId)

Builder.append (::)

Builder.append (likedPostId)

Return builder.toString ()

}

}

Enumerated class of LikedStatusEnum users' like status

Package com.solo.coderiver.user.enums

Import lombok.Getter

/ * *

* status of users' likes

, /

@ Getter

Public enum LikedStatusEnum {

LIKE (1, "like")

UNLIKE (0, "cancel likes / No likes")

Private Integer code

Private String msg

LikedStatusEnum (Integer code, String msg) {

This.code = code

This.msg = msg

}

Second, database design

The database table must contain at least three fields: like user id, like user id, and like status. Plus the primary key id, creation time, modification time on the line.

Construction table sentence

Create table `user_ like `(

`id` int not null auto_increment

`liked_user_ id` varchar (32) not null comment 'liked user id'

User id' liked by `liked_post_ id` varchar (32) not null comment'

`status` tinyint (1) default'1' comment 'like status, 0 cancel, 1 like'

`create_ time`timestamp not null default current_timestamp comment 'creation time'

`update_ time`timestamp not null default current_timestamp on update current_timestamp comment 'modification time'

Primary key (`id`)

INDEX `liked_user_ id` (`liked_user_ id`)

INDEX `liked_post_ id` (`liked_post_ id`)

) comment 'user praise form'

Corresponding object 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

/ * *

* user approval form

, /

@ Entity

@ Data

Public class UserLike {

/ / Primary key id

@ Id

@ GeneratedValue (strategy = GenerationType.IDENTITY)

Private Integer id

/ / id of the user who is liked

Private String likedUserId

/ / id of users who like it

Private String likedPostId

/ / the status of giving likes. No likes are given by default

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

}

} III. Database operation

The operation database is also encapsulated in the interface

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 {

/ * *

* keep a record of likes

* @ param userLike

* @ return

, /

UserLike save (UserLike userLike)

/ * *

* batch save or modify

* @ param list

, /

List saveAll (List list); / *

* query the like list based on the id of the person being liked (that is, query who has given likes to this person)

* @ param likedUserId id of the liked person

* @ param pageable

* @ return

, /

Page getLikedListByLikedUserId (String likedUserId, Pageable pageable)

/ * *

* query the like list based on the id of the like person (that is, who has been liked by this person)

* @ param likedPostId

* @ param pageable

* @ return

, /

Page getLikedListByLikedPostId (String likedPostId, Pageable pageable)

/ * *

* query whether a like record exists through the id of the person being liked and the person who likes it.

* @ param likedUserId

* @ param likedPostId

* @ return

, /

UserLike getByLikedUserIdAndLikedPostId (String likedUserId, String likedPostId)

/ * *

* store the like data in Redis into the database

, /

Void transLikedFromRedis2DB ()

/ * *

* store the number of likes in Redis into the database

, /

Void transLikedCountFromRedis2DB ()

}

LikedServiceImpl implementation class

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 saveAll (List list) {

Return likeRepository.saveAll (list)

}

@ Override

Public Page getLikedListByLikedUserId (String likedUserId, Pageable pageable) {

Return likeRepository.findByLikedUserIdAndStatus (likedUserId, LikedStatusEnum.LIKE.getCode (), pageable)

}

@ Override

Public Page 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 list = redisService.getLikedDataFromRedis ()

For (UserLike like: list) {

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

If (ul = = null) {

/ / No record, deposit directly into

Save (like)

} else {

/ / has a record and needs to be updated

Ul.setStatus (like.getStatus ())

Save (ul)

}

}

}

@ Override

@ Transactional

Public void transLikedCountFromRedis2DB () {

List list = redisService.getLikedCountFromRedis ()

For (LikedCountDTO dto: list) {

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

/ / the number of likes is an unimportant operation, and there is no need to throw an exception if an error occurs.

If (user! = null) {

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

User.setLikeNum (likeNum)

/ / update the number of likes

UserService.updateInfo (user)

}

}

}

}

These are the operations of the database, mainly adding, deleting, changing and checking.

4. Enable timed tasks to be persisted and stored in the database

Timed task Quartz is very powerful, so use it.

Steps for using Quartz:

1. Add dependency

Org.springframework.boot

Spring-boot-starter-quartz

two。 Write a configuration file

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) / / sets the time period in seconds

.withIntervalInHours (2) / / execute once every two hours

.repeatForever ()

Return TriggerBuilder.newTrigger () .forJob (quartzDetail ()

.withIdentity (LIKE_TASK_IDENTITY)

.withschedule (scheduleBuilder)

.build ()

}

}

3. Classes that write and execute tasks inherit from 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

/ * *

* scheduled tasks for giving likes

, /

@ 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 ()

/ / synchronize the like information in Redis to the database

LikedService.transLikedFromRedis2DB ()

LikedService.transLikedCountFromRedis2DB ()

}

}

The method encapsulated by LikedService is directly called in the scheduled task to complete data synchronization.

At this point, I believe you have a deeper understanding of the "Redis efficient steps to like and cancel likes". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.