利用Redis处理购物车相关逻辑

添加到购物车

/**
 * 添加普通商品到购物车逻辑
 * @param addCartDto
 * @return
 */
public R<Boolean> addCartForNormalGoods(AddCartDto addCartDto) {
    // 判断商品是否存在
    GoodsSpu goodsSpu = goodsSpuService.selectById(addCartDto.getSpuId());
    if (null == goodsSpu || "1".equals(goodsSpu.getFlagDel())) {
        return R.failMsg(R.FAIL, "没有查询到该商品");
    }
    if (goodsSpu.getGoodsStatus() != GoodsStatusEnum.USABLE_SALE.getIndex()) {
        return R.failMsg("该商品已下架，暂不能加入到购物车");
    }

    // 判断商品规格
    GoodsSku goodsSku = goodsSkuService.selectById(addCartDto.getSkuId());
    if (null == goodsSku || "1".equals(goodsSku.getFlagDel())) {
        return R.failMsg(R.FAIL, "该商品没有此规格");
    }

    if (!goodsSku.getSpuId().equals(goodsSpu.getSpuId())) {
        return R.failMsg(R.FAIL, "该商品没有此规格");
    }

    // 校验缓存中是否已经存在该商品规格
    String userCartKey = UserConstant.USER_PICK_UP_NORMAL_GOODS_PREFIX + addCartDto.getUserId();
    
    // 查询用户购物车
    BoundHashOperations<String, Object, Object> hashOps = getStringRedisTemplate().boundHashOps(userCartKey);
    CartDataDto cart = null;
    if (hashOps.hasKey(addCartDto.getGoodsType() + "_" + goodsSku.getSkuId())) {
        // 如果购物车中已存在该记录的话, 更新数量
        String cartJson = hashOps.get(addCartDto.getGoodsType() + "_" + goodsSku.getSkuId()).toString();
        cart = JSON.parseObject(cartJson, CartDataDto.class);
        cart.setBuyNum(cart.getBuyNum() + addCartDto.getBuyNum());
    } else {
        // 不存在购物车的话重新插入一条记录
        cart = buildCartDataDto(goodsSpu, goodsSku, addCartDto);
    }

    // 将购物车记录写入redis
    hashOps.put(addCartDto.getGoodsType() + "_" + goodsSku.getSkuId(), JSON.toJSONString(cart));
    log.info(String.format("--------------代客下单添加普通商品到购物车成功，入参为:[%s], 返回结果为：[%s]--------------------", new Gson().toJson(addCartDto), new Gson().toJson(cart)));
    return new R(true);
}

/**
 * 构建普通商品购物车对象
 * @param goodsSpu
 * @param goodsSku
 * @param addCartDto
 * @return
 */
private CartDataDto buildCartDataDto(GoodsSpu goodsSpu, GoodsSku goodsSku, AddCartDto addCartDto) {
    CartDataDto cartDataDto = new CartDataDto();
    cartDataDto.setGoodsType(addCartDto.getGoodsType());
    cartDataDto.setStoreId(goodsSpu.getStoreId());
    // 查询店铺信息
    StoreInfoDTO storeInfoDTO = sellerService.getStoreInfo(goodsSpu.getStoreId());
    if (storeInfoDTO != null) {
        cartDataDto.setStoreName(storeInfoDTO.getStoreName());
    }
    cartDataDto.setSpuId(addCartDto.getSpuId());
    cartDataDto.setSpuName(goodsSpu.getName());
    cartDataDto.setSkuId(addCartDto.getSkuId());
    String skuStandardValue = getSkuStandardValue(goodsSku.getSkuId());
    cartDataDto.setSkuStandValue(skuStandardValue);
    cartDataDto.setSkuImg(goodsSku.getImage());
    cartDataDto.setPrice(goodsSku.getPrice().toPlainString());
    // 为购买数量
    cartDataDto.setBuyNum(addCartDto.getBuyNum());

    return cartDataDto;
}

查询购物车列表

public R<ShoppingCartVo> queryCartGoodsCommon(String userKey) {

    BoundHashOperations<String, Object, Object> userKeyOps = getStringRedisTemplate().boundHashOps(userKey);
    List<Object> cartJsonList = userKeyOps.values();
    List<CartDataDto> cartDataDtos = null;
    if (CollectionUtils.isEmpty(cartJsonList)) {
        return new R<>(new ShoppingCartVo());
    }

    cartDataDtos = cartJsonList.stream().map(cartJson -> {
        CartDataDto cart = JSON.parseObject(cartJson.toString(), CartDataDto.class);
        return cart;
    }).collect(Collectors.toList());


    ShoppingCartVo shoppingCartVo = shoppingCartVo = buildSellerGoodsVoListForCart(cartDataDtos, queryCartDto.getUserId());
    return new R(shoppingCartVo);
}

/**
 * 构建购物车列表集合(普通商品)
 * @param cartDtoList
 * @param userId
 * @return
 */
private ShoppingCartVo buildSellerGoodsVoListForCart(List<CartDataDto> cartDtoList, Long userId) {

     // 构建购物车对象信息

.........

 }

 

  更新商品数量信息

/**
 * 代客下单购物车和代客下单更新商品数量公共部分抽出
 * @param updateCartNumDto
 * @return
 */
private R<Boolean> updateCartGoodsNumCommon(UpdateCartNumDto updateCartNumDto) {
    if (null == updateCartNumDto) {
        return R.failMsg(R.FAIL, "更新购物车商品数量参数不能为空");
    }
    if (null == updateCartNumDto.getUserId() || 0 == updateCartNumDto.getUserId()) {
        return R.failMsg("请先登录!");
    }

    // 通过类型，分别判断普通商品或礼包商品是否存在
    if (1 == updateCartNumDto.getGoodsType()) {
        // 普通商品
        // 判断商品是否存在
        GoodsSpu goodsSpu = goodsSpuService.selectById(updateCartNumDto.getSpuId());
        if (null == goodsSpu) {
            return R.failMsg(R.FAIL, "该商品不存在");
        }

        // 判断商品规格
        GoodsSku goodsSku = goodsSkuService.selectById(updateCartNumDto.getSkuId());
        if (null == goodsSku) {
            return R.failMsg(R.FAIL, "该商品没有此规格");
        }

        if (!goodsSku.getSpuId().equals(goodsSpu.getSpuId())) {
            return R.failMsg(R.FAIL, "该商品没有此规格");
        }
    } else if (2 == updateCartNumDto.getGoodsType()) {
        // 礼包商品
        ComboGoods goods = comboGoodsMapper.selectById(updateCartNumDto.getSpuId());
        if (null == goods) {
            return R.failMsg("该商品不存在");
        }
        ComboGoodsSku goodsSku = comboGoodsSkuService.selectById(updateCartNumDto.getSkuId());
        if (null == goodsSku) {
            return R.failMsg("该商品没有此sku信息");
        }

        if (!goodsSku.getGoodsId().equals(goods.getGoodsId())) {
            return R.failMsg("商品信息不正确");
        }
    }

    // 获取hash操作对象
    String userCartKey = UserConstant.USER_PICK_UP_NORMAL_GOODS_PREFIX + updateCartNumDto.getUserId();
    BoundHashOperations<String, Object, Object> hashOperations = getStringRedisTemplate().boundHashOps(userCartKey);
    String skuIdkey = updateCartNumDto.getGoodsType() + "_" + updateCartNumDto.getSkuId();
    if (hashOperations.hasKey(skuIdkey)) {
        // 获取购物车信息
        String cartJson = hashOperations.get(skuIdkey).toString();
        CartDataDto updateDto = JSON.parseObject(cartJson, CartDataDto.class);
        // 更新数量
        updateDto.setBuyNum(updateCartNumDto.getBuyNum());
        // 写入购物车
        hashOperations.put(skuIdkey, JSON.toJSONString(updateDto));
        log.info(String.format("代客下单--更新购物车商品数量成功！入参为[%s], 返回结果为[%s]", new Gson().toJson(updateCartNumDto), new Gson().toJson(hashOperations.get(skuIdkey))));
    }

    return new R<>(true);
}

删除购物车中某一项商品

public R<Boolean> delGoodsForPickUp(DelCartDto delCartDto) {
    log.info(String.format("我要提货-购物车提货商品列表删除商品，入参为[%s]", new Gson().toJson(delCartDto)));
    // 获取hash操作对象
    String userCartKey = UserConstant.USER_PICK_UP_NORMAL_GOODS_PREFIX + delCartDto.getUserId();
    // 获取商品类型作为取哪种集合的参数
    DelCartParamDto delCartParamDto = delCartDto.getParamDtos().get(0);

    BoundHashOperations<String, Object, Object> hashOperations = getStringRedisTemplate().boundHashOps(userCartKey);
    for (DelCartParamDto paramDto : delCartDto.getParamDtos()) {
        String skuIdkey = paramDto.getGoodsType() + "_" + paramDto.getSkuId();
        if (!hashOperations.hasKey(skuIdkey)) {
            log.error(String.format("我要提货-购物车提货商品列表删除商品--购物车中sku信息不存在，入参为：[%s]", skuIdkey));
        }
        hashOperations.delete(skuIdkey);
    }
    return new R<>(true);
}

方式非常简单，只需要一层层获取第二层的key,即可直接删除，非常方便。

如果要清空购物车的话，直接清空redis的key即可。

 

此种方式有一个不好的点是将购物车对象转换成了一个json字符串，其实可以直接存对象，这样会少一层对象转换的开销，本篇文章的主要目的在于介绍用redis集合的方式存购物车的多层集合，太方便了，比先前直接存一个对象，然后转存json的方式好太多了，购物车列表的显示速度也快了很多。

https://www.iteye.com/blog/357029540-2398599    BoundHashOps的用法