SpringBoot中通过自定义缓存注解(AOP切面拦截)实现数据库数据缓存到Redis

偏执的太偏执、 2022-10-10 09:40 13阅读 0赞

# 场景 #

若依前后端分离版本地搭建开发环境并运行项目的教程：

[https://blog.csdn.net/BADAO\_LIUMANG\_QIZHI/article/details/108465662][https_blog.csdn.net_BADAO_LIUMANG_QIZHI_article_details_108465662]

基于上面搭建起来前后端分离的Vue+SpringBoot的项目。

其中数据库使用的是Mysql,缓存层用的是Redis。

数据库中某个表存储的信息，在业务代码比如定时任务中，需要频繁的查询。

所以将表中的数据存储到redis中一份。

其原理是，在调用查询方法时，判断redis中是否已经有，如果有则优先从redis中查询。

如果没有则在数据库中查询后并存入到Redis中一份，并给其设置过期时间。

这样在过期时间之内，查询数据会从redis中查询，过期之后会重新从Mysql中查询并存入到Redis一份。

并且还要实现，再对这个Mysql表进行新增、编辑、删除的操作时，将redis中存储的数据

进行删除，这样下次查询就会查询数据库中最新的。

注：

博客：  
[https://blog.csdn.net/badao\_liumang\_qizhi][https_blog.csdn.net_badao_liumang_qizhi]  
关注公众号  
霸道的程序猿  
获取编程相关电子书、教程推送与免费下载。

# 实现 #

首先在Mysql中新建一个表bus\_student

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JBREFPX0xJVU1BTkdfUUlaSEk_size_16_color_FFFFFF_t_70][]

然后基于此表使用代码生成，前端Vue与后台各层代码生成并添加菜单。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JBREFPX0xJVU1BTkdfUUlaSEk_size_16_color_FFFFFF_t_70 1][]

然后来到后台代码中，在后台框架中已经添加了操作redis的相关依赖和工具类。

但是这里还需要添加aspect依赖

<dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
                <version>4.3.14.RELEASE</version>
            </dependency>

然后在存放配置类的地方新建新增redis缓存的注解

package com.ruoyi.system.redisAop;
    
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /*
     * @Author
     * @Description 新增redis缓存
     **/
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface AopCacheEnable {
        //redis缓存key
        String[] key();
        //redis缓存存活时间默认值（可自定义）
        long expireTime() default 3600;
    
    }

以及删除redis缓存的注解

package com.ruoyi.system.redisAop;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /*
     * @Description 删除redis缓存注解
     **/
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface AopCacheEvict {
        //redis中的key值
        String[] key();
    }

然后再新建一个自定义缓存切面具体实现类CacheEnableAspect

存放位置

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JBREFPX0xJVU1BTkdfUUlaSEk_size_16_color_FFFFFF_t_70 2][]

package com.ruoyi.system.redisAop;
    
    
    import com.ruoyi.system.domain.BusStudent;
    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.RedisTemplate;
    import org.springframework.stereotype.Component;
    
    import java.lang.reflect.Method;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.TimeUnit;
    
    /*
     * @Description 自定义缓存切面具体实现类
     **/
    @Aspect
    @Component
    public class CacheEnableAspect {
    
        @Autowired
        public RedisTemplate redisCache;
    
        /**
         * Mapper层切点 使用到了我们定义的 AopCacheEnable 作为切点表达式。
         */
        @Pointcut("@annotation(com.ruoyi.system.redisAop.AopCacheEnable)")
        public void queryCache() {
        }
    
        /**
         * Mapper层切点 使用到了我们定义的 AopCacheEvict 作为切点表达式。
         */
        @Pointcut("@annotation(com.ruoyi.system.redisAop.AopCacheEvict)")
        public void ClearCache() {
        }
    
        @Around("queryCache()")
        public Object Interceptor(ProceedingJoinPoint pjp) {
            Object result = null;
            //注解中是否有#标识
            boolean spelFlg = false;
            //判断是否需要走数据库查询
            boolean selectDb = false;
            //redis中缓存的key
            String redisKey = "";
            //获取当前被切注解的方法名
            Method method = getMethod(pjp);
            //获取当前被切方法的注解
            AopCacheEnable aopCacheEnable = method.getAnnotation(AopCacheEnable.class);
            //获取方法参数值
            Object[] arguments = pjp.getArgs();
            //从注解中获取字符串
            String[] spels = aopCacheEnable.key();
            for (String spe1l : spels) {
                if (spe1l.contains("#")) {
                    //注解中包含#标识，则需要拼接spel字符串,返回redis的存储redisKey
                    redisKey = spe1l.substring(1) + arguments[0].toString();
                } else {
                    //没有参数或者参数是List的方法，在缓存中的key
                    redisKey = spe1l;
                }
                //取出缓存中的数据
                result = redisCache.opsForValue().get(redisKey);
                //缓存是空的，则需要重新查询数据库
                if (result == null || selectDb) {
                    try {
                        result =  pjp.proceed();
                        //从数据库查询到的结果不是空的
                        if (result != null && result instanceof ArrayList) {
                            //将redis中缓存的结果转换成对象list
                            List<BusStudent> students = (List<BusStudent>) result;
                            //判断方法里面的参数是不是BusStudent
                            if (arguments[0] instanceof BusStudent) {
                                //将rediskey-students 存入到redis
                                redisCache.opsForValue().set(redisKey, students, aopCacheEnable.expireTime(), TimeUnit.SECONDS);
                            }
                        }
                    } catch (Throwable e) {
                        e.printStackTrace();
                    }
                }
            }
            return result;
        }
    
        /*** 定义清除缓存逻辑，先操作数据库，后清除缓存*/
        @Around(value = "ClearCache()")
        public Object evict(ProceedingJoinPoint pjp) throws Throwable {
            //redis中缓存的key
            Method method = getMethod(pjp);
            // 获取方法的注解
            AopCacheEvict cacheEvict = method.getAnnotation(AopCacheEvict.class);
            //先操作db
            Object result = pjp.proceed();
            // 获取注解的key值
            String[] fieldKeys = cacheEvict.key();
            for (String spe1l : fieldKeys) {
                //根据key从缓存中删除
                redisCache.delete(spe1l);
            }
            return result;
        }
    
        /**
         * 获取被拦截方法对象
         */
        public Method getMethod(ProceedingJoinPoint pjp) {
            Signature signature = pjp.getSignature();
            MethodSignature methodSignature = (MethodSignature) signature;
            Method targetMethod = methodSignature.getMethod();
            return targetMethod;
        }
    }

注意这里的queryCache和ClearCache,里面切点表达式

分别对应上面自定义的两个AopCacheEnable和AopCacheEvict。

然后在环绕通知的queryCache方法执行前后时

获取被切方法的参数，参数中的key，然后根据key去redis中去查询，

如果查不到，就把方法的返回结果转换成对象List，并存入到redis中，

如果能查到，则将结果返回。

然后找到这个表的查询方法，mapper层，比如要将查询的返回结果存储进redis

@AopCacheEnable(key = "BusStudent",expireTime = 40)
        public List<BusStudent> selectBusStudentList(BusStudent busStudent);

然后在这个表的新增、编辑、删除的mapper方法上添加

/**
         * 新增学生
         *
         * @param busStudent 学生
         * @return 结果
         */
        @AopCacheEvict(key = "BusStudent")
        public int insertBusStudent(BusStudent busStudent);
    
        /**
         * 修改学生
         *
         * @param busStudent 学生
         * @return 结果
         */
        @AopCacheEvict(key = "BusStudent")
        public int updateBusStudent(BusStudent busStudent);
    
        /**
         * 删除学生
         *
         * @param id 学生ID
         * @return 结果
         */
        @AopCacheEvict(key = "BusStudent")
        public int deleteBusStudentById(Integer id);

注意这里的注解上的key要和上面的查询的注解的key一致。

然后启动项目，如果启动时提示:

Consider marking one of the beans as @Primary, updating the consumer to acce

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JBREFPX0xJVU1BTkdfUUlaSEk_size_16_color_FFFFFF_t_70 3][]

因为sringboot通过@Autowired注入接口的实现类时发现有多个，也就是有多个类继承了这个接口，spring容器不知道使用哪一个。

找到redis的配置类，在RedisTemplate上添加@Primary注解

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JBREFPX0xJVU1BTkdfUUlaSEk_size_16_color_FFFFFF_t_70 4][]

验证注解的使用

debug启动项目，在CacheEnableAspect中查询注解中打断点，然后调用查询方法，

就可以看到能进断点，然后就可以根据自己想要的逻辑和效果进行修改注解。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JBREFPX0xJVU1BTkdfUUlaSEk_size_16_color_FFFFFF_t_70 5][]

第一次查询时redis中是没有的，所以会走mysql查询，在过期时间之内就不再查询mysq，而是查询redis了。

![20210627095659666.gif][]

然后再调用新增、编辑、删除接口时会将redis中缓存的数据删掉。

但是使用若依这套框架，在新增、编辑、删除操作后会调用查询接口，所以会直接又存储进来。

所以可以用postman等接口测试工具测试。

然后就是当操作完之后如果redis中的数据还没过期，前端页面查询的仍然是redis中的数据，不是最新数据。

所以redis中过期的时间自己把握。

另外此种缓存机制，建议不要和前端请求的mapper进行混用。

建议自定义新的mapper只取用需要的数据，然后给其他比如高频率的定时任务查询用。

[https_blog.csdn.net_BADAO_LIUMANG_QIZHI_article_details_108465662]: https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/108465662
[https_blog.csdn.net_badao_liumang_qizhi]: https://blog.csdn.net/badao_liumang_qizhi
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JBREFPX0xJVU1BTkdfUUlaSEk_size_16_color_FFFFFF_t_70]: /images/20221005/c54345344df64df5b1f49de43bc18ea4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JBREFPX0xJVU1BTkdfUUlaSEk_size_16_color_FFFFFF_t_70 1]: /images/20221005/08c5c027df1c4865935b15ae10220819.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JBREFPX0xJVU1BTkdfUUlaSEk_size_16_color_FFFFFF_t_70 2]: /images/20221005/2b6ad6e70227446bb67dce15e3e28590.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JBREFPX0xJVU1BTkdfUUlaSEk_size_16_color_FFFFFF_t_70 3]: /images/20221005/bc41c7d5eb6f4431825bb97d260d7771.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JBREFPX0xJVU1BTkdfUUlaSEk_size_16_color_FFFFFF_t_70 4]: /images/20221005/fd077e523d6540ae978870891503a437.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JBREFPX0xJVU1BTkdfUUlaSEk_size_16_color_FFFFFF_t_70 5]: /images/20221005/82274225a1cd47938ddb82dee1c5d6ce.png
[20210627095659666.gif]: /images/20221005/cfbb73caabe44f7789b282878581522e.png