How SpringBoot AOP Redis implements delayed double deletion function

1. Business scenario

In the case of multi-thread concurrency, assuming there are two database modification requests, in order to ensure the data consistency between the database and redis,
In the implementation of the modification request, it is necessary to cascade modify the data in Redis after modifying the database.
Request 1: A modifies the database data B modifies the Redis data
Request 2: C modifies the database data D modifies the Redis data
In a concurrent situation, there will be A —> C —> D — > Situation B
(Be sure to understand that the order of execution of multiple sets of atomic operations concurrently by threads may overlap)

1. Problems at this time

A Modify the database The data was finally saved to Redis, and C also modified the database data after A.

At this time, there is an inconsistency between the data in Redis and the database data. In the subsequent query process, Redis will be checked first for a long time. As a result, the queried data is not the real data in the database. question.

2. Solution

When using Redis, you need to maintain the consistency of Redis and database data. One of the most popular solutions is the delayed double delete strategy.
Note: You must know that frequently modified data tables are not suitable for using Redis, because the result of the double deletion strategy is to delete the data saved in Redis, and subsequent queries will query the database. Therefore, Redis uses a data cache that reads far more than changes.
Delayed double deletion scheme execution steps

1> Delete cache
2> Update database
3> Delay 500 milliseconds (set the delay execution time according to the specific business)
4> Delete cache

3. Why is there a delay of 500 milliseconds?

We need to complete the database update operation before the second Redis deletion. Let's pretend that if there is no third step, there is a high probability that after the two deletion Redis operations are completed, the data in the database has not been updated. If there is a request to access the data at this time, the problem we mentioned at the beginning will appear. That question.

4. Why do you need to delete the cache twice?

If we do not have a second deletion operation and there is a request to access data at this time, it may be the Redis data that has not been modified before. After the deletion operation is executed, Redis will be empty. When a request comes in, it will The database will be accessed. At this time, the data in the database is the updated data, ensuring data consistency.

2. Code practice

1. Introduce Redis and SpringBoot AOP dependencies

<!-- redis使用 -->
<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- aop -->
<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2. Write custom aop annotations and aspects

ClearAndReloadCache delay double Delete annotation

/**
 *延时双删
 **/
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Target(ElementType.METHOD)
public @interface ClearAndReloadCache {
    String name() default "";
}

ClearAndReloadCacheAspect delayed double deletion of aspects

@Aspect
@Component
public class ClearAndReloadCacheAspect {

@Autowired
private StringRedisTemplate stringRedisTemplate;

/**
* 切入点
*切入点,基于注解实现的切入点  加上该注解的都是Aop切面的切入点
*
*/

@Pointcut("@annotation(com.pdh.cache.ClearAndReloadCache)")
public void pointCut(){

}
/**
* 环绕通知
* 环绕通知非常强大，可以决定目标方法是否执行，什么时候执行，执行时是否需要替换方法参数，执行完毕是否需要替换返回值。
* 环绕通知第一个参数必须是org.aspectj.lang.ProceedingJoinPoint类型
* @param proceedingJoinPoint
*/
@Around("pointCut()")
public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint){
    System.out.println("----------- 环绕通知 -----------");
    System.out.println("环绕通知的目标方法名：" + proceedingJoinPoint.getSignature().getName());

    Signature signature1 = proceedingJoinPoint.getSignature();
    MethodSignature methodSignature = (MethodSignature)signature1;
    Method targetMethod = methodSignature.getMethod();//方法对象
    ClearAndReloadCache annotation = targetMethod.getAnnotation(ClearAndReloadCache.class);//反射得到自定义注解的方法对象

    String name = annotation.name();//获取自定义注解的方法对象的参数即name
    Set<String> keys = stringRedisTemplate.keys("*" + name + "*");//模糊定义key
    stringRedisTemplate.delete(keys);//模糊删除redis的key值

    //执行加入双删注解的改动数据库的业务 即controller中的方法业务
    Object proceed = null;
    try {
        proceed = proceedingJoinPoint.proceed();
    } catch (Throwable throwable) {
        throwable.printStackTrace();
    }

    //开一个线程 延迟1秒（此处是1秒举例，可以改成自己的业务）
    // 在线程中延迟删除  同时将业务代码的结果返回 这样不影响业务代码的执行
    new Thread(() -> {
        try {
            Thread.sleep(1000);
            Set<String> keys1 = stringRedisTemplate.keys("*" + name + "*");//模糊删除
            stringRedisTemplate.delete(keys1);
            System.out.println("-----------1秒钟后，在线程中延迟删除完毕 -----------");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }).start();

    return proceed;//返回业务代码的值
    }
}

3, application.yml

server:
  port: 8082

spring:
  # redis setting
  redis:
    host: localhost
    port: 6379

  # cache setting
  cache:
    redis:
      time-to-live: 60000 # 60s

  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: 1234

# mp setting
mybatis-plus:
  mapper-locations: classpath*:com/pdh/mapper/*.xml
  global-config:
    db-config:
      table-prefix:
  configuration:
    # log of sql
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    # hump
    map-underscore-to-camel-case: true

4, user_db.sql script

is used for production testing Data

DROP TABLE IF EXISTS `user_db`;
CREATE TABLE `user_db`  (
  `id` int(4) NOT NULL AUTO_INCREMENT,
  `username` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 8 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user_db
-- ----------------------------
INSERT INTO `user_db` VALUES (1, '张三');
INSERT INTO `user_db` VALUES (2, '李四');
INSERT INTO `user_db` VALUES (3, '王二');
INSERT INTO `user_db` VALUES (4, '麻子');
INSERT INTO `user_db` VALUES (5, '王三');
INSERT INTO `user_db` VALUES (6, '李三');

5, UserController

/**
 * 用户控制层
 */
@RequestMapping("/user")
@RestController
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/get/{id}")
    @Cache(name = "get method")
    //@Cacheable(cacheNames = {"get"})
    public Result get(@PathVariable("id") Integer id){
        return userService.get(id);
    }

    @PostMapping("/updateData")
    @ClearAndReloadCache(name = "get method")
    public Result updateData(@RequestBody User user){
        return userService.update(user);
    }

    @PostMapping("/insert")
    public Result insert(@RequestBody User user){
        return userService.insert(user);
    }

    @DeleteMapping("/delete/{id}")
    public Result delete(@PathVariable("id") Integer id){
        return userService.delete(id);
    }
}

6, UserService

/**
 * service层
 */
@Service
public class UserService {

    @Resource
    private UserMapper userMapper;

    public Result get(Integer id){
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(User::getId,id);
        User user = userMapper.selectOne(wrapper);
        return Result.success(user);
    }

    public Result insert(User user){
        int line = userMapper.insert(user);
        if(line > 0)
            return Result.success(line);
        return Result.fail(888,"操作数据库失败");
    }

    public Result delete(Integer id) {
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(User::getId, id);
        int line = userMapper.delete(wrapper);
        if (line > 0)
            return Result.success(line);
        return Result.fail(888, "操作数据库失败");
    }

    public Result update(User user){
        int i = userMapper.updateById(user);
        if(i > 0)
            return Result.success(i);
        return Result.fail(888,"操作数据库失败");
    }
}

3. Test verification

1, ID=10, add a new data

2. When querying the database for the first time, Redis will save the query results

3. The first access ID is 10

4. The first access database ID is 10, and store the result in Redis

5. Update ID For the user name corresponding to 10 (verification database and cache inconsistency scheme)

Database and cache inconsistency verification scheme:

Make a breakpoint and simulate A thread After the first deletion is performed, before A completes updating the database, another thread B accesses ID=10 and reads the old data.

Using the second deletion, after setting the appropriate delay time according to the business scenario, after the cache deletion is successful twice, The output of Redis will be empty. What is read is the real data of the database, and there will be no inconsistency between the read cache and the database.

4. Code Engineering

The core code is shown in the red box

The above is the detailed content of How SpringBoot AOP Redis implements delayed double deletion function. For more information, please follow other related articles on the PHP Chinese website!