wangzhipeng47

分布式事务与下单

一、gulimall-cart

二、购物车

1、购物车需求

2、购物车VO

3、 ThreadLocal用户身份鉴别

3. 添加商品到购物车

4. 展示购物车

5. 选中购物车项

6. 修改购物项数量

7. 删除购物车项

三、消息队列

四、Session共享

五、订单模型

六、服务通信数据共享问题

订单登录拦截

异步线程的request数据与远程调用cookie的携带

七、订单确认页

八、接口幂等性讨论

九、订单提交

十、分布式事务

seata解决分布式事务问题

消息队列实现最终一致性

十一、支付

十二、秒杀服务

0 定时任务

1. 秒杀系统关注的问题

2. 秒杀架构设计

3. 商品上架

4. 获取当前秒杀商品

5. 获取当前商品的秒杀信息

6. 秒杀最终处理

十三、Sentinel服务流控、熔断和降级

1. 环境搭建

2、sentinel流量规则解释

3、自定义被限流响应

4、网关流控

5、 feign的流控和降级

十四、Zipkin链路追踪

1. 环境搭建

2. 查询调用链路

3. 查询依赖

版权

笔记-基础篇-1(P1-P28)：https://blog.csdn.net/hancoder/article/details/106922139
笔记-基础篇-2(P28-P100)：https://blog.csdn.net/hancoder/article/details/107612619
笔记-高级篇(P340)：https://blog.csdn.net/hancoder/article/details/107612746
笔记-vue：https://blog.csdn.net/hancoder/article/details/107007605
笔记-elastic search、上架、检索：https://blog.csdn.net/hancoder/article/details/113922398
笔记-认证服务：https://blog.csdn.net/hancoder/article/details/114242184
笔记-分布式锁与缓存：https://blog.csdn.net/hancoder/article/details/114004280
笔记-集群篇：https://blog.csdn.net/hancoder/article/details/107612802
springcloud笔记：https://blog.csdn.net/hancoder/article/details/109063671
笔记版本说明：2020年提供过笔记文档，但只有P1-P50的内容，2021年整理了P340的内容。请点击标题下面分栏查看系列笔记
声明：
- 可以白嫖，但请勿转载发布，笔记手打不易
- 本系列笔记不断迭代优化，csdn：hancoder上是最新版内容，10W字都是在csdn免费开放观看的。
- 离线md笔记文件获取方式见文末。2021-3版本的md笔记打完压缩包共500k（云图床），包括本项目笔记，还有cloud、docker、mybatis-plus、rabbitMQ等个人相关笔记
sql：https://github.com/FermHan/gulimall/sql文件
本项目其他笔记见专栏：https://blog.csdn.net/hancoder/category_10822407.html

本篇2.5W字，请直接ctrl+F搜索内容

一、gulimall-cart

构建gulimall-cart，复制静态资源到nginx，修改网关

购物车分为离线购物车和登录购物车

离线购物车重启浏览器了也还有

二、购物车

1、购物车需求

特点：读多写少，放入数据库并不合适

登录状态：登录购物车

放入数据库
mongodb
放入redis（采用）
- 登录以后，将离线购物车里合并后清空离线购物车

未登录状态：离线购物车

放入localstorage浏览器的技术
cookie
WebSQL
放入redis（采用）
- 浏览器重启后还在

2、购物车VO

(1) 数据结构分析

购物车

{
    skuid:123123,
    check:true, # 每一项是否被选中
    title:"apple ...",
    defaultImage:"",
    price:4999,
    count:1,
    totalPrice:4999, # 商品的总价=单价*数量
    skuSaleVO:{...}
}

购物车不只一条数据

[
    {sku1},{sku2},{}
]

redis有5种不同数据结构，这里选择哪一种比较合适呢？Map>

不好的方式：不同用户应该有独立的购物车，因此购物车应该以用户作为key来存储，value是用户的所有购车信息。这样看来基本的k-v结构就可以了。

但是，我们对购车中的商品进行增、删、改操作，基本都需要根据商品id讲行判断，为了方便后期处理，我们的购车也应该是k-v结构，key是商品id，value才是这个商品的购车信息。

一个购物车是由各个购物项组成的，但是我们用List进行存储并不合适，因为使用List查找某个购物项时需要挨个遍历每个购物项，会造成大量时间损耗，为保证查找速度，我们使用hash进行存储

每个人都有一个hash表，key为skuId，value为数据

(2) 购物项vo

public class CartItem {

	private Long skuId;

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

	private String title;
	private String image;

	private List skuAttr;

	/*** 价格*/
	private BigDecimal price;
	/*** 数量*/
	private Integer count;

(3) 购物车vo

public class Cart {

	private List items;

	/*** 商品的数量*/
	private Integer countNum;
	/*** 商品的类型数量*/
	private Integer countType;

	/*** 整个购物车的总价*/
	private BigDecimal totalAmount;

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

	/*** 计算商品的总量*/
	public Integer getCountNum() {
		int count = 0;
		if(this.items != null && this.items.size() > 0){
			for (CartItem item : this.items) {
				count += item.getCount();
			}
		}
		return count;
	}

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

	public BigDecimal getTotalAmount() {
		BigDecimal amount = new BigDecimal("0");
		if(this.items != null && this.items.size() > 0){
			for (CartItem item : this.items) {
				if(item.getCheck()){
					BigDecimal totalPrice = item.getTotalPrice();
					amount = amount.add(totalPrice);
				}
			}
		}
		return amount.subtract(this.getReduce());
	}

3、 ThreadLocal用户身份鉴别

(1) threadlocal说明

threadlocal的效果是其中存储的内容只有当前线程能访问的

如果想了解更多threadlocal知识可以查看：https://blog.csdn.net/hancoder/article/details/107853513

threadlocal的原理是每个线程都有一个map，key为threadlocal对象，value为对象所对应的值

参考京东，在点击购物车时，会为临时用户生成一个name为user-key的cookie临时标识，过期时间为一个月，如果手动清除user-key，那么临时购物车的购物项也被清除，所以user-key是用来标识和存储临时购物车数据的

(2) 使用ThreadLocal进行用户身份鉴别信息传递

但是注意的是tomcat中线程可以复用，所以线程和会话不是一对一的关系。但是没有关系，会在拦截器中先判断会话有没有用户信息（cookie），

首先明确每次拦截器都会重新设置threadlocal
没有的话创建一个临时用户，回去的时候告诉用户的临时cookie。threadlocal中只封装临时用户信息
有的话把临时用户和登录用户封装到一起，设置到threadlocal中

拦截器拦截会话

购物车拦截器的配置

@Configuration
public class GulimallWebConfig implements WebMvcConfigurer {
    //拦截所有请求
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new CartInterceptor()).addPathPatterns("/**");
    }
}

购物车拦截器

可以看到有句session.getAttribute(AuthServerConstant.LOGIN_USER);
看cookie中有没有临时数据，就是cookie带过来的
将用户信息放到threadlocal中让当前用户使用threadLocal.set(userInfoTo);

public class CartInterceptor implements HandlerInterceptor {

	// 静态，
	public static ThreadLocal threadLocal = new ThreadLocal<>();

	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

		// 准备好要设置到threadlocal里的user对象
		UserInfoTo userInfoTo = new UserInfoTo();
		HttpSession session = request.getSession();
		// 获取loginUser对应的用户value，没有也不去登录了。登录逻辑放到别的代码里，需要登录时再重定向
		MemberRespVo user = (MemberRespVo) session.getAttribute(AuthServerConstant.LOGIN_USER);
		if (user != null){ // 用户登陆了，设置userId
			userInfoTo.setUsername(user.getUsername());
			userInfoTo.setUserId(user.getId());
		}
		
		// 不登录也没关系，可以访问临时用户购物车
		// 去查看请求带过来的cookies里的临时购物车cookie
		Cookie[] cookies = request.getCookies();
		if(cookies != null && cookies.length > 0){
			for (Cookie cookie : cookies) {
				String name = cookie.getName();
				if(name.equals(CartConstant.TEMP_USER_COOKIE_NAME)){
					userInfoTo.setUserKey(cookie.getValue());
					userInfoTo.setTempUser(true);
				}
			}
		}
		// 如果没有临时用户 则分配一个临时用户 // 分配的临时用户在postHandle的时候放到cookie里即可
		if (StringUtils.isEmpty(userInfoTo.getUserKey())){
			String uuid = UUID.randomUUID().toString().replace("-","");
			userInfoTo.setUserKey("GULI-" + uuid);//临时用户
		}
		threadLocal.set(userInfoTo);
		return true;
		// 还有一个登录后应该删除临时购物车的逻辑没有实现
	}

	/**
	 * 执行完毕之后分配临时用户让浏览器保存
	 */
	@Override
	public void postHandle(HttpServletRequest request, 
						   HttpServletResponse response, Object handler,
						   ModelAndView modelAndView) throws Exception {

		UserInfoTo userInfoTo = threadLocal.get();
		// 如果是临时用户，返回临时购物车的cookie
		if(!userInfoTo.isTempUser()){
			Cookie cookie = new Cookie(CartConstant.TEMP_USER_COOKIE_NAME, userInfoTo.getUserKey());
			// 设置这个cookie作用域 过期时间
			cookie.setDomain("gulimall.com");
			cookie.setMaxAge(CartConstant.TEMP_USER_COOKIE_TIME_OUT);
			response.addCookie(cookie);
		}
	}
}

3. 添加商品到购物车

需要的服务：gateway、product、ware、cart、seckill、search、auth

/*** 添加商品到购物车
	 *  RedirectAttributes.addFlashAttribute():将数据放在session中，可以在页面中取出，但是只能取一次
	 *  RedirectAttributes.addAttribute():将数据拼接在url后面，?skuId=xxx
	 * */
@GetMapping("/addToCart")
public String addToCart(@RequestParam("skuId") Long skuId,
                        @RequestParam("num") Integer num,
                        RedirectAttributes redirectAttributes)  // 重定向数据， 会自动将数据添加到url后面
    throws ExecutionException, InterruptedException {

    // 添加数量到用户购物车
    cartService.addToCart(skuId, num);
    // 返回skuId告诉哪个添加成功了
    redirectAttributes.addAttribute("skuId", skuId);
    // 重定向到成功页面
    return "redirect:http://cart.gulimall.com/addToCartSuccess.html";
}

// 添加sku到购物车响应页面
@GetMapping("/addToCartSuccess.html")
public String addToCartSuccessPage(@RequestParam(value = "skuId",required = false) Object skuId, Model model){
    CartItem cartItem = null;
    // 然后在查一遍 购物车
    if(skuId == null){
        model.addAttribute("item", null);
    }else{
        try {
            cartItem = cartService.getCartItem(Long.parseLong((String)skuId));
        } catch (NumberFormatException e) {
            log.warn("恶意操作! 页面传来skuId格式错误");
        }
        model.addAttribute("item", cartItem);
    }
    return "success";
}

获取用户购物车数据

先获取redis里该用户购物车的那个map，每个用户的购物车都是个map，map名为ATGUIGU:cart:用户id

登录用户优先

private BoundHashOperations getCartOps() {
    // 1. 这里我们需要知道操作的是离线购物车还是在线购物车
    UserInfoTo userInfoTo = CartInterceptor.threadLocal.get();
  
    String cartKey = CART_PREFIX; //  "ATGUIGU:cart:";
    if(userInfoTo.getUserId() != null){
        log.debug("\n用户 [" + userInfoTo.getUsername() + "] 正在操作购物车");
        // 已登录的用户购物车的标识
        cartKey += userInfoTo.getUserId();
    }else{
        log.debug("\n临时用户 [" + userInfoTo.getUserKey() + "] 正在操作购物车");
        // 未登录的用户购物车的标识
        cartKey += userInfoTo.getUserKey();
    }
    // 绑定这个 key 以后所有对redis 的操作都是针对这个key
    return stringRedisTemplate.boundHashOps(cartKey);
}

购物车service

若购物车中已经存在该商品，只需增添数量
否则需要查询商品购物项所需信息，并添加新商品至购物车
- map的key是skuId，value是数量

@Override // CartServiceImpl
public CartItem addToCart(Long skuId, Integer num) throws ExecutionException, InterruptedException {
    // 获取当前用户的map
    BoundHashOperations cartOps = getCartOps();
    // 查看该用户购物车里是否有指定的skuId
    String res = (String) cartOps.get(skuId.toString());

    // 查看用户购物车里是否已经有了该sku项
    if(StringUtils.isEmpty(res)){
        CartItem cartItem = new CartItem();
        // 异步编排
        CompletableFuture getSkuInfo = CompletableFuture.runAsync(() -> {
            // 1. 远程查询当前要添加的商品的信息
            R skuInfo = productFeignService.SkuInfo(skuId);
            SkuInfoVo sku = skuInfo.getData("skuInfo", new TypeReference() {});
            // 2. 填充购物项
            cartItem.setCount(num);
            cartItem.setCheck(true);
            cartItem.setImage(sku.getSkuDefaultImg());
            cartItem.setPrice(sku.getPrice());
            cartItem.setTitle(sku.getSkuTitle());
            cartItem.setSkuId(skuId);
        }, executor);

        // 3. 远程查询sku销售属性，销售属性是个list
        CompletableFuture getSkuSaleAttrValues = CompletableFuture.runAsync(() -> {
            List values = productFeignService.getSkuSaleAttrValues(skuId);
            cartItem.setSkuAttr(values);
        }, executor);
        // 等待执行完成
        CompletableFuture.allOf(getSkuInfo, getSkuSaleAttrValues).get();

        // sku放到用户购物车redis中
        cartOps.put(skuId.toString(), JSON.toJSONString(cartItem));
        return cartItem;
    }else{//购物车里已经有该sku了，数量+1即可
        CartItem cartItem = JSON.parseObject(res, CartItem.class);
        // 不太可能并发，无需加锁
        cartItem.setCount(cartItem.getCount() + num);
        cartOps.put(skuId.toString(), JSON.toJSONString(cartItem));
        return cartItem;
    }
}

4. 展示购物车

若用户未登录，则直接使用user-key获取购物车数据
否则使用userId获取购物车数据，并将user-key对应临时购物车数据与用户购物车数据合并，并删除临时购物车

@RequestMapping("/cart.html")
public String getCartList(Model model) {
    CartVo cartVo=cartService.getCart();
    model.addAttribute("cart", cartVo);
    return "cartList";
}


@Override
public Cart getCart() throws ExecutionException, InterruptedException {
    UserInfoTo userInfoTo = CartInterceptor.threadLocal.get();
    Cart cart = new Cart();
    // 临时购物车的key
    String tempCartKey = CART_PREFIX + userInfoTo.getUserKey();
    // 是否登录
    if(userInfoTo.getUserId() != null){
        // 已登录 对用户的购物车进行操作
        String cartKey = CART_PREFIX + userInfoTo.getUserId();
        // 1 如果临时购物车的数据没有进行合并
        List tempItem = getCartItems(tempCartKey);
        if(tempItem != null){
            // 2 临时购物车有数据 则进行合并
            log.info("\n[" + userInfoTo.getUsername() + "] 的购物车已合并");
            for (CartItem cartItem : tempItem) {
                addToCart(cartItem.getSkuId(), cartItem.getCount());
            }
            // 3 清空临时购物车,防止重复添加
            clearCart(tempCartKey);
            // 设置为非临时用户
            userInfoTo.setTempUser(false);
        }
        // 4 获取登录后的购物车数据 [包含合并过来的临时购物车数据]
        List cartItems = getCartItems(cartKey);
        cart.setItems(cartItems);
    }else {
        // 没登录 获取临时购物车的所有购物项
        cart.setItems(getCartItems(tempCartKey));
    }
    return cart;
}

/**
	 * 获取购物车所有项
	 */
private List getCartItems(String cartKey){
    BoundHashOperations hashOps = stringRedisTemplate.boundHashOps(cartKey);
    // key不重要，拿到值即可
    List