自定义注解——处理环绕通知——MybatisPlus配置类——Redis配置类——redisson配置信息——Swagger2配置信息——Redis常量配置类——全局异常处理类

自定义注解

package com.edu.shengda.common.cache;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author mqx
 */
@Target({
   ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface GmallCache{
   

    String prefix() default "cache";
}

处理环绕通知

package com.edu.shengda.common.cache;

import com.alibaba.fastjson.JSON;
import com.edu.shengda.common.constant.RedisConst;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.util.Arrays;
import java.util.concurrent.TimeUnit;

/**
 * @author mqx
 * 处理环绕通知
 * @date 2020-11-11 09:30:29
 */
@Component
@Aspect
public class GmallCacheAspect {
   

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private RedissonClient redissonClient;


    @Around("@annotation(com.edu.shengda.common.cache.GmallCache)")
    public Object cacheAroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
   

        //  声明一个对象
        Object object = new Object();

        //  在环绕通知中处理业务逻辑 {实现分布式锁}
        //  获取到注解，注解使用在方法上！
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        GmallCache gmallCache = signature.getMethod().getAnnotation(GmallCache.class);
        //  获取到注解上的前缀

        String prefix = gmallCache.prefix();

        //  方法传入的参数
        Object[] args = joinPoint.getArgs();
        //  组成缓存的key 需要前缀+方法传入的参数
        String key = prefix + args.toString();
//        String key = prefix+ Arrays.asList(args).toString();

        try {
   
            //从缓存中查询
            Object o = cacheHit(signature, key);
            if (o == null) {
   
                //从数据库中查询 这个是锁的key
                String lockKey = prefix + ":lock";
                //获取锁
                RLock lock = redissonClient.getLock(lockKey);
                boolean tryLock = lock.tryLock(RedisConst.SKULOCK_EXPIRE_PX1, RedisConst.SKULOCK_EXPIRE_PX2, TimeUnit.SECONDS);
                if (tryLock) {
   

                    try {
   
                        //  表示执行方法体 getSkuInfoDB(skuId);
                        object = joinPoint.proceed(joinPoint.getArgs());
                        //  判断object 是否为空
                        if (object == null) {
   
                            //  防止缓存穿透
                            Object object1 = new Object();
                            redisTemplate.opsForValue().set(key, JSON.toJSONString(object1), RedisConst.SKUKEY_TEMPORARY_TIMEOUT, TimeUnit.SECONDS);
                            //  返回数据
                            return object1;
                        }
                        //  放入缓存
                        redisTemplate.opsForValue().set(key, JSON.toJSONString(object), RedisConst.SKUKEY_TIMEOUT, TimeUnit.SECONDS);

                        //  返回数据
                        return object;
                    } catch (Throwable throwable) {
   
                        throwable.printStackTrace();
                    } finally {
   
                        lock.unlock();
                    }
                } else {
   
                    //  上锁失败,睡眠自旋
                    Thread.sleep(1000);
                    return cacheAroundAdvice(joinPoint);
                    //  理想状态
                    //  return cacheHit(key, signature);
                }


            } else {
   
                return object;
            }
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
        //  如果出现问题数据库兜底
        return joinPoint.proceed(joinPoint.getArgs());


    }


    /**
     * 表示从缓存中获取数据
     *
     * @param key       缓存的key
     * @param signature 获取方法的返回值类型
     * @return
     */
    //ctrl + ait +m 抽出代码作为方法
    private Object cacheHit(MethodSignature signature, String key) {
   
        //  通过key 来获取缓存的数据
        String strJson = (