缓存+分布式锁在 Java 项目中的应用

@ToString
@Data
public class UserInfoTo {

    private Long userId;
    private String userKey;//一定封装

    private boolean tempUser = false;
}

/**
 * 拦截器
 * 在执行目标方法之前，判断用户的登录状态，并封装传递给controller目标请求
 * @author Klaus
 * @date 2022/9/19
 */
public class CartInterceptor implements HandlerInterceptor {

    public static ThreadLocal<UserInfoTo> threadLocal = new ThreadLocal<>();

    /**
     * 目标方法执行之前
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
                             Object handler) throws Exception {
        UserInfoTo userInfoTo = new UserInfoTo();
        HttpSession session = request.getSession();
        MemberRespVo member = (MemberRespVo) session.getAttribute(AuthServerConstant.LOGIN_USER);
        if (member != null){
            //用户登录
            userInfoTo.setUserId(member.getId());
        }
        Cookie[] cookies = request.getCookies();
        if (cookies != null && cookies.length >0){
            for (Cookie cookie : cookies) {
                //user-key
                String name = cookie.getName();
                if (name.equals(CartConstant.TEMP_USER_COOKIE_NAME)){
                    //user-key:  afrwgrgrg3r
                    userInfoTo.setUserKey(cookie.getValue());
                    userInfoTo.setTempUser(true);
                }
            }
        }

        //如果没有临时用户一定分配一个临时用户
        if (StringUtils.isEmpty(userInfoTo.getUserKey())){
            String uuid = UUID.randomUUID().toString();
            userInfoTo.setUserKey(uuid);
        }
        //目标方法执行之前
        threadLocal.set(userInfoTo);
        return true;
    }

    /**
     * 业务执行之后，分配临时用户，让浏览器保存
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        UserInfoTo userInfoTo = threadLocal.get();
        //如果没有临时用户一定保存一个临时用户，默认不是
        if (!userInfoTo.isTempUser()){
            //是临时用户
            //将user-key放入cookie
            Cookie cookie = new Cookie(CartConstant.TEMP_USER_COOKIE_NAME, userInfoTo.getUserKey());
            //作用域
            cookie.setDomain("gulimall.com");
            //持续延迟临时用户的过期时间
            cookie.setMaxAge(CartConstant.TEMP_USER_COOKIE_TIMEOUT);
            //响应头里加入cookie
            response.addCookie(cookie);
        }
    }
}

/**
     * 添加商品到购物车
     *         redirectAttributes.addFlashAttribute():将数据放在session里面可以在页面取出，但是只能取一次
     *         redirectAttributes.addAttribute("skuId", skuId);将数据放在url后面
     * @return
     */
    @GetMapping("/addToCart")
    public String addToCart(@RequestParam("skuId") Long skuId,
                            @RequestParam("num") Integer num,
                            RedirectAttributes redirectAttributes) throws ExecutionException, InterruptedException {

        cartService.addToCart(skuId, num);
//        model.addAttribute("skuId", skuId); //Required Long parameter 'skuId' is not present
        redirectAttributes.addAttribute("skuId", skuId);
        //添加商品到购物车，重定向到成功页面->刷新页面不会再增加购物车数量http://cart.gulimall.com/addToCart?skuId=35&num=1
        return "redirect:http://cart.gulimall.com/addToCartSuccess.html";
    }

/**
 * 整个购物车的内容
 *  需要计算的属性，必须重写他的get方法，保证每次获取属性都会进行计算
 * @author Klaus
 * @date 2022/9/19
 */
public class Cart {

    private List<CartItem> items;

    private Integer countNum;//商品数量

    private Integer countType;//商品类型数量

    private BigDecimal totalAmount;//商品总价

    private BigDecimal reduce = new BigDecimal("0.00");//减免价格

    public List<CartItem> getItems() {
        return items;
    }

    public void setItems(List<CartItem> items) {
        this.items = items;
    }

    /**
     * 统计每一行*数量 再相加
     * @return
     */
    public Integer getCountNum() {
        int count = 0;
        if (items != null && items.size() > 0) {
            for (CartItem item : items) {
                count += item.getCount();
            }
        }
        return count;
    }


    /**
     * 统计每一行相加
     * @return
     */
    public Integer getCountType() {
        int count = 0;
        if (items != null && items.size() > 0) {
            for (CartItem item : items) {
                count += 1;
            }
        }
        return count;
    }



    public BigDecimal getTotalAmount() {
        BigDecimal amount = new BigDecimal("0");
        //1、计算购物项总价
        if (items != null && items.size() > 0) {
            for (CartItem item : items) {
                if (item.getCheck()){
                    //购物项被选中才进行计算
                    BigDecimal totalPrice = item.getTotalPrice();
                    amount = amount.add(totalPrice);
                }
            }
        }

        //2、减去优惠总价
        BigDecimal subtract = amount.subtract(getReduce());
        return subtract;
    }



    public BigDecimal getReduce() {
        return reduce;
    }

    public void setReduce(BigDecimal reduce) {
        this.reduce = reduce;
    }
}

    /**
     * 购物项
     * 例如：
     * {
     * skuId: 2131241,
     * check: true,
     * title: "Apple iphone.....",
     * defaultImage: "...",
     * price: 4999,
     * count: 1,
     * totalPrice: 4999,
     * skuSaleVO: {...}
     * }
     * @author Klaus
     * @date 2022/9/19
     */
    
    public class CartItem {
    
        private Long skuId;
        private Boolean check = true;
        private String title;
        private String image;
        private List<String> skuAttrs;
        private BigDecimal price;
        private Integer count;
        private BigDecimal totalPrice;
    
    	....
    
        /**
         * 计算当前项总价
         * @return
         */
        public BigDecimal getTotalPrice() {
            return this.price.multiply(new BigDecimal("" + this.count));
        }
    
        public void setTotalPrice(BigDecimal totalPrice) {
            this.totalPrice = totalPrice;
        }
    }

 /**
  * 第一层 Map， Key 是用户 id
  * 第二层 Map， Key 是购物车中商品 id， 值是购物项数据
  * 将商品添加到购物车
  *
  * @param skuId
  * @param num
  * @return
  */
 @Override
 public CartItem addToCart(Long skuId, Integer num) throws ExecutionException, InterruptedException {
     //操作购物车
     BoundHashOperations<String, Object, Object> cartOps = getCartOps();
 
 
     String res = (String) cartOps.get(skuId.toString());
     if (StringUtils.isEmpty(res)) {
         //购物车没有这个商品执行以下代码
         //2、添加新商品到购物车
         CartItem cartItem = new CartItem();
         CompletableFuture<Void> getSkuInfoTask = CompletableFuture.runAsync(() -> {
             //1、远程查询当前要添加的商品的信息
             R r = productFeignService.getSkuInfo(skuId);
             SkuInfoVo data = r.getData("skuInfo", new TypeReference<SkuInfoVo>() {
             });
 
             cartItem.setCheck(true);
             cartItem.setCount(num);
             cartItem.setImage(data.getSkuDefaultImg());
             cartItem.setTitle(data.getSkuTitle());
             cartItem.setSkuId(skuId);
             cartItem.setPrice(data.getPrice());
         }, executor);
 
         //3、远程查询sku的组合信息
         CompletableFuture<Void> getSkuSaleAttrValues = CompletableFuture.runAsync(() -> {
             List<String> values = productFeignService.getSkuSaleAttrValues(skuId);
             cartItem.setSkuAttrs(values);
         }, executor);
 
         //异步全部完成才加入缓存
         CompletableFuture.allOf(getSkuInfoTask, getSkuSaleAttrValues).get();
         String s = JSON.toJSONString(cartItem);
         //加入缓存，skuId cartItem
         cartOps.put(skuId.toString(), s);
         return cartItem;
     } else {
         //购物车有此商品，进行数量修改
         CartItem cartItem = JSON.parseObject(res, CartItem.class);
         //当前操作仅修改了逆转回来的数据，还需要更新redis
         cartItem.setCount(cartItem.getCount() + num);
         //再将修改后的数据转为json并存入redis
         cartOps.put(skuId.toString(), JSON.toJSONString(cartItem));
         return cartItem;
     }
 
 
 }

/**
   * 获取到我们要操作的购物车
   *
   * @return
   */
  private BoundHashOperations<String, Object, Object> getCartOps() {
      UserInfoTo userInfoTo = CartInterceptor.threadLocal.get();
      //1、判断用户是否登录了
      String cartKey = "";
      if (userInfoTo.getUserId() != null) {
          //用户登录了
          cartKey = CART_PREFIX + userInfoTo.getUserId();
      } else {
          //用户没登录
          cartKey = CART_PREFIX + userInfoTo.getUserKey();
      }
  
      //将购物车加入缓存绑定操作（hash）
      BoundHashOperations<String, Object, Object> operations = redisTemplate.boundHashOps(cartKey);
      return operations;
  }

/**
     * 浏览器有一个cookie：user-key：标识用户身份，一个月后过期
     * 如果第一次使用jd的购物车功能，都会给一个临时的用户身份
     * 浏览器以后保存，每次访问都会带上这个cookie；
     *
     * 登录：session有
     * 没登录，按照cookie里面带来user-key来做
     * 第一次，如果没有临时用户，会帮忙创建一个临时用户。
     * @return
     */
    @GetMapping("/cart.html")
    public String cartListPage(Model model) throws ExecutionException, InterruptedException {

        //1、快速得到用户信息：id，user-key
//        UserInfoTo userInfoTo = CartInterceptor.threadLocal.get();
//        System.out.println(userInfoTo);

        Cart cart = cartService.getCart();
        model.addAttribute("cart", cart);
        return "cartList";
    }

/**
 * 获取整个购物车
 *
 * @return
 */
@Override
public Cart getCart() throws ExecutionException, InterruptedException {
    Cart cart = new Cart();
    UserInfoTo userInfoTo = CartInterceptor.threadLocal.get();
    if (userInfoTo.getUserId() != null) {
        //1、登录
        String cartKey = CART_PREFIX + userInfoTo.getUserId();
        //1.1、如果临时购物车的数据还没有合并【合并购物车】
        //临时购物车的所有购物项
        String tempCartKey = CART_PREFIX + userInfoTo.getUserKey();
        List<CartItem> tempCartItems = getCartItems(tempCartKey);
        if (tempCartItems != null) {
            //临时购物车有数据，需要合并
            for (CartItem item : tempCartItems) {
                addToCart(item.getSkuId(), item.getCount());
            }
            //合并完后清除临时购物车的数据
            clearCart(tempCartKey);
        }
        //3、获取登录后的购物车数据【包含合并过来的临时购物车的数据，和登录后的购物车数据】
        List<CartItem> cartItems = getCartItems(cartKey);
        cart.setItems(cartItems);

    } else {
        //2、没登录
        String cartKey = CART_PREFIX + userInfoTo.getUserKey();
        //获取临时购物车的所有购物项
        List<CartItem> cartItems = getCartItems(cartKey);
        cart.setItems(cartItems);

    }
    return cart;
}

private List<CartItem> getCartItems(String cartKey) {
    BoundHashOperations<String, Object, Object> hashOps = redisTemplate.boundHashOps(cartKey);
    List<Object> values = hashOps.values();
    if (values != null && values.size() > 0) {
        List<CartItem> collect = values.stream().map((obj) -> {
            String str = (String) obj;
            CartItem cartItem = JSON.parseObject(str, CartItem.class);
            return cartItem;
        }).collect(Collectors.toList());
        return collect;
    }
    return null;
}

/**
 * 跳转到成功页，增加购物车用到2个页面，防止在添加购物车之后再刷新页面时自动增加
 * @param skuId
 * @param model
 * @return
 */
@GetMapping("/addToCartSuccess.html")
public String addToCartSuccessPage(@RequestParam("skuId")Long skuId, Model model){
    //重定向到成功页面，再次查询购物车数据即可
    CartItem item = cartService.getCartItem(skuId);
    model.addAttribute("item", item);
    return "success";
}

/**
 * 获取购物车中某个购物项
 *
 * @param skuId
 * @return
 */
@Override
public CartItem getCartItem(Long skuId) {
    BoundHashOperations<String, Object, Object> cartOps = getCartOps();
    String str = (String) cartOps.get(skuId.toString());
    //将缓存中的数据转为vo对象
    CartItem cartItem = JSON.parseObject(str, CartItem.class);
    return cartItem;
}

@GetMapping("/deleteItem")
public String deleteItem(@RequestParam("skuId") Long skuId){
    cartService.deleteItem(skuId);
    return "redirect:http://cart.gulimall.com/cart.html";
}

/**
 * 删除购物项
 *
 * @param skuId
 */
@Override
public void deleteItem(Long skuId) {
    BoundHashOperations<String, Object, Object> cartOps = getCartOps();
    //删除指定键
    cartOps.delete(skuId.toString());
}

@GetMapping("/countItem")
public String countItem(@RequestParam("skuId") Long skuId,
                        @RequestParam("num") Integer num){
    cartService.changeItemCount(skuId, num);
    return "redirect:http://cart.gulimall.com/cart.html";
}

/**
 * 修改购物项数量
 *
 * @param skuId
 * @param num
 */
@Override
public void changeItemCount(Long skuId, Integer num) {
    CartItem cartItem = getCartItem(skuId);
    cartItem.setCount(num);

    BoundHashOperations<String, Object, Object> cartOps = getCartOps();
    cartOps.put(skuId.toString(), JSON.toJSONString(cartItem));
}

@GetMapping("/checkItem")
public String checkItem(@RequestParam("skuId") Long skuId,
                        @RequestParam("check") Integer check){

    cartService.checkItem(skuId, check);
    return "redirect:http://cart.gulimall.com/cart.html";
}

/**
 * 勾选购物项
 *
 * @param skuId
 * @param check
 */
@Override
public void checkItem(Long skuId, Integer check) {

    BoundHashOperations<String, Object, Object> cartOps = getCartOps();
    CartItem cartItem = getCartItem(skuId);
    cartItem.setCheck(check == 1 ? true : false);

    //将vo对象转为json序列化的文本
    String s = JSON.toJSONString(cartItem);
    cartOps.put(skuId.toString(), s);
}

/**
 * 不是页面跳转需加@ResponseBody
 * @return
 */
@GetMapping("/currentUserCartItems")
@ResponseBody
public List<CartItem> currentUserCartItems(){


    return cartService.getUserCartItems();
}

/**
     * 获取当前用户的所有购物项
     *
     * @return
     */
    @Override
    public List<CartItem> getUserCartItems() {
        UserInfoTo userInfoTo = CartInterceptor.threadLocal.get();
        if (userInfoTo.getUserId() == null){
            //没登录
            return null;
        }else {
            //登录了
            String cartKey = CART_PREFIX + userInfoTo.getUserId();
            List<CartItem> cartItems = getCartItems(cartKey);
            //只要选中了的购物项
            List<CartItem> collect = cartItems.stream().filter(item ->
                item.getCheck()//默认是true
            ).map(item->{
//                R price = productFeignService.getPrice(item.getSkuId());
                BigDecimal price = productFeignService.getPrice(item.getSkuId());
                //todo 更新为最新的价格
//                String data = (String) price.get("data");
//                item.setPrice(new BigDecimal(data));
                item.setPrice(price);
                return item;
            }).collect(Collectors.toList());
            return collect;
        }
    }

/**
 * 核心原理
 * 1、@EnableRedisHttpSession导入RedisHttpSessionConfiguration配置
 *      1）、给容器中添加了一个组件
 *          传入SessionRepository==》【RedisOperationsSessionRepository】===》redis操作session，session的增删改查封装类
 *      2）、SessionRepositoryFilter==》Filter(web)：session存储过滤器；每个请求过来都必须经过Filter
 *         I）、创建的时候，就自动从容器中获取了SessionRepository
 *         II）、原始的HttpServletRequest request, HttpServletResponse response都被分别包装成了SessionRepositoryRequestWrapper，SessionRepositoryResponseWrapper
 *         III）、以后获取session-》request.getSession();（原始的）
 *         //SessionRepositoryRequestWrapper重写getSession方法
 *         IV）、wrapperRequest.getSession();==> SessionRepository中获取的到
 *  装饰者模式；
 *
 *  自动延期；redis中的数据也是有过期时间的
 */
@EnableRedisHttpSession //整合redis作为session存储

/**
 * @author Klaus
 * @date 2022/9/17
 */
@Configuration
public class GulimallSessionConfig {

    @Bean
    public CookieSerializer cookieSerializer(){
        DefaultCookieSerializer cookieSerializer = new DefaultCookieSerializer();

        cookieSerializer.setDomainName("gulimall.com");
        cookieSerializer.setCookieName("KLAUSSESSION");
        return cookieSerializer;
    }

    @Bean
    public RedisSerializer<Object> springSessionDefaultRedisSerializer() {
        return new GenericJackson2JsonRedisSerializer();
    }
}

//本地缓存可以使用map
private Map<String, Object> cache;

@Autowired
StringRedisTemplate stringRedisTemplate;
@Test
public void testStringRedisTemplate(){
ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
ops.set("hello","world_"+ UUID.randomUUID().toString());
String hello = ops.get("hello");
System.out.println(hello);
}

/**
 * 抽取业务方法
 *
 * @return
 */
private Map<String, List<Catalog2Vo>> getDataFromDb() {
    //获取缓存
    String catalogJson = stringRedisTemplate.opsForValue().get("catalogJson");
    if (!StringUtils.isEmpty(catalogJson)) {
        //缓存不为空直接返回
        Map<String, List<Catalog2Vo>> result = JSON.parseObject(catalogJson, new TypeReference<Map<String, List<Catalog2Vo>>>() {
        });
        return result;
    }
    System.out.println("查询了数据库。。。");

    /**
     * 缓存为空，进行查询业务
     * 1、将数据库的多次查询变为一次，即方法抽取
     */
    //查询所有
    List<CategoryEntity> selectList = baseMapper.selectList(null);

    //1、查出所有1级分类                                   父分类集合，一级分类父分类id为0
    List<CategoryEntity> level1Categorys = getParent_cid(selectList, 0L);

    //2、封装数据
    Map<String, List<Catalog2Vo>> map = level1Categorys.stream().collect(Collectors.toMap(
            //"pCId":"c2{}"
            k -> k.getCatId().toString(),
            v -> {
                //2.1、每一个的一级分类，查到这个一级分类的[二级分类]
                //得到二级分类实体集合 抽取查询方法-> baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", v.getCatId()));
                //todo                                                 父分类集合， 当前分类id（v为当前遍历的一级分类）
                List<CategoryEntity> catalog2Entities = getParent_cid(selectList, v.getCatId());
                //2.2、封装上面的结果
                List<Catalog2Vo> catalog2Vos = null;
                //父分类不为空，即二级分类实体集合不为空
                if (catalog2Entities != null) {
                    //遍历拿到每个二级分类集合
                    catalog2Vos = catalog2Entities.stream().map(l2 -> {
                        //封装二级分类vo数据
                        Catalog2Vo catalog2Vo = new Catalog2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName());
                        //2.2.1、找当前二级分类的三级分类封装成vo baseMapper.selectList(new QueryWrapper<CategoryEntity>(). eq("parent_cid", l2.getCatId()));
                        //                                       （三级分类父分类）父分类集合， 当前分类id（l2为当前遍历的二级分类）
                        List<CategoryEntity> catalog3Entities = getParent_cid(selectList, l2.getCatId());
                        List<Catalog2Vo.Catalog3Vo> catalog3Vos = null;
                        if (catalog3Entities != null) {
                            catalog3Vos = catalog3Entities.stream().map(l3 -> {
                                //2.2.2、封装成指定格式
                                Catalog2Vo.Catalog3Vo catalog3Vo = new Catalog2Vo.Catalog3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
                                return catalog3Vo;
                            }).collect(Collectors.toList());
                            catalog2Vo.setCatalog3List(catalog3Vos);
                        }


                        return catalog2Vo;
                    }).collect(Collectors.toList());
                }
                return catalog2Vos;
            }));
    //todo 3、查到的数据再放入缓存，将对象转为json放入缓存中
    String s = JSON.toJSONString(map);
    //将数据放入缓存
    stringRedisTemplate.opsForValue().set("catalogJson", s, 1, TimeUnit.DAYS);
    //将数据库查到的结果直接返回，即将数据库查到的结果放一份到缓存中并返回
    return map;
}

/**
     * 抽取获取父分类id的查询方法，优化三级分类数据获取，使得在压力测试中吞吐量有明显的提高；
     * 查询数据库是影响吞吐量高低的重要因素之一，因此尽量减少数据库的查询
     *
     * @param selectList
     * @param parent_cid
     * @return
     */
    private List<CategoryEntity> getParent_cid(List<CategoryEntity> selectList, Long parent_cid) {
        //return baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", v.getCatId()));
        //直接进行过滤得到当前遍历的父分类id为传入的父分类id
        List<CategoryEntity> collect = selectList.stream().filter(item -> item.getParentCid().equals(parent_cid)).collect(Collectors.toList());
        return collect;
    }

/**
     * 使用redis缓存的同时使用本地锁（同步锁）来执行业务
     *
     * @return
     */
    public Map<String, List<Catalog2Vo>> getCatalogJsonFromDbWithLocalLock() {

        //如果缓存中有就用缓存的
//        Map<String, List<Catalog2Vo>> catalogJson = (Map<String, List<Catalog2Vo>>) cache.get("catalogJson");
//        if (catalogJson.get("catalogJson") == null){
//            //调用业务xxx
//            //返回数据又放入缓存
//            cache.put("catalogJson", parent_cid);
//        }
//        return catalogJson;
        //只要是同一把锁，就能锁住需要的这个锁的所有线程
        //1、synchronized (this):SpringBoot所有的组件在容器中都是单例的
        //todo 本地锁synchronized，JUC(Lock)，在分布式情况下，想要锁住所有，必须使用分布式锁

        //单实例的加锁，即本地锁只能锁住当前进程
        synchronized (this) {
            //得到锁以后，我们应该再去缓存中确定一次，如果没有才需要继续查询
            return getDataFromDb();
        }

    }

Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "0");
        if (lock) {
            // 加锁成功..执行业务
            Map<String,List<Catelog2Vo>> dataFromDb = getDataFromDB();
            redisTemplate.delete("lock"); // 删除锁
            return dataFromDb;
        } else {
            // 加锁失败，重试 synchronized()
            // 休眠100ms重试
            return getCatelogJsonFromDbWithRedisLock();
        }

Boolean lock = redisTemplate.opsForValue().setIfAbsent()
        if (lock) {
            // 加锁成功..执行业务
            // 设置过期时间
            redisTemplate.expire("lock",30,TimeUnit.SECONDS);
            Map<String,List<Catelog2Vo>> dataFromDb = getDataFromDB();
            redisTemplate.delete("lock"); // 删除锁
            return dataFromDb;
        } else {
            // 加锁失败，重试 synchronized()
            // 休眠100ms重试
            return getCatelogJsonFromDbWithRedisLock();
        }

// 设置值同时设置过期时间
Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock","111",300,TimeUnit.SECONDS);
if (lock) {
    // 加锁成功..执行业务
    // 设置过期时间,必须和加锁是同步的，原子的
    redisTemplate.expire("lock",30,TimeUnit.SECONDS);
    Map<String,List<Catelog2Vo>> dataFromDb = getDataFromDB();
    redisTemplate.delete("lock"); // 删除锁
    return dataFromDb;
} else {
    // 加锁失败，重试 synchronized()
    // 休眠100ms重试
    return getCatelogJsonFromDbWithRedisLock();
}

String uuid = UUID.randomUUID().toString();
        // 设置值同时设置过期时间
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock",uuid,300,TimeUnit.SECONDS);
        if (lock) {
            // 加锁成功..执行业务
            // 设置过期时间,必须和加锁是同步的，原子的
//            redisTemplate.expire("lock",30,TimeUnit.SECONDS);
            Map<String,List<Catelog2Vo>> dataFromDb = getDataFromDB();
//            String lockValue = redisTemplate.opsForValue().get("lock");
//            if (lockValue.equals(uuid)) {
//                // 删除我自己的锁
//                redisTemplate.delete("lock"); // 删除锁
//            }
// 通过使用lua脚本进行原子性删除
            String script = "if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end";
                //删除锁
                Long lock1 = redisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class), Arrays.asList("lock"), uuid);

            return dataFromDb;
        } else {
            // 加锁失败，重试 synchronized()
            // 休眠100ms重试
            return getCatelogJsonFromDbWithRedisLock();
        }

 /**
     * 使用redis分布式锁来执行业务（luo脚本解锁）
     *
     * @return
     */
    //@Override
    public Map<String, List<Catalog2Vo>> getCatalogJsonFromDbWithRedisLock() {

        //抢占锁前，每人都获取唯一id设置成lock的value值
        String uuid = UUID.randomUUID().toString();
        //1、占分布式锁，去redis占坑(原子操作)  SET  lock(k)  1111(v)     NX                        EX(时间不能太短)
        Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", uuid, 300, TimeUnit.SECONDS);
        if (lock) {
            System.out.println("获取分布式锁成功.......");
            //2、设置过期时间，防止出现死锁情况(若突然断电而无法执行设置过期时间)
            //因此设置过期时间，必须和加锁是同步的，原子的
            //stringRedisTemplate.expire("lock", 30, TimeUnit.SECONDS);

            Map<String, List<Catalog2Vo>> dataFromDb;
            try {
                //加锁成功.... 执行业务
                dataFromDb = getDataFromDb();
            } finally {
                //无论业务崩溃或异常等情况都执行删除锁，只要保证原子加锁和原子解锁没有问题即可
                //因此可以使用luo脚本解锁来实现原子操作
                //                              指定的lock(key) == 指定的uuid(value)                                        删除返回1，失败返回0
                String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
                //执行脚本，删除锁
                Long lock1 = stringRedisTemplate.execute(
                        //删除key->成功返回1，失败返回0，返回值为Integer
                        new DefaultRedisScript<Long>(script, Long.class),
                        //所有的key集合->得到lock集合
                        Arrays.asList("lock"), uuid);
            }
            //获取值对比+对比成功删除=原子操作，否则，即使比对成功也可能删的是别人的锁
//            String lockValue = stringRedisTemplate.opsForValue().get("lock");
//            //根据占锁的唯一Id值判断是不是同一把锁
//            // 极端情况，10s过期时间，执行业务用了9.5s，但获取锁要发送请求到远程的redis来返回数据，所需时间为0.3s，判断需要1s，
//            // 即比对成功时锁已过期，删的是redis刚更新的抢占锁
//            if (uuid.equals(lockValue)){
//                //是同一把锁就把这把锁删掉
//                //业务执行完毕后解锁-> 删除锁(key)
//                stringRedisTemplate.delete("lock");
//            }

            return dataFromDb;
        } else {
            System.out.println("获取分布式锁失败.......等待重试");
            //加锁失败....重试。。synchronized ()
            //休眠200ms重试
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {

            }
            //自旋的方式-> 重新获取锁
            return getCatalogJsonFromDbWithRedisLock();
        }


    }

/**
     * 抽取缓存操作方法（使用了RedisLock）
     * 没加缓存注解前的缓存操作业务代码（获取分类的json数据）
     * @return
     */
    //@Override
    public Map<String, List<Catalog2Vo>> getCatalogJson2() {

        //给缓存中放json字符串，拿出的json字符串，还要逆转为能用的对象类型【序列化与反序列化】

        /**
         * 1、空结果缓存，解决缓存穿透
         * 2、设置过期时间（加随机值）：解决缓存雪崩
         * 3、加锁：解决缓存击穿
         */

        //1、加入缓存逻辑，缓存中存放的数据是json字符串
        //json跨语言，跨平台兼容
        String catalogJson = stringRedisTemplate.opsForValue().get("catalogJson");
        if (StringUtils.isEmpty(catalogJson)) {
            //2、缓存中没有，查询数据库
            //保证数据库查询完成以后，将数据放在redis中，这是一个原子操作
            System.out.println("缓存不命中。。。。将要查询数据库。。。");
            Map<String, List<Catalog2Vo>> catalogJsonFromDb = getCatalogJsonFromDbWithRedisLock();
//            //3、查到的数据再放入缓存，将对象转为json放入缓存中
//            String s = JSON.toJSONString(catalogJsonFromDb);
//            //将数据放入缓存
//            stringRedisTemplate.opsForValue().set("catalogJson", s, 1, TimeUnit.DAYS);
            //将数据库查到的结果直接返回，即将数据库查到的结果放一份到缓存中并返回
            return catalogJsonFromDb;
        }
        System.out.println("缓存命中。。。。直接返回。。。");
        //将数据转为指定类型
        Map<String, List<Catalog2Vo>> result = JSON.parseObject(catalogJson, new TypeReference<Map<String, List<Catalog2Vo>>>() {
        });
        return result;
    }

/**
 * @author Klaus
 * @date 2022/9/7
 */
@Configuration
public class MyRedissonConfig {

    /**
     * 所有对Redisson的使用都是通过RedissonClient对象
     * @return
     * @throws IOException
     */
    @Bean(destroyMethod="shutdown")
    public RedissonClient redisson() throws IOException {
        //1、创建配置
        //Redis url should start with redis:// or rediss://
        Config config = new Config();
        //可以用"rediss://"来启用 SSL 连接
        config.useSingleServer().setAddress("redis://192.168.10.103:6379");

        //2、根据config创建出Redisson实例
        RedissonClient redissonClient = Redisson.create(config);
        return redissonClient;
    }
}

RLock lock = redisson.getLock("anyLock");// 最常见的使用方法
lock.lock();
// 加锁以后 10 秒钟自动解锁// 无需调用 unlock 方法手动解锁
lock.lock(10, TimeUnit.SECONDS);
// 尝试加锁，最多等待 100 秒，上锁以后 10 秒自动解锁 
boolean res = lock.tryLock(100,10, TimeUnit.SECONDS);
if (res) {
try {
	...
} finally {
	lock.unlock();
	}
}

/**
 * 缓存里面的数据如何和数据库保持一致（使用了RedissonLock）
 * 缓存数据一致性
 * 1）、双写模式
 * 2）、失效模式
 *
 * @return
 */
//@Override
public Map<String, List<Catalog2Vo>> getCatalogJsonFromDbWithRedissonLock() {

    //抢占锁前，每人都获取唯一id设置成lock的value值
    //1、占分布式锁，去redis占坑(原子操作)
    //注意：传的锁名字一样，锁就一样，锁的粒度，越细越快
    //锁的粒度：具体缓存的是某个数据，11号-商品；product-11-lock  product-12-lock product-lock
    RLock lock = redisson.getLock("catalogJson-lock");
    lock.lock();

    Map<String, List<Catalog2Vo>> dataFromDb;
    try {
        dataFromDb = getDataFromDb();
    } finally {
        lock.unlock();
    }
    return dataFromDb;


}

@ResponseBody
@GetMapping("/hello")
public String hello() {

    //1、获取一把锁，只要锁的名字一样，就是同一把锁
    RLock lock = redisson.getLock("my-lock");
    //2、加锁 阻塞式等待，(默认加的锁都是30s时间)即如果加不到锁，就会在这一直等直到加到锁为止才继续执行下去
    //lock.lock();
    //1)、锁的自动续期，如果业务超长，运行期间自动给锁续上新的30s，即不用担心业务时间长而锁自动过期被删掉
    //2)、加锁的业务只要运行完成，就不会给当前锁续期，即使不手动解锁，锁默认在30s以后自动删除
    //10秒自动解锁，自动解锁时间一定要大于业务的执行时间
    lock.lock(30, TimeUnit.SECONDS);
    //todo 问题：lock.lock(10, TimeUnit.SECONDS);在锁时间到了以后，不会自动续期
    //1、如果我们传递了锁的超时时间，就发送给redis执行脚本，进行占锁，默认超时时间就是我们指定的时间
    //2、如果我们未指定锁的超时时间，就使用30*1000【LockWatchingTimeout看门狗的默认时间】；
    //     只要占锁成功，就会启动一个定时任务【重新给锁设置过期时间，新的过期时间就是看门狗的默认时间】，每隔10s都会自动再次续期，续成30s
    //     internalLockLeaseTime【看门狗时间】/  3,10s

    //最佳实战
    //1）、lock.lock(30, TimeUnit.SECONDS);省掉了整个续期操作，手动解锁
    try {
        System.out.println("加锁成功，执行业务。。。" + Thread.currentThread().getId());
        Thread.sleep(30000);
    } catch (Exception e) {

    } finally {
        //3、解锁  假设解锁代码没有运行，redisson会不会出现死锁
        System.out.println("释放锁。。。" + Thread.currentThread().getId());
        lock.unlock();
    }

    return "hello";
}

 /**
     * 保证一定读到最新数据，修改期间，写锁是一个排它锁（互斥锁、独享锁），读锁是一个共享锁
     * 写锁没释放读就必须等待
     * 读 + 读： 相当于无锁，并发读，只会在redis中记录好，所有当前的读锁，它们都会同时加锁成功
     * 写 + 读： 等待写锁释放
     * 写 + 写： 阻塞状态
     * 读 + 写： 有读锁，写也需要等待
     * 只要有写的存在，都必须等待
     * @return
     */
    @ResponseBody
    @GetMapping("/write")
    public String writeValue() {
        RReadWriteLock lock = redisson.getReadWriteLock("rw-lock");
        String s = "";
        RLock rLock = lock.writeLock();
        try {
            //1、改数据加写锁，读数据加读锁
            rLock.lock();
            System.out.println("写锁加锁成功..." + Thread.currentThread().getId());
            //v
            s = UUID.randomUUID().toString();
            Thread.sleep(30000);
            //                                  k         v
            redisTemplate.opsForValue().set("writeValue", s);
        } catch (Exception e) {

        } finally {
            rLock.unlock();
            System.out.println("写锁释放" + Thread.currentThread().getId());
        }
        return s;
    }

    //分布式里的锁跟JUC的API里的锁完全一样
    @ResponseBody
    @GetMapping("/read")
    public String readValue() {
        RReadWriteLock lock = redisson.getReadWriteLock("rw-lock");
//        ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
        String s = "";
        RLock rLock = lock.readLock();
        //1、读数据加读锁
        rLock.lock();
        try {
            System.out.println("读锁加锁成功....." + Thread.currentThread().getId());
            s = redisTemplate.opsForValue().get("writeValue");
            Thread.sleep(30000);
        } catch (Exception e) {

        } finally {
            rLock.unlock();
            System.out.println("读锁释放" + Thread.currentThread().getId());
        }
        return s;
    }

/**
     * 车库停车
     * 3车位
     * 信号量也可以用作分布式限流
     * @return
     */
    @ResponseBody
    @GetMapping("/park")
    public String park() throws InterruptedException {
        RSemaphore park = redisson.getSemaphore("park");
//        park.acquire();//获取一个信号，获取一个值，占一个车位，阻塞式获取，即一定要获取到一个车位
        boolean b = park.tryAcquire();//尝试获取车位，有就停，没有就算了
        if (b){
            //执行业务
        }else {
            return "error";
        }
        return "ok=>" + b;
    }


    /**
     * 把车开走，腾空车位
     * @return
     */
    @ResponseBody
    @GetMapping("/go")
    public String go(){
        RSemaphore park = redisson.getSemaphore("park");
        park.release();//释放一个信号(车位)
        return "ok";
    }

/**
 * 放假 锁门
 * 1班没人了，2
 * 5个班全部都走完，我们可以锁大门
 * @return
 */
@ResponseBody
@GetMapping("/lockDoor")
public String lockDoor() throws InterruptedException {
    RCountDownLatch door = redisson.getCountDownLatch("door");
    door.trySetCount(5);
    door.await();//等待闭锁都完成

    return "放假了...";
}

@ResponseBody
@GetMapping("/gogogo/{id}")
public String gogogo(@PathVariable("id") Long id){
    RCountDownLatch door = redisson.getCountDownLatch("door");
    door.countDown();//计数减一

    return id + "班的人都走了...";
}

/**
 * @author Klaus
 * @date 2022/9/7
 */
@EnableConfigurationProperties(CacheProperties.class)
@EnableCaching
@Configuration
public class MyCacheConfig {

//    @Autowired
//    CacheProperties cacheProperties;

    /**
     * 配置文件中的东西没有用上
     *
     * 1、原来和配置文件绑定的配置类是这样子的
     *      @ConfigurationProperties( prefix = "spring.cache")
     *      public class CacheProperties {
     * 2、要让它生效
     *      @EnableConfigurationProperties(CacheProperties.class)
     * @return
     */
    @Bean
    RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties) {

        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        //config = config.entryTtl();
        //覆盖默认配置
        //将数据的key序列化为字符串
        config = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
        //将数据的值序列化为json格式 new GenericFastJsonRedisSerializer()兼容各种泛型
        config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));

        CacheProperties.Redis redisProperties = cacheProperties.getRedis();
        //将配置文件中的所有配置都生效
        if (redisProperties.getTimeToLive() != null) {
            config = config.entryTtl(redisProperties.getTimeToLive());
        }

        if (redisProperties.getKeyPrefix() != null) {
            config = config.prefixKeysWith(redisProperties.getKeyPrefix());
        }

        if (!redisProperties.isCacheNullValues()) {
            config = config.disableCachingNullValues();
        }

        if (!redisProperties.isUseKeyPrefix()) {
            config = config.disableKeyPrefix();
        }

        return config;
    }
}

//index/catalog.json
@ResponseBody
@GetMapping("/index/catalog.json")
public Map<String, List<Catalog2Vo>> getCatalogJson() {
    Map<String, List<Catalog2Vo>> catalogJson = categoryService.getCatalogJson();
    return catalogJson;
}

/**
 * 加入缓存注解，再次简化缓存操作业务代码
 * @return
 */
@Cacheable(value = "category", key = "#root.methodName")
@Override
public Map<String, List<Catalog2Vo>> getCatalogJson() {
    System.out.println("查询了数据库。。。");

    /**
     * 缓存为空，进行查询业务
     * 1、将数据库的多次查询变为一次，即方法抽取
     */
    //查询所有
    List<CategoryEntity> selectList = baseMapper.selectList(null);

    //1、查出所有1级分类                                   一级分类集合，一级分类父分类id为0
    List<CategoryEntity> level1Categorys = getParent_cid(selectList, 0L);

    //2、封装数据
    Map<String, List<Catalog2Vo>> map = level1Categorys.stream().collect(Collectors.toMap(
            //"pCId":"c2{}"
            k -> k.getCatId().toString(),
            v -> {
                //2.1、每一个的一级分类，查到这个一级分类的[二级分类]
                //得到二级分类实体集合 抽取查询方法-> baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", v.getCatId()));
                //todo                                                 父分类集合， 当前分类id（v为当前遍历的一级分类）
                List<CategoryEntity> catalog2Entities = getParent_cid(selectList, v.getCatId());
                //2.2、封装上面的结果
                List<Catalog2Vo> catalog2Vos = null;
                //父分类不为空，即二级分类实体集合不为空
                if (catalog2Entities != null) {
                    //遍历拿到每个二级分类集合
                    catalog2Vos = catalog2Entities.stream().map(l2 -> {
                        //封装二级分类vo数据
                        Catalog2Vo catalog2Vo = new Catalog2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName());
                        //2.2.1、找当前二级分类的三级分类封装成vo baseMapper.selectList(new QueryWrapper<CategoryEntity>(). eq("parent_cid", l2.getCatId()));
                        //                                       （三级分类父分类）父分类集合， 当前分类id（l2为当前遍历的二级分类）
                        List<CategoryEntity> catalog3Entities = getParent_cid(selectList, l2.getCatId());
                        List<Catalog2Vo.Catalog3Vo> catalog3Vos = null;
                        if (catalog3Entities != null) {
                            catalog3Vos = catalog3Entities.stream().map(l3 -> {
                                //2.2.2、封装成指定格式
                                Catalog2Vo.Catalog3Vo catalog3Vo = new Catalog2Vo.Catalog3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
                                return catalog3Vo;
                            }).collect(Collectors.toList());
                            catalog2Vo.setCatalog3List(catalog3Vos);
                        }


                        return catalog2Vo;
                    }).collect(Collectors.toList());
                }
                return catalog2Vos;
            }));
    return map;
}

@GetMapping({"/", "index.html"})
    public String indexPage(Model model) {
//        System.out.println("" + Thread.currentThread().getId());
        //todo 1、查出所有的1级分类
        List<CategoryEntity> categoryEntityList = categoryService.getLevel1Categorys();

        //视图解析器进行拼接
        //classpath:/templates/ + 返回值 +  .html
        model.addAttribute("categorys", categoryEntityList);
        return "index";
    }

@Cacheable(value = {"category"}, key = "#root.method.name", sync = true)
@Override
public List<CategoryEntity> getLevel1Categorys() {
    System.out.println("getLevel1Categorys.....");
    long l = System.currentTimeMillis();
    //查出一级分类，即父分类为0
    List<CategoryEntity> categoryEntities = baseMapper.selectList(new QueryWrapper<CategoryEntity>().
            eq("parent_cid", 0));
    //System.out.println("消耗时间：" + (System.currentTimeMillis() - l));
    return categoryEntities;
}

//    @Caching(evict = {
//            @CacheEvict(value = "category", key = "'getLevel1Categorys'"),
//            @CacheEvict(value = "category", key = "'getCatalogJson'")
//    })
    //category::key 失效模式
    @CacheEvict(value = "category", allEntries = true)
//    @CachePut//双写模式
    @Transactional
    @Override
    public void updateCascade(CategoryEntity category) {
        //先更新自己
        this.updateById(category);
        categoryBrandRelationService.updateCategory(category.getCatId(), category.getName());

        //同时修改缓存中的数据
        //redis.del("catalogJSON");等待下次主动查询进行更新
    }