一、這次系統來做了下購物車的功能模塊，以下幾個功能吧：

1、查詢購物車列表

2、向購物車添加商品

3、刪除購物車商品

4、修改購物車商品數量

以上四個是傳統的增刪改成功能。

5、購物車商品全選功能實現

6、取消全選功能實現

7、購物車商品單選功能實現

8、取消單個商品的選擇

9、查詢購物車的商品數量功能實現

以上是本次介紹的幾個功能模塊，這其中涉及到一些小的細節處理問題，今天主要來總結下。

之前寫過一個博客介紹了購物車的添加功能模塊，通過這個模塊我們也封裝了購物車的常用方法。

二、購物車功能細節問題明確

（1）當用戶打開用戶自己的購物車的時候，默認的購物車的商品的沒有選的狀態，即購物車中總價是為0的。

（2）購物車中的總結計算問題：只有選擇的商品才會在計算的總價中。

（3）購物車中的全選功能、非全選功能、單選、取消單選功能的技巧問題。

（4）購物車中商品的數量與庫存的問題

三、細節的實現

controller層：

package com.imooc.project.cartcontroller;

import com.imooc.project.cartservice.ICartService;
import com.imooc.project.common.Const;
import com.imooc.project.common.ServerResponse;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.apache.catalina.servlet4preview.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletResponse;


/**
 * 購物車功能模塊實現
 */
@Api(value = "購物車功能實現",tags = {"imoocProject項目的購物車功能實現"})
@RestController
@RequestMapping("/cart/")
public class CartController {

    @Autowired
    private ICartService iCartService;

    @ApiOperation(value = "向購物車內添加商品")
    @PostMapping("add.do")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "userId",value = "用戶id",dataType ="Integer",paramType = "query"),
            @ApiImplicitParam(name = "productId",value = "商品id",dataType ="Integer",paramType = "query"),
            @ApiImplicitParam(name = "count",value ="商品數量",dataType ="Integer",paramType = "query")
    }
    )
    //這裏應該是先判斷用戶是否登錄的，登錄之後獲取用戶的id，然後查詢該用戶的購物車，在這裏模擬用戶
    //購物車功能流程：
    //當用戶未登錄的狀態下，加入購物車，此時商品是保存在cookie中的，用戶換臺電腦購物車就失效。當用戶結算的時候需要用戶的登錄，這一塊的處理也是計算價格庫存
    // 在用戶登錄的前提下，查詢用戶購物車中是否有該商品，如果沒有，則將商品添加到購物車中（這中間牽扯到庫存和商品價格的處理，該商品的總結，該用戶購物車最終的總價），如果有該商品，則增加商品的數量，更新用戶的購物車，計算價格
    public ServerResponse addProductCart(HttpServletRequest request,HttpServletResponse response,Integer userId, Integer productId, Integer count){
       ServerResponse serverResponse;
        if (userId!=null && userId==21) {
             serverResponse = iCartService.addProductCart(userId, productId, count);
        }else{
            //用戶未登錄狀態下的加入購物車功能
            serverResponse= iCartService.addProductCookie(request,response,productId,count);
        }
    return serverResponse;
    }
	
	 @ApiOperation(value = "更新購物車某個產品數量")
	 @PostMapping("update.do‘")
	 @ApiImplicitParams({
            @ApiImplicitParam(name = "productId",value = "商品id",dataType ="Integer",paramType = "query"),
            @ApiImplicitParam(name = "count",value = "商品數量",dataType ="Integer",paramType = "query"),
    }
    )
	 public ServerResponse updateCartQuantity(Integer productId, Integer count){
		 Integer userId=21;
		 return iCartService.updateCartQuantity(userId,productId,count);
	 }
	 
	 @ApiOperation(value = "移除購物車某個產品")
	 @DeleteMapping("delete_product.do")
	 @ApiImplicitParam(name = "productIds",value = "商品id集合",dataType ="Integer",paramType = "query")
	 public ServerResponse deleteProduct(Integer[] productIds){
		 Integer userId=21;
		 return iCartService.deleteProductFromCart(userId,productIds);	 
	 }
	 
	 //購物車List列表
	 @ApiOperation(value = "展示購物車列表")
	 @GetMapping("list.do")
	 public ServerResponse deleteProduct(){
		 Integer userId=21;
		 return iCartService.showCartList(userId);	 
	 }

	 @ApiOperation(value = "購物車選中某個商品")
	 @GetMapping("select.do")
	 @ApiImplicitParam(name = "productId",value = "商品id",dataType ="Integer",paramType = "query")
	 public ServerResponse selectProduct(Integer productId){
	 	int userId=21;
		 return  iCartService.selectProduct(userId,productId,Const.CartProperty.CARTCHECKED);
	 }
	 
	 @ApiOperation(value = "購物車取消選中某個商品")
	 @GetMapping("un_select.do")
	 @ApiImplicitParam(name = "productId",value = "商品id",dataType ="Integer",paramType = "query")
	 public ServerResponse unselectProduct(Integer productId){
	 	Integer userId=21;
	 	return iCartService.unSelectProduct(userId,productId,Const.CartProperty.UN_CHECKED);
	 }
	 @ApiOperation(value = "查詢在購物車裏的產品數量")
	 @GetMapping("get_cart_product_count.do")
	 public ServerResponse getCartProductCount(){
		 Integer userId=21;
		 return iCartService.getCartProductCount(userId);
	 }
	 
	 @ApiOperation(value = "購物車全選")
	 @GetMapping("select_all.do")
	 public ServerResponse selectAllProduct(){
		 Integer userId=21;
		 return iCartService.selectAllProduct(userId, Const.CartProperty.CARTCHECKED);
	 }
	 @ApiOperation(value = "購物車取消全選")
	 @GetMapping("un_select_all.do")
	 public ServerResponse unselectAllProduct(){
		 Integer userId=21;
		 return iCartService.unselectAllProduct(userId,Const.CartProperty.UN_CHECKED);
	 }
	 
	 






}

serviceImpl層：

package com.imooc.project.cartserviceImpl;

import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;
import com.imooc.project.cartVo.CartItmCookieVo;
import com.imooc.project.cartVo.CartProductVoList;
import com.imooc.project.cartVo.CartVo;
import com.imooc.project.cartservice.ICartService;
import com.imooc.project.common.Const;
import com.imooc.project.common.ResponseCode;
import com.imooc.project.common.ServerResponse;
import com.imooc.project.entity.mmall_cart;
import com.imooc.project.entity.mmall_product;
import com.imooc.project.mapper.mmall_cartMapper;
import com.imooc.project.mapper.mmall_productMapper;
import com.imooc.project.util.BigDecimalUtil;
import com.imooc.project.util.CookieUtils;
import org.apache.catalina.servlet4preview.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.servlet.http.HttpServletResponse;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

/**
 * 購物車功能模塊實現
 */
@Service
public class CartServiceImpl implements ICartService {
    @Autowired
    private mmall_cartMapper cartMapper;
    @Autowired
    private mmall_productMapper productMapper;
    //購物車功能流程：
    //當用戶未登錄的狀態下，加入購物車，此時商品是保存在cookie中的，用戶換臺電腦購物車就失效。當用戶結算的時候需要用戶的登錄，這一塊的處理也是計算價格庫存
    // 在用戶登錄的前提下，查詢用戶購物車中是否有該商品，如果沒有，則將商品添加到購物車中（這中間牽扯到庫存和商品價格的處理，該商品的總結，該用戶購物車最終的總價），如果有該商品，則增加商品的數量，更新用戶的購物車，計算價格
    //這種情況是淘寶網站使用的，只有用戶的登錄的狀態下商品才可以加入購物車，保證了數據的同步
    @Override
    public ServerResponse<CartVo> addProductCart(Integer userId,Integer productId,Integer count) {
        if (productId == null || count == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(), ResponseCode.ILLEGAL_ARGUMENT.getDesc());
        }
        //查詢該用戶的購物車中是否有該商品
        mmall_cart cart = cartMapper.selectProductExit(userId, productId);
        mmall_product product = productMapper.selectByPrimaryKey(productId);
        if (cart == null) {
            //如果購物車為空，則購物車沒有此商品，需要插入到購物車
            mmall_cart cartItem = new mmall_cart();
            cartItem.setProductId(productId);
            cartItem.setUserId(userId);
            cartItem.setQuantity(count);
            cartItem.setChecked(Const.CartProperty.CARTCHECKED);
            int i = cartMapper.insert(cartItem);
        } else {
            //如果購物車不為空，則已有此商品，需要更新購物車商品的數量
            int stock = product.getStock();
                cart.setQuantity(cart.getQuantity() + count);
                cartMapper.updateByPrimaryKeySelective(cart);
        }
          return this.list(userId);
    }


    public ServerResponse<CartVo> list (Integer userId){
        CartVo cartVo = this.getCartVoLimit(userId);
        return ServerResponse.createBySuccess(cartVo);
    }
    private CartVo getCartVoLimit(Integer userId){
        //封裝vo展示給前臺,查詢用戶購物車中的商品展示
        CartVo cartVo=new CartVo();
        BigDecimal cartTotalPrice=new BigDecimal("0");
        List<mmall_cart> cartList=cartMapper.selectProductByUserId(userId);
        List<CartProductVoList> list= Lists.newArrayList();
        if (!CollectionUtils.isEmpty(cartList)) {
            for (mmall_cart cartItem : cartList) {
                //開始封裝這個包裝顯示類
                CartProductVoList cartProductVoList = new CartProductVoList();
                cartProductVoList.setId(cartItem.getId());
                cartProductVoList.setUserId(userId);
                cartProductVoList.setProductId(cartItem.getProductId());
                //根據購物車的商品id來查詢該商品的信息
                mmall_product productItem = productMapper.selectByPrimaryKey(cartItem.getProductId());
                if (productItem!=null){
                    cartProductVoList.setProductMainImage(productItem.getMainImage());
                    cartProductVoList.setProductName(productItem.getName());
                    cartProductVoList.setProductStatus(productItem.getStatus());
                    cartProductVoList.setProductStock(productItem.getStock());
                    cartProductVoList.setProductSubtitle(productItem.getSubtitle());
                    cartProductVoList.setProductPrice(productItem.getPrice());
                    //商品庫存限制這個功能
                    int buyLimitCount = 0;
                    if (cartItem.getQuantity()<= productItem.getStock()) {
                        buyLimitCount=cartItem.getQuantity();
                        cartProductVoList.setLimitQuantity(Const.CartProperty.LIMIT_NUM_SUCCESS);
                    } else {
                        //這一步需要註意，當庫存不足時，需要更新購物車庫存
                        buyLimitCount = productItem.getStock();
                        cartProductVoList.setLimitQuantity(Const.CartProperty.LIMIT_NUM_FAIL);
                        //購物車中更新有效庫存,
                        mmall_cart cartForQuantity = new mmall_cart();
                        cartForQuantity.setId(cartItem.getId());
                        cartForQuantity.setQuantity(buyLimitCount);
                        cartMapper.updateByPrimaryKeySelective(cartForQuantity);
                    }
                    cartProductVoList.setQuantity(buyLimitCount);
                    //購物車總價格的問題：一個是該產品的總價，一個是購物車中最後的商品總價
                    //這個是該商品的總價格：商品價格*商品的數量
                    cartProductVoList.setProductTotalPrice(BigDecimalUtil.mul(productItem.getPrice().doubleValue(),cartItem.getQuantity().doubleValue()));
                    cartProductVoList.setProductChecked(cartItem.getChecked());
                }
                //註意這裏的理解：購物車中的商品默認是都沒有選中的，所以當有商品是選中狀態時才會將價格計算到總價中。所以這裏如果購物車全選，則計算的全部的價格，如果沒有全選，則價格為0，如果選中一個，則只有一個的價格
                if (cartItem.getChecked()==Const.CartProperty.CARTCHECKED){
                    cartTotalPrice=BigDecimalUtil.add(cartTotalPrice.doubleValue(),cartProductVoList.getProductTotalPrice().doubleValue());
                }
                list.add(cartProductVoList);
            }
        }
        cartVo.setCartProductVoLists(list);
        cartVo.setAllChecked(this.getAllCheckedStatus(userId));//如果全選則返回true，非全選則返回false
        cartVo.setCartTotalPrice(cartTotalPrice);
        return cartVo;
    }
    private boolean getAllCheckedStatus(Integer userId){
        if(userId == null){
            return false;
        }
        //查詢購物車中該用戶下選中的狀態，checked=0，即未被選中狀態，如果返回0，則表明購物車中全部選中的狀態，返回true
        return cartMapper.selectCartProductCheckedStatusByUserId(userId) == 0;

    }
//用戶未登錄的情況下購物車保存到cookie中，京東網站使用的方法
    @Override
    public ServerResponse addProductCookie(HttpServletRequest request, HttpServletResponse response, Integer productId, Integer count) {
         /*添加購物車商品，首先購物車商品是保存在cookie中的，因為我們只要不付款是沒有什麽作用的。
         * 如何從cookie中讀取購物車列表呢，是利用request來實現的。
         * 第一步：首先判斷cookie中是否存在該商品，如果存在，則商品數量加1，
         * 如果沒有則根據商品id從rest工程中獲取該商品，將商品寫入cookie。
         */
        CartItmCookieVo cartItmCookieVo=null;
        //從cookie中讀取商品
      List<CartItmCookieVo> cookieList=this.getProductByCookie(request);
      List<CartItmCookieVo> list=Lists.newArrayList();
      //遍歷這個列表，查詢購物車中是否存在此商品，如果存在則更新，如果不存在則寫入cookie中
        for (CartItmCookieVo cartItem: cookieList) {
            if (cartItem.getProductId()==productId){
                cartItem.setQuantity(cartItem.getQuantity()+count);
                cartItmCookieVo=cartItem;
                break;
            }else{
                cartItmCookieVo=new CartItmCookieVo();
               mmall_product product=productMapper.selectByPrimaryKey(productId);
                cartItmCookieVo.setId(cartItem.getId());
                cartItmCookieVo.setProductId(productId);
                cartItmCookieVo.setProductName(product.getName());
                if (product.getStock()>=cartItem.getQuantity()) {
                    cartItmCookieVo.setQuantity(cartItem.getQuantity());
                }else{
                    cartItmCookieVo.setQuantity(product.getStock());
                }
                cartItmCookieVo.setProductPrice(product.getPrice());
                cartItmCookieVo.setProductMainImage(product.getMainImage());
                list.add(cartItmCookieVo);
                CookieUtils.setCookie(request,response,"TT_CART",JSON.toJSONString(list),true);
            }
        }
        return ServerResponse.createBySuccess(list);
    }



    //從cookie中讀取商品列表
    private List<CartItmCookieVo> getProductByCookie(HttpServletRequest request) {
       String cookie=CookieUtils.getCookieValue(request,"TT_CART",true);
       //因為cookie中存放的是json格式的數據，所以如果需要轉換成list形式
        if (cookie==null){
            return new ArrayList<>();
        }else{
            //這裏用到了使用阿裏巴巴的fastjson將json轉為list集合的形式
            List<CartItmCookieVo> cartcookieList = JSON.parseArray(cookie, CartItmCookieVo.class);
            return cartcookieList;
        }
    }
	
	//更新購物車中商品的數量
	public ServerResponse updateCartQuantity(Integer userId,Integer productId,Integer count){
		if(userId==null && productId==null){
	return ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(), ResponseCode.ILLEGAL_ARGUMENT.getDesc());
		}
		//查詢用戶的購物車中是否有該商品，如果有則更新商品數量，如果沒有則提示報錯
		mmall_product product=productMapper.selectByPrimaryKey(productId);
		if(product!=null){
			mmall_cart cart=cartMapper.selectProductExit(userId,productId);
		if(cart!=null){
			//因為在下面的展示用戶的購物車列表的時候會對商品的庫存進行比較，重新調整數量，所以這裏就直接設置它加的數量即可
			 cart.setQuantity(count);
			 cartMapper.updateByPrimaryKeySelective(cart);
			 return this.list(userId);
		}else{
			return ServerResponse.createByErrorMessage("該用戶的購物車中無此商品，無法更新商品數量");
		}
		}else{
            return ServerResponse.createByErrorMessage("系統錯誤");
        }
	}
	//刪除購物車中的某個或者某些商品
	public ServerResponse deleteProductFromCart(Integer userId,Integer[] productIds){
		if(userId==null && productIds.length==0){
			return ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(), ResponseCode.ILLEGAL_ARGUMENT.getDesc()); 
		}
		List<mmall_cart> cartList=cartMapper.selectProductByUserId(userId);
		
		if(!CollectionUtils.isEmpty(cartList)){
			cartMapper.deleteProductFromCart(userId,productIds);
			return this.list(userId);
		}else{
			return ServerResponse.createByErrorMessage("該用戶購物車為空");
		}	
	}
	
	//展示購物車列表
	public ServerResponse showCartList(Integer userId){
		if(userId==null){
			return ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(), ResponseCode.ILLEGAL_ARGUMENT.getDesc()); 
		}
		return this.list(userId);
	}

    @Override
    public ServerResponse<CartVo> selectProduct(Integer userId, Integer productId,Integer checked) {
        cartMapper.checkOrUnchecked(userId,productId,checked);
        return this.list(userId);
    }

    @Override
    public ServerResponse unSelectProduct(Integer userId, Integer productId, Integer checked) {
        cartMapper.checkOrUnchecked(userId,productId,checked);
        return this.list(userId);
    }

    @Override
    public ServerResponse selectAllProduct(Integer userId, Integer checked) {
	    cartMapper.checkOrUnchecked(userId,null,checked);
        return this.list(userId);
    }

    @Override
    public ServerResponse unselectAllProduct(Integer userId, Integer checked) {
        cartMapper.checkOrUnchecked(userId,null,checked);
        return this.list(userId);
    }

//獲取購物車中產品的數量，是指購物車中的的產品的數量總和
    @Override
    public ServerResponse getCartProductCount(Integer userId) {
	    if (userId==null){
	        return ServerResponse.createBySuccess(0);
        }

        return ServerResponse.createBySuccess(cartMapper.getCartCount(userId));
    }


}

mapper的幾個文件：

購物車功能完整版12.13