SpringAop应用三之Aop实现Redis缓存双删(自定义注解实现切入)

代码源地址：https://github.com/haijiao12138/Spring.git

一：引入redis依赖和自定义注解@DataChange和实现controller：

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
 </dependency>
  <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <version>2.2.6.RELEASE</version>
</dependency>

自定义注解使用  在方法上加入：@DataChange(name = "AopController.test")，name作为参数使用；

package com.haijiao12138.demo.spring.util;

import java.lang.annotation.*;

/**
 * @author haijiao12138
 * @date 2021/8/12 20:57
 * @description
 */

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface DataChange {
    String name() default "";


}

controller中实现：

package com.haijiao12138.demo.spring.aop0812.controller;
import com.haijiao12138.demo.spring.util.AutowireRedis;
import com.haijiao12138.demo.spring.util.DataChange;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

/**
 * @author: haijiao12138
 * @ClassName: AopController
 * @description: TODO
 * @date: 2021/8/12 19:35
 *
 */
@RestController
@RequestMapping("/aop")
public class AopController {

    List<Object> list = new ArrayList<>();
    @RequestMapping("/data")
    @AutowireRedis
    public List<Object> test(){

        list.add("张三");
        list.add("李四");
        return list;
    }

    @RequestMapping("/addData")
    @DataChange(name = "AopController.test")
    public List<Object> addData(){

        list.add("王五");
        list.add("赵六");
        return list;
    }

    @RequestMapping("/test")
    public String testAop(String key){
        return "testAop: key = " + key;
    }

    @RequestMapping("testAfterThrowing")
    public String testAfterThrowing(String key){
        throw new NullPointerException(key);
    }


    @RequestMapping("/testAround")
    public String testAround(String key){
        return "环绕通知：key = " + key;
    }



}

二：实现切面类 实现双删代码  双删加延迟删除

每次对数据库操作时，在该方法上加入对应操作数据库的查询操作的类和方法名，本测试中是
将“AopController.test”作为参数传入；利用反射得到对应方法的对象名和通过对象名得到name参数作为redis模糊删除的条件；

package com.haijiao12138.demo.spring.aop0812;/**
 * @author 候苑博
 * @date 2021/8/12 19:32
 * @description
 */

import com.haijiao12138.demo.spring.util.DataChange;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Set;

/**
 * @author: 候苑博
 * @ClassName: WebAspect
 * @description: TODO
 * @date: 2021/8/12 19:32
 *
 */
@Aspect
@Component
public class WebAspectData {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 切入点
     *切入点,基于注解实现的切入点  加上该注解的都是Aop切面的切入点
     *
     */
    @Pointcut("@annotation(com.haijiao12138.demo.spring.util.DataChange)")
    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();//方法对象
        DataChange annotation = targetMethod.getAnnotation(DataChange.class);//反射得到自定义注解的方法对象

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

        //执行加入双删注解的改动数据库的业务 即controller中的方法业务
        Object proceed = null;
        try {
            proceed = proceedingJoinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        
        //开一个线程 延迟1秒（此处是1秒举例，可以改成自己的业务） 
        // 在线程中延迟删除  同时将业务代码的结果返回 这样不影响业务代码的执行
       new Thread(new Runnable() {
           @Override
           public void run() {
               try {
                   Thread.sleep(1000);
                   Set<String> keys = stringRedisTemplate.keys("*" + name + "*");//模糊删除
                   Long delete = stringRedisTemplate.delete(keys);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }).start();
        
        return proceed;//返回业务代码的值

    }

}

三.测试  页面测试数据

查询页面的时候 如果没数据 就先利用redis存入数据库：

此时redis中没有值;访问一次后 数据库的值 会写入redis中；

 

 现在redis中有了刚才访问的值；

加入现在执行redis的改动数据库打的方法，这时会利用Aop机制 执行对Redis的延迟双删策略；

访问：http://localhost:8080/aop/addData

 执行第一次删除 之后  redis中的数据就被删除了；

当执行完controller中的业务代码后，数据库的值可能进行了改动，比如增加了，如下面代码所示：

 比如模拟数据库中的代码由原来的“张三，李四”变成了“张三，李四，王五赵六”，数据库增加了值；如果在数据库的增加“王五赵六”的过程中，数据库还没来得及加上数据，此时又有线程来读取数据库的代码，此时数据库还是“张三和李四”，这是第一次删除之后的写入redis，如果数据库增加上“王五赵六”后，redis和数据库的数据就会出现不一致的场景，所以需要在增加完完数据后再次删除redis的数据，俗称第二次删除；

比如现在又其他线程访问数据库数据：redis存入的还是之前的值：

 然后 数据“王五 赵六”执行完毕后，数据库就多了数据，现在就第二次删除就把刚才redis中的缓存不一致的数据给删除了：如下图所示：

 数据第二次删除，得到验证；

延迟的目的：

需要评估自己的项目的读数据业务逻辑的耗时。这么做的目的，就是确保读请求结束，写请求可以删除读请求造成的缓存脏数据。延迟第二次删除，加上线程休眠休眠，不会对原来的程序返回值造成时间延迟，原来的返回值作为业务的代码正常返回，一秒后 redis中的缓存进行正常删除；

删除代码如下：

项目目录如下：