Day140-142.尚品汇：AOP+Redis缓存+redssion分布式锁、CompletableFuture异步编排、首页三级分类展示、Nginx静态代理

目录

Day08

一、获取商品详情 加入缓存

二、全局缓存：分布式锁与aop 整合

三、布隆过滤器

四、CompletableFuture 异步编排 jdk1.8

Day09

1. 将item 改为多线程并发 异步编排

2. 首页三级分类显示

3.页面静态化 -- Nginx静态代理

4. 商品的检索

4. 商品上架

---

Day08

hash 适合存储对象，在有修改的时候可以不反序列化其他字段；适合存储购物车

一、获取商品详情 加入缓存

商品详情页可能会出现并发，因此在获取数据时应该添加分布式锁保护数据库。

1. redisson方式

//获取商品详情 redisson 缓存方式
    private SkuInfo getInfoRedissonCache(Long skuId) {
        SkuInfo skuInfo = null;
        try {
            // 1.定义key，获取缓存，判断是否有数据
            String skuKey = RedisConst.SKUKEY_PREFIX+ skuId +RedisConst.SKUKEY_SUFFIX;
            skuInfo = (SkuInfo) redisTemplate.opsForValue().get(skuKey);
            if(skuInfo == null){
                // 2.定义LockKey，尝试获取锁
                String locKey = RedisConst.SKUKEY_PREFIX + skuId + RedisConst.SKULOCK_SUFFIX;
                RLock lock = redissonClient.getLock(locKey);
                 /*
                第一种： lock.lock();
                第二种:  lock.lock(10,TimeUnit.SECONDS);
                第三种： lock.tryLock(100,10,TimeUnit.SECONDS);
                 */
                // 3.尝试获取锁
                boolean res = lock.tryLock(RedisConst.SKULOCK_EXPIRE_PX1, RedisConst.SKULOCK_EXPIRE_PX2, TimeUnit.SECONDS);
                if(res){
                    try {
                        skuInfo = getSkuInfoDB(skuId);
                        // 4.存入空数据，防止缓存穿透
                        if(skuInfo==null){
                            SkuInfo skuInfoNull = new SkuInfo(); //对象的地址
                            redisTemplate.opsForValue().set(skuKey,skuInfoNull,RedisConst.SKUKEY_TEMPORARY_TIMEOUT,TimeUnit.SECONDS);
                            return skuInfoNull;
                        }
                        // 5.数据存入缓存
                        redisTemplate.opsForValue().set(skuKey,skuInfo,RedisConst.SKUKEY_TIMEOUT,TimeUnit.SECONDS);
                        return skuInfo;
                    } catch (Exception e){
                        e.printStackTrace();
                    }
                    finally {
                        // 6.解锁 加锁次数要与解锁次数一致
                        lock.unlock();
                    }
                }else {
                    // 没获取到锁的线程等待;回旋
                    Thread.sleep(500);
                    return getSkuInfo(skuId);
                }
            }else {
                // 缓存中有数据，直接返回
                return skuInfo;
            }
        } catch (InterruptedException e) {
            //redis宕机了！记录日志！发送短信方法！！
            e.printStackTrace();
        }
        // 防止redis宕机，数据库兜底
        return getSkuInfoDB(skuId);
    }

2. redis + lua 方式

lock，unlock 可能产生锁死，不需等待自旋机制；trylock可设定过期时间，需要等待自旋机制。

//获取商品详情 redis+lua 缓存方式
    private SkuInfo getInfoRedisCache(Long skuId) {
        SkuInfo skuInfo = null;
        //1. 分析key是谁?
        String skuKey = RedisConst.SKUKEY_PREFIX+ skuId +RedisConst.SKUKEY_SUFFIX;
        //2. 分析使用那种数据类型? String Hash List set Zset
        //模板自动进行序列化，可进行强转
        skuInfo = (SkuInfo) redisTemplate.opsForValue().get(skuKey);
        //3. 判断缓存中是否有这个数据，redis 非关系型数据库
        if(skuInfo == null){
            //4. 加锁，查询数据库放入缓存 redis +lua | redisson
            String locKey = RedisConst.SKUKEY_PREFIX + skuId + RedisConst.SKULOCK_SUFFIX;
            String uuid = UUID.randomUUID().toString();
            //set key value ex timeout nx ==> 保证原子性，过期时间应大于业务执行时间
            Boolean result = redisTemplate.opsForValue().setIfAbsent(locKey, uuid,
                    RedisConst.SKULOCK_EXPIRE_PX2, TimeUnit.SECONDS);
            //5. 判断是否获取到锁
            if(result){
                // 6.从数据库获取数据，判断是否有此数据，防止缓存穿透
                skuInfo = this.getSkuInfoDB(skuId);
                if(skuInfo==null){
                    //存入空对象，时间要短一些
                    SkuInfo skuInfoNull = new SkuInfo();
                    redisTemplate.opsForValue().set(skuKey,skuInfoNull,
                            RedisConst.SKUKEY_TEMPORARY_TIMEOUT,TimeUnit.SECONDS);
                    //释放锁 省略...
                    return skuInfoNull;
                }
                // 7.将数据放入缓存
                redisTemplate.opsForValue().set(skuKey,skuInfo,RedisConst.SKUKEY_TIMEOUT,TimeUnit.SECONDS);
                // 8.释放锁; lua 脚本保证操作具有原子性
                String scriptText = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
                DefaultRedisScript redisScript = new DefaultRedisScript<>();
                redisScript.setResultType(Long.class); //设置返回值类型
                redisScript.setScriptText(scriptText);
                redisTemplate.execute(redisScript, Arrays.asList(locKey),uuid);
                return skuInfo;
            }else {
                // 9.没有获取到锁,等待;自旋
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return getSkuInfo(skuId);
            }
        }else {
            // 缓存中有数据直接放回
            return skuInfo;
        }
        //数据库兜底 省略
    }

二、全局缓存：分布式锁与aop 整合

商品详情页面渲染数据都需要有分布式锁业务逻辑！

事务注解：底层就是使用aop 在不改变原有功能基础上，添加新的功能！

通知机制：前置、后置、环绕、异常
切点： 方法---注解；切面： 服务层

业务逻辑

1. 拼接缓存 key

2. 获取缓存数据，有则直接返回

3. 拼接锁 Lockey

4. 没有缓存数据，加锁，查询数据库

5. 判断是否存在数据，没有数据存入空对象防止缓存穿透

6. 将数据存入缓存，解锁

7. try cath，查询数据库兜底，防止redis 宕机

1. 自定义一个注解

@Target({ElementType.METHOD}) //注解的使用范围:方法上
@Retention(RetentionPolicy.RUNTIME) //表示注解的生命周期:运行时生效
public @interface GmallCache {
    //在这里定义一个属性，组成缓存key的前缀
    String prefix() default "cache";
}

2. 自定义一个切面类

@Component
@Aspect
public class GmallCacheAspect {

    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private RedissonClient redissonClient;

    //切面 AOP GmallCache注解
    @SneakyThrows
    @Around("@annotation(com.atguigu.gmall.common.cache.GmallCache)")
    public Object cacheAroundAdvice(ProceedingJoinPoint joinPoint){
        Object obj = new Object();
        try {
            //1.获取缓存key: 注解前缀+方法参数
            //获取方法签名
            MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
            //获取方法
            Method method = methodSignature.getMethod();
            //获取注解
            GmallCache gmallCache = method.getAnnotation(GmallCache.class);
            //获取注解参数
            String prefix = gmallCache.prefix();
            //组成key
            Object[] args = joinPoint.getArgs();
            String key = prefix + Arrays.asList(args).toString();

            //2.通过key来获取缓存的数据;存在则返回 (封装为了方法)
            obj = this.getRedisData(key,methodSignature);
            if(obj==null){
                //3.尝试获取锁
                //通过方法签名 拼接锁的key
                String locKey = key + ":lock";
                RLock lock = this.redissonClient.getLock(locKey);
                boolean res = lock.tryLock(RedisConst.SKULOCK_EXPIRE_PX1,
                        RedisConst.SKULOCK_EXPIRE_PX2,
                        TimeUnit.SECONDS);
                if(res){
                    try {
                        //4.查询数据存入缓存，解锁
                        //执行方法体，查询数据库
                        obj  = joinPoint.proceed(args);
                        //5.如果没有数据存入空值，防止缓存穿透
                        if(obj==null){
                            Object o = new Object();
                            //不能存入Object，转为JSON字符串
                            redisTemplate.opsForValue().set(key,JSON.toJSONString(o),
                                    RedisConst.SKUKEY_TEMPORARY_TIMEOUT,TimeUnit.SECONDS);
                            return o;
                        }
                        //查到数据，存入缓存
                        this.redisTemplate.opsForValue().set(key,JSON.toJSONString(obj),
                                RedisConst.SKUKEY_TIMEOUT,TimeUnit.SECONDS);
                        return obj;
                    } finally {
                        // 解锁
                        lock.unlock();
                    }
                }else {
                    //6.没有抢到锁，等待自旋
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    return cacheAroundAdvice(joinPoint);
                }
            }else {
                //有缓存数据直接返回
                return obj;
            }
        } catch (Throwable e) {
            //redis宕机!发送消息、通知短信!
            e.printStackTrace();
        }
        //7.查询数据库兜底:防止redis宕机
        return joinPoint.proceed(joinPoint.getArgs());
    }

    private Object getRedisData(String key,MethodSignature methodSignature) {
        //判断缓存数据是否存在，存在直接返回数据
        String strJson = (String) redisTemplate.opsForValue().get(key);
        if(!StringUtils.isEmpty(strJson)){
            //将字符串转换为具体数据类型
            Class returnType = methodSignature.getReturnType();
            return JSON.parseObject(strJson,returnType);
        }
        return null;
    }
}

3. 需要缓存+锁的方法，加入自定义注解 

4. 测试

如何防止二次调用？

三、布隆过滤器

可以解决缓存穿透：uuid随机穿透

底层就是一个二进制数据 默认0，能够判断一个元素在集合中是否存在，

一个元素一定不存在 或者 可能存在，存在一定的误判率{可通过代码调节}

优点：

1. 保密性好：存储的数据是0或1

2. 空间效率和查询时间 O(M) M：数组长度，O(K) K：hash 函数个数

3. 占用空间小

缺点：

误判率、删除困难

原理

存储数据：

1. 通过k个kash 函数计算hash值，对应二进制数组下标

2. 将二进制数组中的 0 改为 1

获取数据：

1. 通过k个kash 函数计算hash值，对应二进制数组下标

2. 如果对应的下标都是1 说明可能存在，如果是0说明一定不存在

原因：可能发生 hash碰撞 (冲突)

误判率和什么有关：hash函数个数、数据长度、数据规模

如何使用：
1.    redisson 整合好了布隆过滤器

2.    设置一些参数，在redis 中

3.    初始化设置：
数据规模，误判率！

4.    保存sku的时候，直接将skuId 添加到布隆过滤器！

5.    在获取数据时判断布隆过滤器中是否有该商品！

如何使用：

1. 初始化配置

@SpringBootApplication
@ComponentScan({"com.atguigu.gmall"})
@EnableDiscoveryClient
//CommandLineRunner:在启动时实现配置初始化
public class ServiceProductApplication implements CommandLineRunner {
   @Autowired
   private RedissonClient redissonClient;

   public static void main(String[] args) {
      SpringApplication.run(ServiceProductApplication.class, args);
   }

   //初始化方法
   @Override
   public void run(String... args) throws Exception {
      //获取布隆过滤器
      RBloomFilter