JAVA开发（通过AOP切面方式管理redis缓存）

喜欢ヅ旅行 2024-03-30 17:30 38阅读 0赞

#### 实现场景 ####

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

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

这样在过期时间之内，查询数据会从redis中查询，过期之后会重新从数据库中查询并存入到Redis一份。再对这个数据库表进行新增、编辑、删除的操作时，将redis中存储的数据。

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

引入切面依赖

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

自定义新增注解

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;
    }

自定义删除注解

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();
    }

自定义切面

import com.maoheyeren.domain.MAdver;
    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.maoheyeren.redisAop.AopCacheEnable)")
        public void queryCache() {
     
        }
     
        /**
         * Mapper层切点 使用到了我们定义的 AopCacheEvict 作为切点表达式。
         */
        @Pointcut("@annotation(com.maoheyeren.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<MAdver> mAdver = (List<MAdver>) result;
     
                            // 判断方法里面的参数是不是MAdver
     
                            if (arguments[0] instanceof MAdver) {
     
                                // 将rediskey-mAdver 存入到redis
     
                                redisCache.opsForValue().set(redisKey, mAdver, 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;
     
        }
     
    }

调用方式

@AopCacheEnable(key = "MAdver",expireTime = 40)
        public List<MAdver> selectMAdverList(MAdver mAdver);

使用注解

/**
    
         * 新增实体
         * @param mAdver 实体
         * @return 结果
         */
    
        @AopCacheEvict(key = "MAdver")
        public int insertMAdver(MAdver mAdver);
    
        /**
         * 修改实体
         * @param mAdver 实体
         * @return 结果
         */
    
        @AopCacheEvict(key = "MAdver")
        public int updateMAdver(MAdver mAdver);
    
    
        /**
         * 删除实体
         * @param id 实体ID
         * @return 结果
         */
    
        @AopCacheEvict(key = "MAdver")
        public int deleteMAdverById(Integer id);