购物车业务

一、分析购物车vo

（1）添加成功页
在这里插入图片描述

public class CartItemVo implements Serializable {

    /**
     * 商品id
     */
    private Long skuId;

    /**
     * 是否选中
     */
    private Boolean check = true;

    /**
     * 商品标题
     */
    private String title;

    /**
     * 商品图片
     */
    private String image;

    /**
     * 商品属性
     */
    private List<String> skuAttrValues;

    /**
     * 商品价格
     */
    private BigDecimal price;

    /**
     * 商品数量
     */
    private Integer count;

    /**
     * 商品总价 = 价格 * 数量
     */
    private BigDecimal totalPrice;




    public Long getSkuId() {
        return skuId;
    }

    public void setSkuId(Long skuId) {
        this.skuId = skuId;
    }

    public Boolean getCheck() {
        return check;
    }

    public void setCheck(Boolean check) {
        this.check = check;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getImage() {
        return image;
    }

    public void setImage(String image) {
        this.image = image;
    }

    public List<String> getSkuAttrValues() {
        return skuAttrValues;
    }

    public void setSkuAttrValues(List<String> skuAttrValues) {
        this.skuAttrValues = skuAttrValues;
    }

    public BigDecimal getPrice() {
        return price;
    }

    public void setPrice(BigDecimal price) {
        this.price = price;
    }

    public Integer getCount() {
        return count;
    }

    public void setCount(Integer count) {
        this.count = count;
    }

    /**
     * 计算当前购物项总价
     * @return
     */
    public BigDecimal getTotalPrice() {
        return this.price.multiply(new BigDecimal(this.count.toString()));
    }

    public void setTotalPrice(BigDecimal totalPrice) {
        this.totalPrice = totalPrice;
    }

    @Override
    public String toString() {
        return "CartItemVo{" +
                "skuId=" + skuId +
                ", check=" + check +
                ", title='" + title + '\'' +
                ", image='" + image + '\'' +
                ", skuAttrValues=" + skuAttrValues +
                ", price=" + price +
                ", count=" + count +
                ", totalPrice=" + totalPrice +
                '}';
    }
}

（2）结算页
在这里插入图片描述

public class Cart {

    /**
     * 购物车子项信息
     */
    List<CartItemVo> items;

    /**
     * 购物车商品总数
     */
    private Integer countNum;

    /**
     * 商品类型数量，有几种商品
     */
    private Integer countType;

    /**
     * 结算价格 = 选中的商品价格 - 优惠价格
     */
    private BigDecimal totalAmount;

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



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

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

    public Integer getCountNum() {
        int count = 0;
        if (items != null && items.size() > 0) {
            for (CartItemVo item : items) {
                count += item.getCount();
            }
        }
        return count;
    }

    public Integer getCountType() {
        int count = 0;
        if (items != null && items.size() > 0) {
            for (CartItemVo item : items) {
                count += 1;
            }
        }
        return count;
    }


    public BigDecimal getTotalAmount() {
        BigDecimal amount = new BigDecimal("0");
        // 计算购物项总价
        if (!CollectionUtils.isEmpty(items)) {
            for (CartItemVo cartItem : items) {
                if (cartItem.getCheck()) {
                    amount = amount.add(cartItem.getTotalPrice());
                }
            }
        }
        // 计算优惠后的价格
        return amount.subtract(getReduce());
    }

    public BigDecimal getReduce() {
        return reduce;
    }

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

二、添加商品到购物车

购物车存储结构： Map<（redis的key）用户id, Map<商品skuId, 商品信息>>
1.通过ThreadLocal获取cookie中保存的用户信息，判断用户是否登陆，分别配置redis的key（boundHashOps）
2.如果购物车中已经存在该商品，只需要修改商品件数，不需要重新添加
3.feign获取sku商品信息、属性列表，使用CompletableFuture异步编排提升效率

为什么线程池不能放在common中？
为什么使用同一个线程池？
如果不添加自定义线程池会怎么样？如果不指定线程池，默认使用 ForkJoinPool，是守护线程，主线程结束，线程池关闭，自定义线程池的需要手动关闭，
为什么通过调用get方法来完成操作，CompletableFuture.anyOf(skuRunAsync,skuAttrRunAsync).get(); ？等待所有线程执行结束
为什么自定义线程后，调用线程却是调用 ThreadPoolExecutor ？
user-key是什么时候生成的？

此方法是将商品数据存入redis，这里选用redis是因为添加购物车操作会频繁的交互数据库，但是redis的持久性有没有数据库好，所有需要增强redis的持久性，redis存数据会使用序列化操作转成字符流进行保存，我们查看数据和获取都不方便，这里直接转换为JSON格式进行存储

/**
     * 加入购物车
     */
    @Override
    public CartItemVo addToCart(Long skuId, Integer num) throws ExecutionException, InterruptedException {

        //绑定key值，不用要一直set key值，使用hash存储方便查询数据

        CartItemVo cartItemVo = new CartItemVo();
        BoundHashOperations<String, Object, Object> boundHashOperations = extracted();


        /**
         * 1.如果redis中已经保存了该商品，则只需要添加件数
         */
        String res = (String) boundHashOperations.get(Long.toString(skuId));
        if (!StringUtils.isEmpty(res)){
            CartItemVo itemVo = JSON.parseObject(res, CartItemVo.class);
            itemVo.setCount(itemVo.getCount() + num);
            String jsonString = JSON.toJSONString(itemVo);
            //这里是直接覆盖？
            boundHashOperations.put(Long.toString(skuId),jsonString);
            return itemVo;
        }

        /**
         * 2.如果redis中未保存该商品
         */
        //查询sku商品信息
        CompletableFuture<Void> skuRunAsync = CompletableFuture.runAsync(new Runnable() {
            @Override
            public void run() {
                R<SkuInfoVo> info = productFeignService.info(skuId);
                if (info.getCode() == 0) {
                    SkuInfoVo skuInfoVo = info.getData(new TypeReference<SkuInfoVo>() {
                    });
                    cartItemVo.setSkuId(skuId);
                    cartItemVo.setCheck(true);
                    cartItemVo.setTitle(skuInfoVo.getSkuTitle());
                    cartItemVo.setImage(skuInfoVo.getSkuDefaultImg());
                    cartItemVo.setPrice(skuInfoVo.getPrice());
                    cartItemVo.setCount(num);
                }
            }
        }, executor);

        //查询sku属性列表
        CompletableFuture<Void> skuAttrRunAsync = CompletableFuture.runAsync(new Runnable() {
            @Override
            public void run() {
                R<List<String>> skuAttr = productFeignService.getSkuAttr(skuId);
                if (skuAttr.getCode() == 0) {
                    List<String> skuAttrData = skuAttr.getData(new TypeReference<List<String>>() {
                    });
                    cartItemVo.setSkuAttrValues(skuAttrData);
                }
            }
        }, executor);

        //等待所有的异步任务全部完成
        CompletableFuture.allOf(skuRunAsync,skuAttrRunAsync).get();

        /**
         * redis存数据会使用序列号操作转成字符流进行保存，我们查询数据和获取都不方便，这里直接转换为JSON格式进行存储
         */
        //存入redis
        String cartJson = JSON.toJSONString(cartItemVo);
        boundHashOperations.put(Long.toString(skuId),cartJson);

        System.out.println();
        return cartItemVo;
    }

封装redis的prefix前缀

 /**
     * 封装redis的prefix前缀
     */
    private BoundHashOperations<String, Object, Object> extracted() {
        UserInfoTo userInfoTo = CartIntercept.toThreadLocal.get();
        String redisKey = "";
        //判断用户是否登陆->封装前缀
        if (userInfoTo.getUserId() != null){
            //gulimall:cart:1
            redisKey = CartConstant.CART_PREFIX + userInfoTo.getUserId();
        }else {
            redisKey = CartConstant.CART_PREFIX + userInfoTo.getUserKey();
        }
        //绑定key值
        BoundHashOperations<String, Object, Object> boundHashOperations = redisTemplate.boundHashOps(redisKey);
        return boundHashOperations;
    }

三、合并购物车（离线购物车与在线购物车合并）

 （1）已登录
     1. 获取离线购物车数据
          如果有离线购物数据，有就取出数据，将离线购物数据与已登录购物数据合并，直接将离线数据添加到已登录的redis中，删除离线的redis
	            （1）如果离线购物车没数据，则只需要返回在线购物车的数据
	            （2）如果离线购物车有数据就合并数据
	            上面两种判断都涉及到离线购物车的数据，所以应该先做离线操作，
	            并且我们只需要返回在线购物车的数据，所以获取在线购物车的操作更因为放在最后执行
	            总结：以后再碰见 if(xx == null){}else(xx != null){} 的操作应该直接走 if(xx != null){}
	 2.获取已登录购物车数据，返回
 （2）离线
      获取离线购物车数据，返回

@Override
    public Cart getCart() throws ExecutionException, InterruptedException {
        Cart cart = new Cart();
        UserInfoTo userInfoTo = CartIntercept.toThreadLocal.get();
        //在线购物车（已登录用户的redis的key）
        String onlineKey = CartConstant.CART_PREFIX + userInfoTo.getUserId();
        //离线购物车（临时用户的redis的key）
        String offlineKey = CartConstant.CART_PREFIX + userInfoTo.getUserKey();
        /**
         * 已登录
         */
        if (userInfoTo.getUserId() != null){

            /**
             * 这里是要做两次判断的
             * （1）如果离线购物车没数据，则只需要返回在线购物车的数据
             * （2）如果离线购物车有数据就合并数据
             *  上面两种判断都涉及到离线购物车的数据，所以应该先做离线操作，
             *  并且我们只需要返回在线购物车的数据，所以获取在线购物车的操作更因为放在最后执行
             *  总结：以后再碰见 if(xx == null){}else(xx != null){} 的操作应该直接走 if(xx != null){}
             */
            //判断离线是否有购物数据
            List<CartItemVo> offlineVos = getCartFromRedis(offlineKey);
            if (offlineVos != null){
                //如果离线购物车有数据，就合并数据->将离线数据添加到已登录的数据中
                for (CartItemVo offlineVo : offlineVos) {
                    /**
                     * 因为上面已经判断了用户已经登录，证明UserInfo的userId是存在的
                     * addToCart()也会通过extracted()得到已登录的redisKey
                     * 所有这里执行添加购物车的操作会直接添加到已登录的购物车中
                     */
                    addToCart(offlineVo.getSkuId(),offlineVo.getCount());
                    //删除离线数据
                    redisTemplate.delete(offlineKey);
                }
            }
            //再次查询在线购物车的数据，并返回
            cart.setItems(getCartFromRedis(onlineKey));
        }else {
            /**
             * 离线
             */
            cart.setItems(getCartFromRedis(offlineKey));
        }
        return cart;
    }

根据key获取redis中存的值

 /**
     * 根据key获取redis中存的值
     */
    @Override
    public List<CartItemVo> getCartFromRedis(String redisKey) {
        BoundHashOperations<String, Object, Object> ops = redisTemplate.boundHashOps(redisKey);
        List<Object> values = ops.values();
        if (values != null && values.size() > 0){
            List<CartItemVo> collect = values.stream().map(obj -> {
                //因为我们存购物数据是使用的JSON格式，所有取数据时直接json字符串转java对象
                String str = (String) obj;
                CartItemVo itemVo = JSON.parseObject(str, CartItemVo.class);
                return itemVo;
            }).collect(Collectors.toList());
            return collect;
        }
        return null;
    }