第11章-购物车

学习目标：

能够说出购物车业务需求
搭建购物车模块
完成新增购物车功能
完成购物车合并功能
完成购物车商品选中删除购物车功能

1、购物车业务简介

购物车模块要能过存储顾客所选的的商品，记录下所选商品，还要能随时更新，当用户决定购买时，用户可以选择决定购买的商品进入结算页面。

功能要求：

1) 利用缓存提高性能。

2) 未登录状态也可以存入购物车，一旦用户登录要进行合并操作。

2、购物车模块搭建

购物车添加展示流程：

2.1 搭建service-cart服务

选中gmall-service父工程，创建子模块：service-cart 。搭建方式如service-item

2.2 配置pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>gmall-service</artifactId>
        <groupId>com.atguigu.gmall</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>service-cart</artifactId>

    <dependencies>
        <dependency>
            <groupId>com.atguigu.gmall</groupId>
            <artifactId>service-product-client</artifactId>
            <version>1.0</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>service-cart</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2.3 启动类

package com.atguigu.gmall;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.ComponentScan;

@EnableFeignClients
@EnableDiscoveryClient
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class CartApp {
    public static void main(String[] args) {
        SpringApplication.run(CartApp.class, args);
    }
}

2.3 添加配置文件

在resources目录下创建：bootstrap.properties

spring.application.name=service-cart
spring.profiles.active=dev
spring.cloud.nacos.discovery.server-addr=192.168.200.128:8848
spring.cloud.nacos.config.server-addr=192.168.200.128:8848
spring.cloud.nacos.config.prefix=${spring.application.name}
spring.cloud.nacos.config.file-extension=yaml
spring.cloud.nacos.config.shared-configs[0].data-id=common.yaml

3、功能—添加入购物车

3.1 功能解析：

1、商品详情页添加购物车

2、添加购物车，用户可以不需要登录，如果用户没有登录，则生成临时用户id，购物车商品与临时用户id关联，当用户登录后，将临时用户id的购物车商品与登录用户id的商品合并

3、商品详情添加购物车时，先判断用户是否登录，如果没登录，再判断是否存在临时用户，如果cookie中也没有临时用户，则生成临时用户

3.2 处理临时用户

3.2.1 商品详情页

商品详情添加购物车页面方法（/item/index.html）：

addToCart() {
    // 判断是否登录和是否存在临时用户，如果都没有，添加临时用户
    if(!auth.isTokenExist() && !auth.isUserTempIdExist()) {
        auth.setUserTempId()
    }
    window.location.href = 'http://cart.gmall.com/addCart.html?skuId=' + this.skuId + '&skuNum=' + this.skuNum
}

3.2.2 服务网关处理

思路：既然userId是从服务网关统一传递过来的，那么临时用户id我们也可以从网关传递过来，改造网关

网关中获取临时用户id

在gmall-gateway 项目中过滤器AuthGlobalFilter添加

/**
 * 尝试获取临时用户ID
 *
 * @param request
 * @return
 */
private String getUserTempId(ServerHttpRequest request) {
    String userTempId = "";

    //1.尝试从cookie中获取
    List<HttpCookie> cookieList = request.getCookies().get("userTempId");
    if (!CollectionUtils.isEmpty(cookieList)) {
        userTempId = cookieList.get(0).getValue();
        return userTempId;
    }

    //2.尝试从请求头中获取
    userTempId = request.getHeaders().getFirst("userTempId");
    if(StringUtils.isNotBlank(userTempId)){
        return userTempId;
    }
    return userTempId;
}

将userTempId 添加header请求头

 //5.将获取到用户ID设置到请求头中，将用户ID传输到目标微服务
if (StringUtils.isNotBlank(userId)) {
    request.mutate().header("userId", userId);
}
//将获取到临时用户ID设置到请求头
String userTempId = getUserTempId(request);
if (StringUtils.isNotBlank(userTempId)) {
    request.mutate().header("userTempId", userTempId);
}

AuthContextHolder类添加公共方法

package com.atguigu.gmall.common.util;


import javax.servlet.http.HttpServletRequest;


 /**
 * @author: atguigu
 * @create: 2023-01-11 10:31
 */
public class AuthContextHolder {


    /**
     * 从请求对象中获取用户ID
     *
     * @return
     */
    public static String getUserId(HttpServletRequest request) {
        String userId = request.getHeader("userId");
        return org.apache.commons.lang.StringUtils.isNotBlank(userId) ? userId : "";
    }


    /**
     * 从请求对象中获取临时用户ID
     *
     * @return
     */
    public static String getUserTempId(HttpServletRequest request) {
        String userTempId = request.getHeader("userTempId");
        return org.apache.commons.lang.StringUtils.isNotBlank(userTempId) ? userTempId : "";
    }
}

3.3 功能开发：

YAPI接口地址：http://192.168.200.128:3000/project/11/interface/api/683

3.3.1 创建实体

package com.atguigu.gmall.model.cart;

import com.atguigu.gmall.model.activity.CouponInfo;
import com.atguigu.gmall.model.base.BaseEntity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.math.BigDecimal;
import java.sql.Timestamp;
import java.util.List;

@Data
@ApiModel(description = "购物车")
//@TableName("cart_info")
public class CartInfo extends BaseEntity {
    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "用户id")
    private String userId;

    @ApiModelProperty(value = "skuid")
    private Long skuId;

    @ApiModelProperty(value = "放入购物车时价格")
    private BigDecimal cartPrice;  // 1999

    @ApiModelProperty(value = "数量")
    private Integer skuNum;

    @ApiModelProperty(value = "图片文件")
    private String imgUrl;
    //  根据skuId ---> skuInfo 找名称, 减少关联查询，提供检索效率.
    @ApiModelProperty(value = "sku名称 (冗余)")
    private String skuName;

    //  选择状态 默认 1 = 选中  0 = 未选中
    @ApiModelProperty(value = "isChecked")
    private Integer isChecked = 1;

    // 实时价格 skuInfo.price
    BigDecimal skuPrice;  // 元旦 1888 | 提示 比加入时，降价了，还是涨价了

    //  优惠券信息列表
    @ApiModelProperty(value = "购物项对应的优惠券信息")
    @TableField(exist = false)
    private List<CouponInfo> couponInfoList;

}

3.3.2 添加购物车控制器

YAPI接口文档：http://192.168.200.128:3000/project/11/interface/api/683

package com.atguigu.gmall.controller;

import com.atguigu.gmall.service.CartService;
import com.atguigu.gmall.common.result.Result;
import com.atguigu.gmall.common.util.AuthContextHolder;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

/**
 * @author: atguigu
 * @create: 2023-01-11 10:46
 */
@RestController
@RequestMapping("/api/cart")
public class CarApiController {


    @Autowired
    private CartService cartService;


    /**
     * 用户将商品加入到购物车
     *
     * @param skuId  商品SKUID
     * @param skuNum 商品加购的数量
     * @return
     */
    @GetMapping("/addToCart/{skuId}/{skuNum}")
    public Result addToCart(HttpServletRequest request, @PathVariable("skuId") Long skuId, @PathVariable("skuNum") Integer skuNum) {
        //声明用户ID遍历：可能是登录用户ID也可能是临时用户ID
        String userId = "";
        userId = AuthContextHolder.getUserId(request);
        if (StringUtils.isBlank(userId)) {
            userId = AuthContextHolder.getUserTempId(request);
        }
        cartService.addToCart(userId, skuId, skuNum);
        return Result.ok();
    }
}

3.3.3 业务接口

package com.atguigu.gmall.service;

public interface CartService {
    /**
     * 用户将商品加入到购物车
     *
     * @param userId 用户ID
     * @param skuId 商品SKUID
     * @param skuNum 商品加购的数量
     * @return
     */
    void addToCart(String userId, Long skuId, Integer skuNum);
}

3.3.4 业务实现类

定义业务需要使用的常量，RedisConst类

public static final String USER_KEY_PREFIX = "user:";
public static final String USER_CART_KEY_SUFFIX = ":cart";
public static final long USER_CART_EXPIRE = 60 * 60 * 24 * 30;

package com.atguigu.gmall.cart.service.impl;

import com.atguigu.gmall.cart.model.CartInfo;
import com.atguigu.gmall.cart.service.CartService;
import com.atguigu.gmall.common.constant.RedisConst;
import com.atguigu.gmall.product.client.ProductFeignClient;
import com.atguigu.gmall.product.model.SkuInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundHashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.Date;

/**
 * @author: atguigu
 * @create: 2023-03-08 10:42
 */
@Service
public class CartServiceImpl implements CartService {

    @Autowired
    private RedisTemplate redisTemplate;


    @Autowired
    private ProductFeignClient productFeignClient;

        /**
     * 将商品加入购物车
     *
     * @param userId
     * @param skuId
     * @param skuNum
     */
    @Override
    public void addToCart(String userId, Long skuId, Integer skuNum) {
        //1 构建用户的购物车hash结构Key  形式:user:用户ID:cart
        String redisKey = getCartKey(userId);

        //2 判断当前商品ID是否在Hash接口中,如果存在-对购物数量累加;如果不存在构建新CarInfo对象存入Redis
        //2.1 创建操作某个用户购物车hash结构操作对象
        BoundHashOperations<String, String, CartInfo> hashOps = redisTemplate.boundHashOps(redisKey);
        //2.2 判断商品是否存在购物车中
        CartInfo cartInfo = null;
        if (hashOps.hasKey(skuId.toString())) {
            //存在-对购物数量累加,修改更新时间
            cartInfo = hashOps.get(skuId.toString());
            cartInfo.setSkuNum(cartInfo.getSkuNum() + skuNum);
            cartInfo.setUpdateTime(new Date());
            //hashOps.put(skuId.toString(), cartInfo);
        } else {
            //不存在构建新CarInfo对象存入Redis
            //远程调用商品微服务 获取商品信息
            SkuInfo skuInfo = productFeignClient.getSkuInfoAndImages(skuId);
            BigDecimal skuPrice = productFeignClient.getSkuPrice(skuId);
            if (skuInfo != null) {
                cartInfo = new CartInfo();
                cartInfo.setSkuPrice(skuPrice);
                cartInfo.setCartPrice(skuPrice);
                cartInfo.setImgUrl(skuInfo.getSkuDefaultImg());
                cartInfo.setSkuId(skuId);
                cartInfo.setSkuName(skuInfo.getSkuName());
                cartInfo.setSkuNum(skuNum);
                cartInfo.setUserId(userId);
                cartInfo.setUpdateTime(new Date());
                cartInfo.setCreateTime(new Date());
            }
        }
        // 无论新增 修改购物车 都需要写会到Redis中
        hashOps.put(skuId.toString(), cartInfo);
    }


    /**
     * 获取用户(登录用户/临时用户)购物车hash结构的Key
     *
     * @param userId
     * @return
     */
    private String getCartKey(String userId) {
        String redisKey = RedisConst.USER_KEY_PREFIX + userId + RedisConst.USER_CART_KEY_SUFFIX;
        return redisKey;
    }
}

4、功能—展示购物车列表

YAPI接口地址：http://192.168.200.128:3000/project/11/interface/api/675

4.1 功能解析

4.2 控制器：CartController

/**
 * 获取用户购物车商品列表(包含购物车合并逻辑)
 *
 * @param request
 * @return
 */
@GetMapping("/cartList")
public Result cartList(HttpServletRequest request) {
    //1.获取用户ID
    String userId = AuthContextHolder.getUserId(request);
    //2.获取临时用户ID
    String userTempId = AuthContextHolder.getUserTempId(request);
    //3.调用业务合并购物车业务
    List<CartInfo> cartInfoList = cartService.cartList(userId, userTempId);
    return Result.ok(cartInfoList);
}

4.3 购物车列表接口：CartService

/**
 * 查询用户购物车列表
 * 版本1：分别查询未登录购物车列表，以及登录的购物车列表
 * 版本2：将两个购物车中商品合并
 * @return
 */
List<CartInfo> cartList(String userId, String userTempId);

4.4 实现类：CartServiceImpl

/**
 * 查询用户购物车列表
 * 版本1：分别查询未登录购物车列表，以及登录的购物车列表
 * 版本2：将两个购物车中商品合并
 *
 * @return
 */
@Override
public List<CartInfo> cartList(String userId, String userTempId) {
    //1.查询未登录购物车列表
    List<CartInfo> cartInfoList = null;
    //1.1 判断临时用户有值情况下 redis中获取购物车列表
    if (StringUtils.isNotBlank(userTempId)) {
        //1.2 构建redisKey 创建hash操作对象
        String noLogCartKey = getCartKey(userTempId);
        BoundHashOperations<String, String, CartInfo> noLoginHashOps = redisTemplate.boundHashOps(noLogCartKey);
        cartInfoList = noLoginHashOps.values();
    }

    //3.已登录的购物车列表
    //3.1 判断用户有值情况下 redis中获取购物车列表
    if (StringUtils.isNotBlank(userId)) {
        //3.2 构建redisKey 创建hash操作对象
        String loginCartKey = getCartKey(userId);
        BoundHashOperations<String, String, CartInfo> loginHashOps = redisTemplate.boundHashOps(loginCartKey);
        cartInfoList = loginHashOps.values();
    }

    //4.对购物车商品数据进行排序
    cartInfoList.sort((o1, o2) -> {
        return DateUtil.truncatedCompareTo(o2.getUpdateTime(), o1.getUpdateTime(), Calendar.SECOND);
    });
    return cartInfoList;
}

5、功能--合并购物车

功能分析：

当用户登录以后，先判断未登录的时候，用户是否购买了商品。
- 如果用户购买了商品，则找到对应的商品Id，对数量进行合并
- 没有找到的商品,则直接添加到数据
合并完成之后，删除未登录数据。

5.1 更改实现类：CartServiceImpl

/**
 * 获取用户购物车商品列表(包含购物车合并逻辑)
 * 不合并购物车情况:
 * 1.用户未登录 直接返回未登录购物车列表
 * 2.用户从未登录变登录状态;未登录购物车数据为空 直接返回已登录购物车数据
 * <p>
 * 合并购物车情况:
 * 用户在未登录情况下添加商品到购物车(未登录购物车有数据);用户进行登录,将未登录购物车中商品跟已登录购物车中商品进行合并.合并后删除未登录购物车数据
 *
 * @param userId
 * @param userTempId
 * @return
 */
@Override
public List<CartInfo> cartList(String userId, String userTempId) {
    //1.如果临时用户ID有值,尝试查询临时用户未登录购物车列表
    List<CartInfo> noLoginCartList = null;
    if (StringUtils.isNotBlank(userTempId)) {
        BoundHashOperations<String, String, CartInfo> noLoginHashOps = redisTemplate.boundHashOps(this.getCartKey(userTempId));
        noLoginCartList = noLoginHashOps.values();
    }

    //如果用户ID为空,不需要合并直接返回未登录购物车数据即可(排序)
    if (StringUtils.isBlank(userId)) {
        noLoginCartList = noLoginCartList.stream().sorted((o1, o2) -> {
            return DateUtil.truncatedCompareTo(o2.getUpdateTime(), o1.getUpdateTime(), Calendar.SECOND);
        }).collect(Collectors.toList());
        return noLoginCartList;
    }

    //2.如果用户ID有值,并且未登录购物车不为空,需要合并
    //2.1 查询已登录购物车列表
    BoundHashOperations<String, String, CartInfo> loginHashOps = redisTemplate.boundHashOps(this.getCartKey(userId));
    List<CartInfo> loginCartList = loginHashOps.values();

    //3.合并购物车操作
    if (!CollectionUtils.isEmpty(noLoginCartList)) {
        //3.1 遍历未登录购物车列表 判断skuId 是否在 用户购物车hash结构中存在
        noLoginCartList.stream().forEach(noLoginCartInfo -> {
            CartInfo loginCartInfo = loginHashOps.get(noLoginCartInfo.getSkuId().toString());
            //3.2 存在商品数量累加
            if (loginCartInfo != null) {
                loginCartInfo.setSkuNum(loginCartInfo.getSkuNum() + noLoginCartInfo.getSkuNum());
                loginCartInfo.setUpdateTime(new Date());
                //得到未登录购物车上选中状态,合并后更新登录购物车选中状态
                if (noLoginCartInfo.getIsChecked().intValue() == 1) {
                    loginCartInfo.setIsChecked(1);
                }
                loginHashOps.put(loginCartInfo.getSkuId().toString(), loginCartInfo);
            } else {
                //3.3 不存在-新增购物车商品
                noLoginCartInfo.setUserId(userId);
                loginHashOps.put(noLoginCartInfo.getSkuId().toString(), noLoginCartInfo);
            }
        });
    }

    //3.合并后删除未登录购物车所有数据
    redisTemplate.delete(this.getCartKey(userTempId));

    //4.再次查询redis中合并后购物车列表,进行排序
    loginCartList = loginHashOps.values();
    if(!CollectionUtils.isEmpty(loginCartList)){
        loginCartList = loginCartList.stream().sorted((o1, o2)->{
            return DateUtil.truncatedCompareTo(o2.getUpdateTime(), o1.getUpdateTime(), Calendar.SECOND);
        }).collect(Collectors.toList());
    }
    return loginCartList;
}

6、选中状态的变更

用户每次勾选购物车的多选框，都要把当前状态保存起来。由于可能会涉及更频繁的操作，所以这个勾选状态不必存储到数据库中。保留在缓存状态即可。

YAPI接口地址：http://192.168.200.128:3000/project/11/interface/api/667

6.1 编写控制器

CartApiController

/**
 * 修改购物车商品选中状态
 *
 * @param skuId
 * @param isChecked
 * @return
 */
@GetMapping("/checkCart/{skuId}/{isChecked}")
public Result updateCheck(HttpServletRequest request, @PathVariable("skuId") Long skuId, @PathVariable("isChecked") int isChecked) {
    //1.获取临时用户ID  登录用户ID
    String userId = getUserId(request);
    cartService.updateCheck(userId, skuId, isChecked);
    return Result.ok();
}

/**
 * 尝试获取用户ID(登录用户ID或者临时用户ID)
 * @param request
 * @return
 */
private String getUserId(HttpServletRequest request) {
    String userId = "";
    String userTempId = AuthContextHolder.getUserTempId(request);
    if (StringUtils.isNotBlank(userTempId)) {
        userId = userTempId;
    }
    String loginUserId = AuthContextHolder.getUserId(request);
    if (StringUtils.isNotBlank(loginUserId)) {
        userId = loginUserId;
    }
    return userId;
}

6.2 编写业务接口与实现

业务接口CartService

/**
 * 修改购物车商品选中状态
 *
 * @param userId
 * @param skuId
 * @param isChecked
 * @return
 */
void updateCheck(String userId, Long skuId, int isChecked);

业务实现类CartServiceImpl

/**
 * 修改购物车商品选中状态
 *
 * @param userId
 * @param skuId
 * @param isChecked
 * @return
 */
@Override
public void updateCheck(String userId, Long skuId, int isChecked) {
    BoundHashOperations<String, String, CartInfo> hashOps = redisTemplate.boundHashOps(this.getCartKey(userId));
    Boolean exists = hashOps.hasKey(skuId.toString());
    if (exists) {
        CartInfo cartInfo = hashOps.get(skuId.toString());
        cartInfo.setIsChecked(isChecked);
        hashOps.put(skuId.toString(), cartInfo);
    }
}

7、删除购物车

YAPI接口地址：http://192.168.200.128:3000/project/11/interface/api/659

7.1 编写控制器

/**
 * 删除购物车中商品
 * @param skuId
 * @return
 */
@DeleteMapping("/deleteCart/{skuId}")
public Result deleteCart(HttpServletRequest request, @PathVariable("skuId") Long skuId){
    String userId = getUserId(request);
    cartService.deleteCart(userId, skuId);
    return Result.ok();
}

7.1 封装业务接口与实现