1
    public SkuInfoDTO getSkuInfoWithRedisson(Long skuId) {
2
        // 定义key sku:skuId:info
3
        String skuInfoKey = RedisConst.SKUKEY_PREFIX + skuId + RedisConst.SKUKEY_SUFFIX;
4
        // 根据key获取redis中的SkuInfoDTO
5
        RBucket<SkuInfoDTO> bucket = redissonClient.getBucket(skuInfoKey);
6
        SkuInfoDTO skuInfoDTO = bucket.get();
7
        if (skuInfoDTO != null) {
8
            // 如果获取到，则直接返回
9
            return skuInfoDTO;
10
        }
11

12
        // 定义锁对应的key
13
        String lockKey = RedisConst.SKUKEY_PREFIX + skuId + RedisConst.SKULOCK_SUFFIX;
14
        RLock redisLock = null;
15
        try {
16
            // 如果没有获取到，则获取锁
17
            redisLock = redissonClient.getLock(lockKey);
18
            //  加锁
19
            redisLock.lock();
20

21
            // 这里是做double check，因为有可能别的服务已经将该SKU数据放入到Redis中
22
            SkuInfoDTO retrySkuInfoDTO = bucket.get();
23
            if (retrySkuInfoDTO != null) {
24
                // 说明别的服务已经将SKU信息放入Redis中，我们只需要从Redis中读取数据即可
25
                return retrySkuInfoDTO;
26
            }
27
          /*
28
              1. 说明缓存中还是没有
29
              2. 而且，也没有其他服务将该SKU信息放入到Redis中，此时访问数据库
30
          */
31
            // 获取SKU基本信息
32
            SkuInfo skuInfo = skuInfoMapper.selectById(skuId);
33
            // 根据skuId 查询图片列表集合
34
            List<SkuImage> skuImageList = skuImageMapper.getSkuImages(skuId);
35
            skuInfo.setSkuImageList(skuImageList);
36
            SkuInfoDTO skuInfoFromDB = skuInfoConverter.skuInfoPO2DTO(skuInfo);
37

38

39
            // 判断数据库中是否有该SKU
40
            if (skuInfoFromDB == null) {
41
                // 如果没有则在Redis中放入默认值，主要预防缓存穿透
42
                skuInfoFromDB = new SkuInfoDTO();
43
            }
44

45
            bucket.set(skuInfoFromDB);
46
            return skuInfoFromDB;
47

48
        } finally {
49
            if (redisLock != null) {
50
                // 释放锁
51
                redisLock.unlock();
52
            }
53
        }

1
@Component
2
@Aspect
3
public class RedisCacheAspect {
4

5
    @Autowired
6
    private RedissonClient redissonClient;
7

8
    //  定义一个环绕通知！
9
    @Around("@annotation(com.cskaoyan.mall.common.cache.RedisCache)")
10
    public Object gmallCacheAspectMethod(ProceedingJoinPoint point) {
11
        //  定义一个对象
12
        Object obj = null;
13
        MethodSignature methodSignature = (MethodSignature) point.getSignature();
14
        RedisCache redisCache = methodSignature.getMethod().getAnnotation(RedisCache.class);
15
        //   获取到注解上的前缀
16
        String prefix = redisCache.prefix();
17
        //  组成缓存的key！ 获取方法传递的参数
18
        String key = prefix + Arrays.asList(point.getArgs()).toString();
19
        RLock lock = null;
20
        try {
21
            //  可以通过这个key 获取缓存的数据
22
            obj = this.redissonClient.getBucket(key).get();
23
            if (obj != null) {
24
                // 获取到了直接返回
25
                return obj;
26
            }
27
        } catch (Exception e) {
28
            e.printStackTrace();
29
        }
30
        try {
31
            //  加锁
32
            lock = redissonClient.getLock(key + ":lock");
33
            lock.lock();
34
            Object redisData = this.redissonClient.getBucket(key).get();
35
            // double check
36
            if (redisData != null) {
37
                // 获取到了直接返回
38
                return redisData;
39
            }
40

41
            //  执行业务逻辑：直接从数据库获取数据
42
            obj = point.proceed(point.getArgs());
43

44
              // 将结果放入redis
45
            obj = putInRedis(obj, key, methodSignature);
46

47
            return obj;
48

49
        } finally {
50
            //  解锁
51
            if (lock != null) {
52
                lock.unlock();
53
            }
54
        }
55
    }
56

57
   /*
58
         将数据放入Redis缓存
59
     */
60
    private Object putInRedis(Object obj, String key, MethodSignature methodSignature) {
61
        try {
62
            if (obj == null) {
63
                //  防止缓存穿透
64
                //obj = new Object();
65
               Class returnType = methodSignature.getReturnType();
66
                if (returnType.isAssignableFrom(List.class)) {
67
                    // 返回值是Collection或List类型
68
                    obj = new ArrayList();
69
                } else if (Map.class.equals(returnType)) {
70
                    // 返回值是Map类型
71
                    obj = new HashMap();
72
                } else {
73
                    // 其他类型
74
                    Constructor declaredConstructor = returnType.getDeclaredConstructor();
75
                    declaredConstructor.setAccessible(true);
76
                    obj = declaredConstructor.newInstance();
77
                }
78
                //  将缓存的数据变为 Json 的 字符串,默认值的过期时间是1分钟
79
                this.redissonClient.getBucket(key).set(obj, RedisConst.SKUKEY_TEMPORARY_TIMEOUT, TimeUnit.SECONDS);
80
            } else {
81
                //  将缓存的数据变为 Json 的 字符串
82
                this.redissonClient.getBucket(key).set(obj, RedisConst.SKUKEY_TIMEOUT, TimeUnit.SECONDS);
83
            }
84
        } catch (Exception e) {
85
            e.printStackTrace();
86
        }
87

88
        return obj;
89
    }
90

91
}

1
    @RedisCache(prefix = RedisConst.SKUKEY_PREFIX)
2
    @Override
3
    public SkuInfoDTO getSkuInfo(Long skuId) {
4
        ...
5
    }
6

7
    @RedisCache(prefix = "spuSaleAttrListCheckBySku:")
8
    @Override
9
    public List<SpuSaleAttributeInfoDTO> getSpuSaleAttrListCheckBySku(Long skuId, Long spuId) {
10
     ...
11
    }
12

13
    @Override
14
    @RedisCache(prefix = "skuValueIdsMap:")
15
    public Map<String, Long> getSkuValueIdsMap(Long spuId) {
16
        ...
17
    }
18

19
    @Override
20
    @RedisCache(prefix = "categoryHierarchyByCategory3Id:")
21
    public CategoryHierarchyDTO getCategoryViewByCategoryId(Long category3Id) {
22
     ...
23
    }
24

25
    @Override
26
    @RedisCache(prefix = "SpuPosterList:")
27
    public List<SpuPosterDTO> findSpuPosterBySpuId(Long spuId) {
28
     ...
29
    }
30

31
    @RedisCache(prefix = "platformAttributeInfoList:")
32
    @Override
33
    public List<PlatformAttributeInfoDTO> getPlatformAttrInfoBySku(Long skuId) {
34
    ...
35
    }