第11章 订单

角色： 订单模块，后端开发工程师。

课程内容

1. 完成订单结算页渲染

2. 完成用户下单实现

3. 完成库存变更实现

1 订单结算页

1.1 收件地址分析

1展示 打开前台 order.html

收件地址分析 td_address表。表结构分析：

CREATE TABLE `tb_address` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) DEFAULT NULL COMMENT '用户名',
  `provinceid` varchar(20) DEFAULT NULL COMMENT '省',
  `cityid` varchar(20) DEFAULT NULL COMMENT '市',
  `areaid` varchar(20) DEFAULT NULL COMMENT '县/区',
  `phone` varchar(20) DEFAULT NULL COMMENT '电话',
  `address` varchar(200) DEFAULT NULL COMMENT '详细地址',
  `contact` varchar(50) DEFAULT NULL COMMENT '联系人',
  `is_default` varchar(1) DEFAULT NULL COMMENT '是否是默认 1默认 0否',
  `alias` varchar(50) DEFAULT NULL COMMENT '别名',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=66 DEFAULT CHARSET=utf8;

我们可以根据用户登录名去tb_address表中查询对应的数据。

1.2 实现用户收件地址查询

1.2.1 代码实现 ydles-service-user

1需改com.ydles.user.service.AddressService接口，添加根据用户名字查询用户收件地址信息，代码如下：

    //根据username 查询
    public List<Address> list(String username);

2业务层接口实现类

修改com.ydles.user.service.impl.AddressServiceImpl类，添加根据用户查询用户收件地址信息实现方法，如下代码：

    @Override
    public List<Address> list(String username) {
        Address address=new Address();
        address.setUsername(username);
        List<Address> addressList = addressMapper.select(address);
        return addressList;
    }

3控制层

修改com.ydles.user.controller.AddressController，添加根据用户名查询用户收件信息方法，代码如下：

    @Autowired
    TokenDecode tokenDecode;
    //根据username 查询 lsit<Address>
    @GetMapping("/list")
    public List<Address> list(){
        //当前登录人
        String username = tokenDecode.getUserInfo().get("username");
        List<Address> addressList = addressService.list(username);
        return addressList;
    }

4创建TokenDecode

com.ydles.UserApplication中创建TokenDecode,代码如下：

@Bean
public TokenDecode tokenDecode(){
    return  new TokenDecode();
}

测试：通过网关访问，修改网关配置信息

      routes:
        - id: ydles_goods_route
          uri: lb://goods
          predicates:
            - Path=/api/album/**,/api/brand/**,/api/cache/**,/api/categoryBrand/**,/api/category/**,/api/para/**,/api/pref/**,/api/sku/**,/api/spec/**,/api/spu/**,/api/stockBack/**,/api/template/**
          filters:
            #- PrefixPath=/brand
            - StripPrefix=1
          #用户微服务
        - id: ydles_user_route
          uri: lb://user
          predicates:
            - Path=/api/user/**,/api/address/**,/api/areas/**,/api/cities/**,/api/provinces/**
          filters:
            - StripPrefix=1
          #认证微服务
        - id: ydles_oauth_user
          uri: lb://user-auth
          predicates:
            - Path=/api/oauth/**
          filters:
            - StripPrefix=1
        #订单微服务
        - id: ydles_order_route
          uri: lb://order
          predicates:
            - Path=/api/cart/**,/api/categoryReport/**,/api/orderConfig/**,/api/order/**,/api/orderItem/**,/api/orderLog/**,/api/preferential/**,/api/returnCause/**,/api/returnOrder/**,/api/returnOrderItem/**
          filters:
            - StripPrefix=1
        #购物车订单渲染微服务
        - id: ydles_order_web_route
          uri: lb://order-web
          predicates:
            - Path=/api/wcart/**,/api/worder/**
          filters:
            - StripPrefix=1

先登录 Postman访问 http://localhost:8001/api/oauth/login

再请求数据 Postman访问 http://localhost:8001/api/address/list

1.3 页面模板渲染

购物车这块也使用的是模板渲染，用户先请求经过微服务网关，微服务网关转发到订单购物车模板渲染服务，模板渲染服务条用用户微服务和订单购物车微服务查询用户收件地址和购物车清单，然后到页面显示。

1.3.1 准备工作

(1)静态资源导入

将资料中的order.html拷贝到ydles-web-order工程的templates中。

(2)页面跳转实现

在ydles-web-order中创建com.ydles.order.controller.OrderController实现页面跳转，代码如下：

@Controller
@RequestMapping("/worder")
public class OrderController {
    @RequestMapping("/ready/order")
    public String readyOrder(Model model) {
        return "order";
    }
}

(3)网关配置

修改ydles-gateway-web的application.yml文件，将订单的路由过滤地址添加上去，代码如下：

        #购物车订单渲染微服务
        - id: ydles_order_web_route
          uri: lb://order-web
          predicates:
            - Path=/api/wcart/**,/api/worder/**
          filters:
            - StripPrefix=1

同时不要忘了把该地址添加到登录过滤地址中，修改com.ydles.filter.URLFilter，在orderFilterPath里添加/api/worder/**过滤，代码如下：

1.3.2 信息查询-重点

需求：

因为一会儿要调用ydles-service-user查询用户的收件地址信息，调用ydles-service-order查询购物车清单信息，所以我们需要创建Feign。购物车的Feign之前已经创建过了，所以只需要创建用户地址相关的即可。

(1)用户地址信息查询

在ydles-service-user-api中创建AddressFeign，代码如下：

@FeignClient(name="user")
public interface AddressFeign {
    /***
     * 查询用户的收件地址信息
     * @return
     */
    @GetMapping(value = "/list")
    public Result<List<Address>> list();
}

(2) ydles_web_order项目启动类OrderWebApplication加入调用的feign包

        <dependency>
            <groupId>com.ydles</groupId>
            <artifactId>ydles_service_user_api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients(basePackages = {"com.ydles.order.feign","com.ydles.user.feign"})
public class OrderWebApplication {

(3)查询购物车和用户收件地址信息

修改ydles-web-order中的com.ydles.order.controller.OrderController的readyOrder方法，在该方法中，使用feign调用查询收件地址信息和用户购物车信息，代码如下：

@Controller
@RequestMapping("/worder")
public class OrderController {
    @Autowired
    private AddressFeign addressFeign;
    @Autowired
    private CartFeign cartFeign;
    @RequestMapping("/ready/order")
    public String readyOrder(Model model) {
         //1收件人的地址信息
        List<Address> addressList = addressFeign.list().getData();
        model.addAttribute("address",addressList);
        //2购物车信息
        Map map = cartFeign.list();
        List<OrderItem> orderItemList = (List<OrderItem>) map.get("orderItemList");
        Integer totalMoney = (Integer) map.get("totalMoney");
        Integer totalNum = (Integer) map.get("totalNum");
        model.addAttribute("carts",orderItemList);
        model.addAttribute("totalMoney",totalMoney);
        model.addAttribute("totalNum",totalNum);
        return "order";
    }
}

(3)数据回显-了解

修改order.html，与静态原型中的order.html打开对比。

2 <html xmlns:th="http://www.thymeleaf.org">

82 <div class="cart py-container" id="app">

97
<div class="choose-address" th:each="addr:${address}">
                                    <div class="con name " th:@click="|chooseAddr('${addr.contact}','${addr.phone}','${addr.address}')|" th:classappend="${addr.isDefault}==1?'selected':''"><a href="javascript:;" ><em th:text="${addr.contact}"></em> <span title="点击取消选择"></span></a></div>
                                    <div class="con address">
                                        <span class="place"><em th:text="${addr.address}"></em> </span>
                                        <span class="phone"><em th:text="${addr.phone}"></em> </span>
                                        <span class="base" th:if="${addr.isDefault}==1">默认地址</span>
                                    </div>
                                    <div class="clearfix"></div>
                                </div>

118
<ul class="payType">
                            <li class="selected" th:@click="|order.payType=1|">在线支付<span title="点击取消选择"></span></li>
                            <li th:@click="|order.payType=0|">货到付款<span title="点击取消选择"></span></li>
                        </ul>

141
<ul class="yui3-g" th:each="cart,cartsList:${carts}">
                                        <li class="yui3-u-1-9">
                                            <span><img th:src="${cart.image}"/></span>
                                        </li>
                                        <li class="yui3-u-5-12">
                                            <div class="desc" th:text="${cart.name}"></div>
                                            <div class="seven">7天无理由退货</div>
                                        </li>
                                        <li class="yui3-u-1-12">
                                            <div class="price" th:text="${cart.price}"></div>
                                        </li>
                                        <li class="yui3-u-1-12">
                                            <div class="num" th:text="${cart.num}"></div>
                                        </li>
                                        <li class="yui3-u-1-12">
                                            <div class="num" th:text="${cart.num}*${cart.price}"></div>
                                        </li>
                                        <li class="yui3-u-1-12">
                                            <div class="exit">有货</div>
                                        </li>
                                    </ul>

193
<div class="fc-receiverInfo">
            寄送至:
            <span id="receive-address">{{order.receiveAddress}}</span>
            收货人：<span id="receive-name">{{order.receiveContact}}</span>
            <span id="receive-phone">{{order.receiveMobile}}</span>
        </div>

201
<div class="list">
                    <span><i class="number"><em th:text="${totalNum}"></em></i>件商品，商品总金额</span>
                    <em class="allprice">¥<em th:text="${totalMoney}"></em></em>
                </div>

211
<div class="clearfix trade">
            <div class="fc-price">应付金额:　<span class="final-price">¥<em th:text="${totalMoney}"></em></span></div>
        </div>

318
<script th:inline="javascript">
        var app = new Vue({
            el:"#app",
            data:{
                order:{
                    'receiveContact': [[${deAddr.contact}]],
                    'receiveMobile': [[${deAddr.phone}]],
                    'receiveAddress': [[${deAddr.address}]],
                    'payType':1
                }
            },
            methods:{
                chooseAddr: function (contact,mobile,address){
                    app.$set(app.order,'receiveContact',contact);
                    app.$set(app.order,'receiveMobile',mobile);
                    app.$set(app.order,'receiveAddress',address);
                }
            }
        })
    </script>

测试：先登录，再访问

http://localhost:8001/api/worder/ready/order

1.3.3 记录选中收件人-了解

收件人动态展示

73 <div class="cart py-container" id="app">

371-395
<script th:inline="javascript">
    var app = new Vue({
        el:"#app",
        data:{
            order:{'receiveContact':[[${deAddr.contact}]],'receiveMobile':[[${deAddr.phone}]],'receiveAddress':[[${deAddr.address}]],'payType':1}
        },
        methods:{
            chooseAddr:function (contact,mobile,address) {
                app.$set(app.order,'receiveContact',contact);
                app.$set(app.order,'receiveMobile',mobile);
                app.$set(app.order,'receiveAddress',address);
            },
            add:function () {
                axios.post('/api/worder/add',this.order).then(function (response) {
                    if (response.data.flag){
                        //添加订单成功
                        alert("添加订单成功");
                    } else{
                        alert("添加订单失败");
                    }
                })
            }
        }
    })
</script>

199-207
<div class="clearfix trade">
            <div class="fc-price">应付金额:　<span class="price">¥<em th:text="${totalMoney}"></em></span></div>
            <div class="fc-receiverInfo">
                寄送至:
                <span id="receive-address">{{order.receiveAddress}}</span>
                收货人：<span id="receive-name">{{order.receiveContact}}</span>
                <span id="receive-phone">{{order.receiveMobile}}</span>
            </div>
        </div>

后端设置默认收件人

        //默认收件人信息
        for (Address address : addressList) {
            if ("1".equals(address.getIsDefault())){
                //默认收件人
                model.addAttribute("deAddr",address);
                break;
            }
        }

前端：

375
order:{'receiveContact':[[${deAddr.contact}]],'receiveMobile':[[${deAddr.phone}]],'receiveAddress':[[${deAddr.address}]],'payType':1}

支付方式

109-114
<div class="step-cont">
                        <ul class="payType">
                            <li class="selected" th:@click="|order.payType=1|">在线支付<span title="点击取消选择"></span></li>
                            <li th:@click="|order.payType=0|">货到付款<span title="点击取消选择"></span></li>
                        </ul>
                    </div>

购物车跳转结算页面

cart.html

<a class="sum-btn" href="/api/worder/ready/order" target="_blank">结算</a>

2 下单-重点

2.1 业务分析

点击提交订单的时候，会立即创建订单数据，创建订单数据会将数据存入到2张表中，分别是订单表和订单明细表，此处还需要修改商品对应的库存数量。

订单表结构如下：

CREATE TABLE `tb_order` (
  `id` varchar(50) COLLATE utf8_bin NOT NULL COMMENT '订单id',
  `total_num` int(11) DEFAULT NULL COMMENT '数量合计',
  `total_money` int(11) DEFAULT NULL COMMENT '金额合计',
  `pre_money` int(11) DEFAULT NULL COMMENT '优惠金额',
  `post_fee` int(11) DEFAULT NULL COMMENT '邮费',
  `pay_money` int(11) DEFAULT NULL COMMENT '实付金额',
  `pay_type` varchar(1) COLLATE utf8_bin DEFAULT NULL COMMENT '支付类型，1、在线支付、0 货到付款',
  `create_time` datetime DEFAULT NULL COMMENT '订单创建时间',
  `update_time` datetime DEFAULT NULL COMMENT '订单更新时间',
  `pay_time` datetime DEFAULT NULL COMMENT '付款时间',
  `consign_time` datetime DEFAULT NULL COMMENT '发货时间',
  `end_time` datetime DEFAULT NULL COMMENT '交易完成时间',
  `close_time` datetime DEFAULT NULL COMMENT '交易关闭时间',
  `shipping_name` varchar(20) COLLATE utf8_bin DEFAULT NULL COMMENT '物流名称',
  `shipping_code` varchar(20) COLLATE utf8_bin DEFAULT NULL COMMENT '物流单号',
  `username` varchar(50) COLLATE utf8_bin DEFAULT NULL COMMENT '用户名称',
  `buyer_message` varchar(1000) COLLATE utf8_bin DEFAULT NULL COMMENT '买家留言',
  `buyer_rate` char(1) COLLATE utf8_bin DEFAULT NULL COMMENT '是否评价',
  `receiver_contact` varchar(50) COLLATE utf8_bin DEFAULT NULL COMMENT '收货人',
  `receiver_mobile` varchar(12) COLLATE utf8_bin DEFAULT NULL COMMENT '收货人手机',
  `receiver_address` varchar(200) COLLATE utf8_bin DEFAULT NULL COMMENT '收货人地址',
  `source_type` char(1) COLLATE utf8_bin DEFAULT NULL COMMENT '订单来源：1:web，2：app，3：微信公众号，4：微信小程序  5 H5手机页面',
  `transaction_id` varchar(30) COLLATE utf8_bin DEFAULT NULL COMMENT '交易流水号',
  `order_status` char(1) COLLATE utf8_bin DEFAULT NULL COMMENT '订单状态,0:未完成,1:已完成，2：已退货',
  `pay_status` char(1) COLLATE utf8_bin DEFAULT NULL COMMENT '支付状态,0:未支付，1：已支付，2：支付失败',
  `consign_status` char(1) COLLATE utf8_bin DEFAULT NULL COMMENT '发货状态,0:未发货，1：已发货，2：已收货',
  `is_delete` char(1) COLLATE utf8_bin DEFAULT NULL COMMENT '是否删除',
  PRIMARY KEY (`id`),
  KEY `create_time` (`create_time`),
  KEY `status` (`order_status`),
  KEY `payment_type` (`pay_type`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

订单明细表结构如下：

CREATE TABLE `tb_order_item` (
  `id` varchar(50) COLLATE utf8_bin NOT NULL COMMENT 'ID',
  `category_id1` int(11) DEFAULT NULL COMMENT '1级分类',
  `category_id2` int(11) DEFAULT NULL COMMENT '2级分类',
  `category_id3` int(11) DEFAULT NULL COMMENT '3级分类',
  `spu_id` varchar(20) COLLATE utf8_bin DEFAULT NULL COMMENT 'SPU_ID',
  `sku_id` bigint(20) NOT NULL COMMENT 'SKU_ID',
  `order_id` bigint(20) NOT NULL COMMENT '订单ID',
  `name` varchar(200) COLLATE utf8_bin DEFAULT NULL COMMENT '商品名称',
  `price` int(20) DEFAULT NULL COMMENT '单价',
  `num` int(10) DEFAULT NULL COMMENT '数量',
  `money` int(20) DEFAULT NULL COMMENT '总金额',
  `pay_money` int(11) DEFAULT NULL COMMENT '实付金额',
  `image` varchar(200) COLLATE utf8_bin DEFAULT NULL COMMENT '图片地址',
  `weight` int(11) DEFAULT NULL COMMENT '重量',
  `post_fee` int(11) DEFAULT NULL COMMENT '运费',
  `is_return` char(1) COLLATE utf8_bin DEFAULT NULL COMMENT '是否退货,0:未退货，1：已退货',
  PRIMARY KEY (`id`),
  KEY `item_id` (`sku_id`),
  KEY `order_id` (`order_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

2.2 下单实现

下单的时候，先往tb_order表中增加数据，再往tb_order_item表中增加数据。

2.2.1 代码实现

这里先修改ydles-service-order微服务，实现下单操作，这里会生成订单号，我们首先需要在启动类中创建一个IdWorker对象。

在com.ydles.OrderApplication中创建IdWorker，代码如下：

    @Bean
    public IdWorker idWorker() {
        return new IdWorker(workerId, datacenterId);
    }

(1)业务层

实现逻辑：

1）获取所有购物车

2）统计计算：总金额，总支付金额，总数量

3）填充订单数据并保存

4）获取每一个购物项保存到orderItem

5）删除购物车中数据

修改订单微服务添加com.ydles.order.service.impl.OrderServiceImpl,代码如下：

/**
     * 下单
     * @param order
     * 缺啥补啥
     */
    @Override
    public boolean add(Order order){
        //1 获取 购物车信息
        Map cartMap = cartService.list(order.getUsername());
        //map.put("orderItemList",orderItemList);
        Integer totalNum = (Integer) cartMap.get("totalNum");
        Integer totalMoney = (Integer) cartMap.get("totalMoney");
        //2 order表里存数据
        String orderId = idWorker.nextId()+"";
        order.setId(orderId);
        order.setTotalNum(totalNum);
        order.setTotalMoney(totalMoney);
        //作业：优惠金额 怎么算      本店满50-5 跨店 300-50
        //作业：邮费金额 怎么算
        order.setPayMoney(totalMoney);
        order.setCreateTime(new Date());
        order.setUpdateTime(new Date());
        //作业：买家留言
        order.setBuyerRate("0");
        order.setSourceType("1");
        order.setOrderStatus("0");
        order.setPayStatus("0");
        order.setConsignStatus("0");
        order.setIsDelete("0");
        orderMapper.insertSelective(order);
        //3 orderItem表里存数据
        List<OrderItem> orderItemList = (List<OrderItem>) cartMap.get("orderItemList");
        for (OrderItem orderItem : orderItemList) {
            orderItem.setOrderId(orderId);
            orderItem.setPostFee(0);
            orderItem.setIsReturn("0");
            orderItemMapper.insertSelective(orderItem);
        }
        //4 删除购物车信息
        stringRedisTemplate.delete(CART+order.getUsername());
        return true;
    }

(2)控制层

修改ydles-service-order微服务，修改com.ydles.order.controller.OrderController类，代码如下：

    @Autowired
    TokenDecode tokenDecode;
    /***
     * 下单
     * @param order
     * @return
     */
    @PostMapping
    public Result add(@RequestBody Order order){
        String username = tokenDecode.getUserInfo().get("username");
        order.setUsername(username);
        orderService.add(order);
        return new Result(true,StatusCode.OK,"添加成功");
    }

2.2.2 渲染服务对接

我们需要在模板渲染端调用订单微服务实现下单操作,下单操作需要调用订单微服务，所以需要创建对应的Feign。

(1)Feign创建

修改ydles-service-order-api，添加OrderFeign，代码如下：

@FeignClient(name = "order")
public interface OrderFeign {
    @PostMapping("/order")
    public Result add(@RequestBody Order order);
}

(2)下单调用

修改ydles-web-order的com.ydles.order.controller.OrderController添加下单方法，代码如下：

    @Autowired
    private OrderFeign orderFeign;
    @PostMapping("/add")
    @ResponseBody
    public Result add(@RequestBody Order order){
        Result result = orderFeign.add(order);
        return result;
    }

(3)页面调用

order.html

383-392
add:function () {
                axios.post('/api/worder/add',this.order).then(function (response) {
                    if (response.data.flag){
                        //添加订单成功
                        alert("添加订单成功");
                    } else{
                        alert("添加订单失败");
                    }
                })
            }

209
<a class="sui-btn btn-danger btn-xlarge" href="javascript:void(0)" @click="add()">提交订单</a>

点击提交订单调用

保存订单测试，表数据变化如下：

tb_order表数据：

tb_order_item表数据：

2.3 库存变更

2.3.1 业务分析

上面操作只实现了下单操作，但对应的库存还没跟着一起减少，我们在下单之后，应该调用商品微服务，将下单的商品库存减少，销量增加。每次订单微服务只需要将用户名传到商品微服务，商品微服务通过用户名到Redis中查询对应的购物车数据，然后执行库存减少，库存减少需要控制当前商品库存>=销售数量。

如何控制库存数量>=购买数量呢？其实可以通过SQL语句实现，每次减少数量之前，加个条件判断。

where num>=#{num}即可。

商品服务需要查询购物车数据，所以需要引入订单的api，在pom.xml中添加如下依赖：

<!--order api 依赖-->
<dependency>
    <groupId>com.ydles</groupId>
    <artifactId>ydles_service_order_api</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

2.3.2 代码实现

要调用其他微服务，需要将头文件中的令牌数据携带到其他微服务中取，所以我们不能使用hystrix的多线程模式，修改ydles-service-order的applicatin.yml配置，代码如下：

#hystrix 配置
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 10000
          strategy: SEMAPHORE

每次还需要使用拦截器添加头文件信息，添加拦截器，代码如下：

(1)Dao层

修改ydles-service-goods微服务的com.ydles.goods.dao.SkuMapper接口，增加库存递减方法,代码如下：

/**
 * 递减库存
 * @param orderItem
 * @return
 */
@Update("UPDATE tb_sku SET num=num-#{num},sale_num=sale_num+#{num} WHERE id=#{skuId} AND num>=#{num}")
int decrCount(OrderItem orderItem);

(2)业务层

修改ydles-service-goods微服务的com.ydles.goods.service.SkuService接口，添加如下方法：

/***
 * 库存递减
 * @param username
 */
void decrCount(String username);

修改ydles-service-goods微服务的com.ydles.goods.service.impl.SkuServiceImpl实现类，添加一个实现方法，代码如下：

@Autowired
private RedisTemplate redisTemplate;
/***
 * 库存递减
 * @param username
 */
@Override
public void decrCount(String username) {
    //获取购物车数据
    List<OrderItem> orderItems = redisTemplate.boundHashOps("Cart_" + username).values();
    //循环递减
    for (OrderItem orderItem : orderItems) {
        //递减库存
        int count = skuMapper.decrCount(orderItem);
        if(count<=0){
            throw new RuntimeException("库存不足，递减失败！");
        }
    }
}

(3)控制层

修改ydles-service-goods的com.ydles.goods.controller.SkuController类，添加库存递减方法，代码如下：

/***
 * 库存递减
 * @param username
 * @return
 */
@PostMapping(value = "/decr/count")
public Result decrCount(@RequestParam("username") String username){
    //库存递减
    skuService.decrCount(username);
    return new Result(true,StatusCode.OK,"库存递减成功！");
}

(4)创建feign

同时在ydles-service-goods-api工程添加com.ydles.goods.feign.SkuFeign的实现，代码如下：

/***
 * 库存递减
 * @param username
 * @return
 */
@PostMapping(value = "/decr/count")
Result decrCount(@RequestParam(value = "username") String username);

2.3.3 调用库存递减

需求：

ydles_service_order服务调用 ydles_service_goods服务, ydles_web_order服务的Application启动类

都需要添加下面拦截器

@Bean
public FeignInterceptor feignInterceptor(){
    return new FeignInterceptor();
}

ydles_service_goods加入配置信息

spring:
  application:
    name: goods
  redis:
    host: 192.168.200.128

调用库存递减

修改ydles-service-order微服务的com.ydles.order.service.impl.OrderServiceImpl类的add方法，增加库存递减的调用。

先注入SkuFeign

@Autowired
private SkuFeign skuFeign;

再调用库存递减方法

//库存减库存
skuFeign.decrCount(order.getUsername());

完整代码如下：

/**
 * 增加
 * @param order
 */
@Override
public Boolean add(Order order){
    //查询出用户的所有购物车
    Map orderItemMap = cartService.list(order.getUsername());
    //统计计算
    Integer totalMoney = Integer.parseInt(String.valueOf(orderItemMap.get("totalPrice")));
    Integer num = Integer.parseInt(String.valueOf(orderItemMap.get("totalNum")));
    //购买商品数量
    order.setTotalNum(num);
    //购买金额
    order.setTotalMoney(totalMoney);
    //支付金额
    order.setPayMoney(totalMoney);
    //优惠金额
    order.setPreMoney(totalMoney);
    //其他数据完善
    order.setCreateTime(new Date());
    order.setUpdateTime(order.getCreateTime());
    order.setBuyerRate("0");        //0:未评价，1：已评价
    order.setSourceType("1");       //来源，1：WEB
    order.setOrderStatus("0");      //0:未完成,1:已完成，2：已退货
    order.setPayStatus("0");        //0:未支付，1：已支付，2：支付失败
    order.setConsignStatus("0");    //0:未发货，1：已发货，2：已收货
    order.setId(idWorker.nextId());
    int count = orderMapper.insertSelective(order);
    //保存待支付订单到redis中
    redisTemplate.boundValueOps(Constants.ORDER_PAY + order.getUsername()).set(order);
    //添加订单明细
    List<OrderItem> orderItemList = (List<OrderItem>)orderItemMap.get("orderItemList");
    for (OrderItem orderItem : orderItemList) {
        orderItem.setId(idWorker.nextId());
        orderItem.setIsReturn("0");
        orderItem.setOrderId(order.getId());
        orderItemMapper.insertSelective(orderItem);
    }
    //扣减库存
    skuFeign.decrCount(order.getUsername());
    //清除Redis缓存购物车数据
    redisTemplate.delete("Cart_"+order.getUsername());
    return true;
}

测试

1购物车添加商品

http://localhost:8001/api/wcart/add?skuId=1450862568724758528&num=5

2查看购物车

http://localhost:8001/api/wcart/list

3点击结算

4点击提交订单

tb_order 有数据

tb_order_item也有数据

tb_sku表查看库存和销量是否更改

库存减少前，查询数据库Sku数据如下：95库存，5销量 库存94，销量6

2.4 增加积分(学员练习)

tb_user表

`points` int(11) DEFAULT NULL COMMENT '积分',

需求：

在增加订单的时候，同时添加用户积分。与减库存道理相同。

(1)dao层

修改ydles-service-user微服务的com.ydles.user.dao.UserMapper接口，增加用户积分方法，代码如下：

/***
 * 增加用户积分
 * @param username
 * @param pint
 * @return
 */
@Update("UPDATE tb_user SET points=points+#{point} WHERE  username=#{username}")
int addUserPoints(@Param("username") String username, @Param("point") Integer pint);

(2)业务层

修改ydles-service-user微服务的com.ydles.user.service.UserService接口，代码如下：

/***
 * 添加用户积分
 * @param username
 * @param pint
 * @return
 */
int addUserPoints(String username,Integer pint);

修改ydles-service-user微服务的com.ydles.user.service.impl.UserServiceImpl，增加添加积分方法实现，代码如下：

/***
 * 修改用户积分
 * @param username
 * @param pint
 * @return
 */
@Override
public int addUserPoints(String username, Integer pint) {
    return userMapper.addUserPoints(username,pint);
}

(3)控制层

修改ydles-service-user微服务的com.ydles.user.controller.UserController，添加增加用户积分方法，代码如下：

@Autowired
private TokenDecode tokenDecode;
/***
 * 增加用户积分
 * @param points:要添加的积分
 */
@GetMapping(value = "/points/add")
public Result addPoints(Integer points){
    //获取用户名
    Map<String, String> userMap = tokenDecode.getUserInfo();
    String username = userMap.get("username");
    //添加积分
    userService.addUserPoints(username,points);
    return new Result(true,StatusCode.OK,"添加积分成功！");
}

(4)Feign添加

修改ydles-service-user-api工程，修改com.ydles.user.feign.UserFeign，添加增加用户积分方法，代码如下：

/***
 * 添加用户积分
 * @param points
 * @return
 */
@GetMapping(value = "/points/add")
Result addPoints(@RequestParam(value = "points")Integer points);

4.4.2 增加积分调用

修改ydles-service-order，添加ydles-service-user-api的依赖，修改pom.xml,添加如下依赖：

<!--user api 依赖-->
<dependency>
    <groupId>com.ydles</groupId>
    <artifactId>ydles-service-user-api</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

在加订单的时候，同时添加用户积分，修改ydles-service-order微服务的com.ydles.order.service.impl.OrderServiceImpl下单方法，增加调用添加积分方法

修改ydles-service-order的启动类com.ydles.OrderApplication，添加feign的包路径

总结：

1订单结算页

2下单

第12章 分布式事务解决方案

角色：架构师

学习目标：

• 能够说出cap定理
• 能够说出BASE定理
• 能够说出常见的分布式事务解决方案
• 能够说出seata框架如何在项目中实现分布式事务

1.分布式事务解决方案

 刚才我们编写的扣减库存与保存订单是在两个服务中存在的，如果扣减库存后订单保存失败了是不会回滚的，这样就会造成数据不一致的情况，这其实就是我们所说的分布式事务的问题，接下来我们来学习分布式事务的解决方案。

1.1 本地事务与分布式事务

1.1.1 事务

数据库事务(简称：事务，Transaction)是指数据库执行过程中的一个逻辑单位，由一个有限的数据库操作序列构成。

事务拥有以下四个特性，习惯上被称为ACID特性：

原子性(Atomicity)：事务作为一个整体被执行，包含在其中的对数据库的操作要么全部被执行，要么都不执行。

一致性(Consistency)：事务应确保数据库的状态从一个一致状态转变为另一个一致状态。一致状态是指数据库中的数据应满足完整性约束。除此之外，一致性还有另外一层语义，就是事务的中间状态不能被观察到(这层语义也有说应该属于原子性)。

隔离性(Isolation)：多个事务并发执行时，一个事务的执行不应影响其他事务的执行，如同只有这一个操作在被数据库所执行一样。

持久性(Durability)：已被提交的事务对数据库的修改应该永久保存在数据库中。在事务结束时，此操作将不可逆转。

作业：隔离级别 传播机制

1.1.2 本地事务

起初，事务仅限于对单一数据库资源的访问控制,架构服务化以后，事务的概念延伸到了服务中。倘若将一个单一的服务操作作为一个事务，那么整个服务操作只能涉及一个单一的数据库资源,这类基于单个服务单一数据库资源访问的事务，被称为本地事务(Local Transaction)。

解决方案：@Transactional

1.1.3 分布式事务

    分布式事务指事务的参与者、支持事务的服务器、资源服务器以及事务管理器分别位于不同的分布式系统的不同节点之上,且属于不同的应用，分布式事务需要保证这些操作要么全部成功，要么全部失败。本质上来说，分布式事务就是为了保证不同数据库的数据一致性。
   最早的分布式事务应用架构很简单，不涉及服务间的访问调用，仅仅是服务内操作涉及到对多个数据库资源的访问。

    当一个服务操作访问不同的数据库资源，又希望对它们的访问具有事务特性时，就需要采用分布式事务来协调所有的事务参与者。
    对于上面介绍的分布式事务应用架构，尽管一个服务操作会访问多个数据库资源，但是毕竟整个事务还是控制在单一服务的内部。如果一个服务操作需要调用另外一个服务，这时的事务就需要跨越多个服务了。在这种情况下，起始于某个服务的事务在调用另外一个服务的时候，需要以某种机制流转到另外一个服务，从而使被调用的服务访问的资源也自动加入到该事务当中来。下图反映了这样一个跨越多个服务的分布式事务：

    如果将上面这两种场景(一个服务可以调用多个数据库资源，也可以调用其他服务)结合在一起，对此进行延伸，整个分布式事务的参与者将会组成如下图所示的树形拓扑结构。在一个跨服务的分布式事务中，事务的发起者和提交均系同一个，它可以是整个调用的客户端，也可以是客户端最先调用的那个服务。

     较之基于单一数据库资源访问的本地事务，分布式事务的应用架构更为复杂。在不同的分布式应用架构下，实现一个分布式事务要考虑的问题并不完全一样，比如对多资源的协调、事务的跨服务传播等，实现机制也是复杂多变。

只要是涉及到多个微服务之间远程调用的话，那就回涉及到分布式事务。

分布式事务的作用：

保证每个事务的数据一致性。

1.2 分布式事务相关理论

1.2.1 CAP定理-重点

CAP定理是在 1998年加州大学的计算机科学家 Eric Brewer （埃里克.布鲁尔）提出，分布式系统有三个指标

• Consistency 强一致性
• Availability 可用性
• Partition tolerance 分区容错

它们的第一个字母分别是 C、A、P。Eric Brewer 说，这三个指标不可能同时做到。这个结论就叫做 CAP 定理。

因为：强一致性和可用性 互斥！

真实情况：

1 ac 传统项目。ssm管理系统，一个程序，一个数据库。

2 cp 信息重要的场景。手机银行转账。转圈圈，在做数据同步，这段时间内，可用性是没有的。

3 ap 互联网。 放弃强一致性，慢慢数据同步。

分区容错 Partition tolerance

**理解:  分布式系统集群中, 一个机器坏掉不应该影响其他机器**

大多数分布式系统都分布在多个子网络。每个子网络就叫做一个区（partition）。分区容错的意思是，区间通信可能失败。比如，一台服务器放在中国，另一台服务器放在美国，这就是两个区，它们之间可能无法通信。

上图中，G1 和 G2 是两台跨区的服务器。G1 向 G2 发送一条消息，G2 可能无法收到。系统设计的时候，必须考虑到这种情况。

一般来说，分区容错无法避免，因此可以认为 CAP 的 P 总是成立。CAP 定理告诉我们，剩下的 C 和 A 无法同时做到。

可用性 Availability

**理解:  一个请求, 必须返回一个响应**

Availability 中文叫做”可用性”，意思是只要收到用户的请求，服务器就必须给出回应。

用户可以选择向 G1 或 G2 发起读操作。不管是哪台服务器，只要收到请求，就必须告诉用户，到底是 v0 还是 v1，否则就不满足可用性。

一致性 Consistency

理解: 一定能读取到最新的数据

Consistency 中文叫做”一致性”。意思是，写操作之后的读操作，必须返回该值。

举例来说，某条记录是 v0，用户向 G1 发起一个写操作，将其改为 v1。

问题是，用户有可能向 G2 发起读操作，由于 G2 的值没有发生变化，因此返回的是 v0。G1 和 G2 读操作的结果不一致，这就不满足一致性了。

为了让 G2 也能变为 v1，就要在 G1 写操作的时候，让 G1 向 G2 发送一条消息，要求 G2 也改成 v1。

一致性和可用性的矛盾

一致性(C)和可用性(A)，为什么不可能同时成立？答案很简单，因为可能通信失败（即出现分区容错）。

如果保证 G2 的一致性，那么 G1 必须在写操作时，锁定 G2 的读操作和写操作。只有数据同步后，才能重新开放读写。锁定期间，G2 不能读写，没有可用性(CP)。

如果保证 G2 的可用性，那么势必不能锁定 G2，所以一致性不成立(AP)。

综上所述，G2 无法同时做到一致性和可用性。系统设计时只能选择一个目标。如果追求一致性，那么无法保证所有节点的可用性；如果追求所有节点的可用性，那就没法做到一致性。

1.2.2 BASE理论

BASE：全称：Basically Available(基本可用)，Soft state（软状态）,和 Eventually consistent（最终一致性）三个短语的缩写，来自 ebay 的架构师提出。BASE 理论是对 CAP 中一致性和可用性权衡的结果，其来源于对大型互联网分布式实践的总结，是基于 CAP 定理逐步演化而来的。其核心思想是：

既是无法做到强一致性（Strong consistency），但每个应用都可以根据自身的业务特点，采用适当的方式来使系统达到最终一致性（Eventual consistency）。

Basically Available(基本可用)

理解: 允许服务降级或者允许响应时间受到一定损失

什么是基本可用呢？假设系统，出现了不可预知的故障，但还是能用，相比较正常的系统而言：

1. 响应时间上的损失：正常情况下的搜索引擎 0.5 秒即返回给用户结果，而基本可用的搜索引擎可以在 1 秒作用返回结果。
2. 功能上的损失：在一个电商网站上，正常情况下，用户可以顺利完成每一笔订单，但是到了大促期间，为了保护购物系统的稳定性，部分消费者可能会被引导到一个降级页面。

Soft state（软状态）

理解: 允许同步数据的时候出现一定时间延迟

什么是软状态呢？相对于原子性而言，要求多个节点的数据副本都是一致的，这是一种 “硬状态”。

软状态指的是：允许系统中的数据存在中间状态，并认为该状态不影响系统的整体可用性，即允许系统在多个不同节点的数据副本存在数据延时。

Eventually consistent（最终一致性）

理解: 经过一段时间的同步数据之后，最终都能够达到一个一致的状态

系统能够保证在没有其他新的更新操作的情况下，数据最终一定能够达到一致的状态，因此所有客户端对系统的数据访问最终都能够获取到最新的值。

1.3 分布式事务解决方案-面试

1.XA两段提交(低效率)-2PC

2.TCC三段提交(3段,高效率[不推荐(补偿代码)])

3.本地消息表(MQ+Table)

4.事务消息(RocketMQ[alibaba])

5.Seata(alibaba)

6.RabbitMQ的ACK机制实现分布式事务(作业)

1.3.1 基于XA协议的两阶段提交 2pc

首先我们来简要看下分布式事务处理的XA规范 ：

可知XA规范中分布式事务有AP，RM，TM组成：

其中应用程序(Application Program ，简称AP)：AP定义事务边界（定义事务开始和结束）并访问事务边界内的资源。

资源管理器(Resource Manager，简称RM)：Rm管理计算机共享的资源，许多软件都可以去访问这些资源，资源包含比如数据库、文件系统、打印机服务器等。

事务管理器(Transaction Manager ，简称TM)：负责管理全局事务，分配事务唯一标识，监控事务的执行进度，并负责事务的提交、回滚、失败恢复等。

二阶段协议:

第一阶段TM要求所有的RM准备提交对应的事务分支，询问RM是否有能力保证成功的提交事务分支，RM根据自己的情况，如果判断自己进行的工作可以被提交，那就对工作内容进行持久化，并给TM回执OK；否者给TM的回执NO。RM在发送了否定答复并回滚了已经的工作后，就可以丢弃这个事务分支信息了。

第二阶段TM根据阶段1各个RM prepare的结果，决定是提交还是回滚事务。如果所有的RM都prepare成功，那么TM通知所有的RM进行提交；如果有RM prepare回执NO的话，则TM通知所有RM回滚自己的事务分支。

也就是TM与RM之间是通过两阶段提交协议进行交互的.

优点： 尽量保证了数据的强一致，适合对数据强一致要求很高的关键领域。（其实也不能100%保证强一致）

缺点： 实现复杂，牺牲了可用性，对性能影响较大，不适合高并发高性能场景。

流程看我的图：

                                                                               mysql

悲观锁 mysql行级锁 oracle表级锁

两阶段提交协议(Two Phase Commitment Protocol)中，涉及到两种角色

一个事务协调者（coordinator）：负责协调多个参与者进行事务投票及提交(回滚)
多个事务参与者（participants）：即本地事务执行者

总共处理步骤有两个
（1）投票阶段（voting phase）：协调者将通知事务参与者准备提交或取消事务，然后进入表决过程。参与者将告知协调者自己的决策：同意（事务参与者本地事务执行成功，但未提交）或取消（本地事务执行故障）；
（2）提交阶段（commit phase）：收到参与者的通知后，协调者再向参与者发出通知，根据反馈情况决定各参与者是否要提交还是回滚；

1.3.2 TCC补偿机制

TCC 其实就是采用的补偿机制，其核心思想是：针对每个操作，都要注册一个与其对应的确认和补偿（撤销）操作。它分为三个阶段：

• Try 阶段主要是对业务系统做检测及资源预留
• Confirm 阶段主要是对业务系统做确认提交，Try阶段执行成功并开始执行 Confirm阶段时，默认 Confirm阶段是不会出错的。即：只要Try成功，Confirm一定成功。
• Cancel 阶段主要是在业务执行错误，需要回滚的状态下执行的业务取消，预留资源释放。

例如： A要向 B 转账，思路大概是：

我们有一个本地方法，里面依次调用 
1、首先在 Try 阶段，要先调用远程接口把 B和 A的钱给冻结起来。 
2、在 Confirm 阶段，执行远程调用的转账的操作，转账成功进行解冻。 
3、如果第2步执行成功，那么转账成功，如果第二步执行失败，则调用远程冻结接口对应的解冻方法 (Cancel)。

优点： 相比两阶段提交，可用性比较强

缺点： 数据的一致性要差一些。TCC属于应用层的一种补偿方式，所以需要程序员在实现的时候多写很多补偿的代码，在一些场景中，一些业务流程可能用TCC不太好定义及处理。

流程看我的图：

1.3.3 消息最终一致性-重点

消息最终一致性应该是业界使用最多的，其核心思想是将分布式事务拆分成本地事务进行处理，这种思路是来源于ebay。我们可以从下面的流程图中看出其中的一些细节：

基本思路就是：

消息生产方，需要额外建一个消息表，并记录消息发送状态。消息表和业务数据要在一个事务里提交，也就是说他们要在一个数据库里面。然后消息会经过MQ发送到消息的消费方。如果消息发送失败，会进行重试发送。

消息消费方，需要处理这个消息，并完成自己的业务逻辑。此时如果本地事务处理成功，表明已经处理成功了，如果处理失败，那么就会重试执行。如果是业务上面的失败，可以给生产方发送一个业务补偿消息，通知生产方进行回滚等操作。

生产方和消费方定时扫描本地消息表，把还没处理完成的消息或者失败的消息再发送一遍。如果有靠谱的自动对账补账逻辑，这种方案还是非常实用的。

优点： 一种非常经典的实现，避免了分布式事务，实现了最终一致性。

缺点： 消息表会耦合到业务系统中，如果没有封装好的解决方案，会有很多杂活需要处理。

流程看我的图：

需求：下单同时，减库存

参与者A 订单服务

1订单服务

1.1  订单表插入数据，订单消息表添加数据101。本地事务，可以控制住。
1.2 定时任务：扫描订单消息表---》mq发一条消息，订单信息

2商品服务

2.1监听消息队列，收到消息订单详情。
2.2sku 减库存，接受到商品订单的消息表。本地事务，可以控制住。
2.3 定时任务：扫描接受到商品订单的消息表---》mq发一条消息，我已经减库存了
2.4 mq发一条消息  接受到商品订单的消息表 101 staus 2 已经发了消息了

3订单服务

3.1监听消息队列（已经减库存了） 订单消息表 删除

2. 分布式事务框架seata

2.1 seata简介

Seata（原名Fescar） 是阿里18年开源的分布式事务的框架。Fescar的开源对分布式事务框架领域影响很大。作为开源大户，Fescar来自阿里的GTS，经历了好几次双十一的考验，一经开源便颇受关注。后来Fescar改名为Seata。 [https://github.com/seata/seata](https://github.com/seata/seata)

Fescar虽然是二阶段提交协议的分布式事务，但是其解决了XA的一些缺点:

• 单点问题:虽然目前Fescar(0.4.2)还是单server的，但是Fescar官方预计将会在0.5.x中推出HA-Cluster，到时候就可以解决单点问题。
• 同步阻塞:Fescar的二阶段，其再第一阶段的时候本地事务就已经提交释放资源了，不会像XA会再两个prepare和commit阶段资源都锁住，并且Fescar,commit是异步操作，也是提升性能的一大关键。
• 数据不一致:如果出现部分commit失败，那么fescar-server会根据当前的事务模式和分支事务的返回状态的结果来进行不同的重试策略。并且fescar的本地事务会在一阶段的时候进行提交，其实单看数据库来说在commit的时候数据库已经是一致的了。
• 只能用于单一数据库: Fescar提供了三种模式，AT和TCC和混合模式。在AT模式下事务资源可以是任何支持ACID的数据库，在TCC模式下事务资源没有限制，可以是缓存，可以是文件，可以是其他的等等。当然这两个模式也可以混用。

同时Fescar也保留了接近0业务入侵的优点，只需要简单的配置Fescar的数据代理和加个注解，加一个Undolog表，就可以达到我们想要的目的。

2.2 实现原理

Fescar将一个本地事务做为一个分布式事务分支，所以若干个分布在不同微服务中的本地事务共同组成了一个全局事务，结构如下。

官帮助文档： https://seata.io/zh-cn/index.html

TM：全局事务管理器，在标注开启fescar分布式事务的服务端开启，并将全局事务发送到TC事务控制端管理

TC：事务控制中心，控制全局事务的提交或者回滚。这个组件需要独立部署维护，目前只支持单机版本，后续迭代计划会有集群版本

RM：资源管理器，主要负责分支事务的上报，本地事务的管理

一段话简述其实现过程：服务起始方发起全局事务并注册到TC。在调用协同服务时，协同服务的事务分支事务会先完成阶段一的事务提交或回滚，并生成事务回滚的undo_log日志，同时注册当前协同服务到TC并上报其事务状态，归并到同一个业务的全局事务中。此时若没有问题继续下一个协同服务的调用，期间任何协同服务的分支事务回滚，都会通知到TC，TC在通知全局事务包含的所有已完成一阶段提交的分支事务回滚。如果所有分支事务都正常，最后回到全局事务发起方时，也会通知到TC，TC在通知全局事务包含的所有分支删除回滚日志。在这个过程中为了解决写隔离和度隔离的问题会涉及到TC管理的全局锁。

（增加订单(branchId=901)，减库存(branchId=109)） xid=101

2.3 Fescar模式

Fescar对分布式事务的实现提供了3种模式，AT模式和TCC模式、saga模式：

2.3.1 AT模式

AT模式：主要关注多 DB 访问的数据一致性，实现起来比较简单，对业务的侵入较小，但性能没有TCC高，这种模式推荐大家使用。

AT模式部分代码如下：不需要关注执行状态，对业务代码侵入较小。

/**
  * 此代码为示例代码, 不需要演示, 主要看AT和TCC代码的区别使用
  */
@GlobalTransactional(timeoutMills = 300000, name = "dubbo-demo-tx")
public void purchase(String userId, String commodityCode, int orderCount) {
    LOGGER.info("purchase begin ... xid: " + RootContext.getXID());
    storageService.deduct(commodityCode, orderCount);
    orderService.create(userId, commodityCode, orderCount);
    throw new RuntimeException("AT 模式发生异常，回滚事务");
}

AT模式的核心是对业务无侵入，是一种改进后的两阶段提交，其设计思路如图：

第一阶段：

核心在于对业务sql进行解析，转换成undolog，两阶段提交往往对资源的锁定需要持续到第二阶段实际的提交或者回滚操作，而有了回滚日志之后，可以在第一阶段释放对资源的锁定，降低了锁范围，提高效率，即使第二阶段发生异常需要回滚，只需找对undolog中对应数据并反解析成sql来达到回滚目的。Seata通过代理数据源将业务sql的执行解析成undolog来与业务数据的更新同时入库，达到了对业务无侵入的效果。

第二阶段：

如果决议是全局提交，此时分支事务此时已经完成提交，不需要同步协调处理（只需要异步清理回滚日志），Phase2 可以非常快速地完成。

如果决议是全局回滚，RM 收到协调器发来的回滚请求，通过 XID 和 Branch ID 找到相应的回滚日志记录，通过回滚记录生成反向的更新 SQL 并执行，以完成分支的回滚。

2.3.3 TCC模式

TCC模式：TCC补偿机制，对代码造成一定的侵入,实现难度较大，这种方式不推荐，不过TCC模式的特点是性能高。

TCC模式部分代码如下：可以看到执行事务回滚，都需要根据不同阶段执行的状态判断，侵入了业务代码。

/**
 * 此代码为示例代码, 不需要演示, 主要看AT和TCC代码的区别使用
 * 转账操作
 * @param from  扣钱账户
 * @param to  加钱账户
 * @param amount  转账金额
 * @return
 */
@Override
@GlobalTransactional
public boolean transfer(final String from, final String to, final double amount) {
    //扣钱参与者，一阶段执行
    boolean ret = firstTccAction.prepareMinus(null, from, amount);
    if(!ret){
        //扣钱参与者，一阶段失败; 回滚本地事务和分布式事务
        throw new RuntimeException("账号:["+from+"] 预扣款失败");
    }
    //加钱参与者，一阶段执行
    ret = secondTccAction.prepareAdd(null, to, amount);
    if(!ret){
        throw new RuntimeException("账号:["+to+"] 预收款失败");
    }
    System.out.println(String.format("transfer amount[%s] from [%s] to [%s] finish.", String.valueOf(amount), from, to));
    return true;
}

2.3.3 Saga模式

详见 https://seata.io/zh-cn/docs/dev/mode/saga-mode.html

3 Seata案例

3.1准备工作

1导入资料中的ydles_common_fescar。注意总父工程中加入模块

<module>ydles_common_fescar</module>

2观察模块中的三个类。
![](img/image-20211209000033506.png#alt=image-20211209000033506)
3数据库ydles_order中的undo_log表为记录相关操作的表

4资料中的fescar-server-0.4.2解压，bin目录中双击fescar-server.bat。**注意**：这是fescar的服务，并且放到一个短目录才能执行。

3.2分布式事务错误演示

1order服务 com.ydles.order.service.impl 的 add方法中增加一个错误 本地事务控制注解增加@Transactional

        //减库存
        skuFeign.decrCount(order.getUsername());
        int i=1/0;
        // 5）删除购物车中数据
        redisTemplate.delete("cart_"+order.getUsername());

2goods 服务 com.ydles.goods.service.impl decrCount减库存方法上增加本地事务控制注解@Transactional

3查看数据库 tb_order tb_order_item中没数据。

tb_sku查看一条数据库存量 100

4登陆购物车并登陆 http://localhost:8001/api/wcart/list

5往购物车添加数据 http://localhost:8001/api/wcart/add?skuId=1450862568724758528&num=5

6购物车页面点击结算到订单页面

7点击提交订单

8代码中 order服务报错

9观察数据库

tb_order tb_order_item没变

tb_sku 1450862568724758528商品库存减少了5

10 为什么

order goods服务是两个服务，即使加上@Transactional也是本地事务控制。

3.3 分布式事务正确演示

1 goods order 增加fescar依赖

        <dependency>
            <groupId>com.ydles</groupId>
            <artifactId>ydles_common_fescar</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

2在订单微服务的OrderServiceImpl的add方法上增加@GlobalTransactional(name = “order_add”)注解

我的购物车

到结算页

下单失败了

3order 服务重启 观察 fescar控制台输出

4goods 服务重启 观察 fescar控制台输出

5重新提交订单 依然失败 但库存不扣减了

4消息队列实现分布式事务—-整个项目的重点

1业务流程-重点

需求：（一次下单—-》用户积分增加一次） 事务

1 order

1.1 order task.本地事务控制。
1.2 spring-task扫表 task-----》mq发消息

2user

2.1监听消息           6
2.2  8相当于锁 11释放锁
2.3 mq（另一个队列） task 积分加上了

3order

3.1监听消息 task_his 加上，后期查看，task 删除

2代码实现

2.1准备

1order中添加两张表

tb_task 任务表
![](img/image-20211209012241987.png#alt=image-20211209012241987)
tb_task_his 历史任务表
![](img/image-20211209012312800.png#alt=image-20211209012312800)

2order-api中添加对应的实体类

package com.ydles.order.pojo;
import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;
@Table(name = "tb_task")
public class Task {
    @Id
    private Long id;
    @Column(name = "create_time")
    private Date createTime;
    @Column(name = "update_time")
    private Date updateTime;
    @Column(name = "delete_time")
    private Date deleteTime;
    @Column(name = "task_type")
    private String taskType;
    @Column(name = "mq_exchange")
    private String mqExchange;
    @Column(name = "mq_routingkey")
    private String mqRoutingkey;
    @Column(name = "request_body")
    private String requestBody;
    @Column(name = "status")
    private String status;
    @Column(name = "errormsg")
    private String errormsg;
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public Date getCreateTime() {
        return createTime;
    }
    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }
    public Date getUpdateTime() {
        return updateTime;
    }
    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }
    public Date getDeleteTime() {
        return deleteTime;
    }
    public void setDeleteTime(Date deleteTime) {
        this.deleteTime = deleteTime;
    }
    public String getTaskType() {
        return taskType;
    }
    public void setTaskType(String taskType) {
        this.taskType = taskType;
    }
    public String getMqExchange() {
        return mqExchange;
    }
    public void setMqExchange(String mqExchange) {
        this.mqExchange = mqExchange;
    }
    public String getMqRoutingkey() {
        return mqRoutingkey;
    }
    public void setMqRoutingkey(String mqRoutingkey) {
        this.mqRoutingkey = mqRoutingkey;
    }
    public String getRequestBody() {
        return requestBody;
    }
    public void setRequestBody(String requestBody) {
        this.requestBody = requestBody;
    }
    public String getStatus() {
        return status;
    }
    public void setStatus(String status) {
        this.status = status;
    }
    public String getErrormsg() {
        return errormsg;
    }
    public void setErrormsg(String errormsg) {
        this.errormsg = errormsg;
    }
}

package com.ydles.order.pojo;
import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;
@Table(name = "tb_task_his")
public class TaskHis {
    @Id
    private Long id;
    @Column(name = "create_time")
    private Date createTime;
    @Column(name = "update_time")
    private Date updateTime;
    @Column(name = "delete_time")
    private Date deleteTime;
    @Column(name = "task_type")
    private String taskType;
    @Column(name = "mq_exchange")
    private String mqExchange;
    @Column(name = "mq_routingkey")
    private String mqRoutingkey;
    @Column(name = "request_body")
    private String requestBody;
    @Column(name = "status")
    private String status;
    @Column(name = "errormsg")
    private String errormsg;
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public Date getCreateTime() {
        return createTime;
    }
    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }
    public Date getUpdateTime() {
        return updateTime;
    }
    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }
    public Date getDeleteTime() {
        return deleteTime;
    }
    public void setDeleteTime(Date deleteTime) {
        this.deleteTime = deleteTime;
    }
    public String getTaskType() {
        return taskType;
    }
    public void setTaskType(String taskType) {
        this.taskType = taskType;
    }
    public String getMqExchange() {
        return mqExchange;
    }
    public void setMqExchange(String mqExchange) {
        this.mqExchange = mqExchange;
    }
    public String getMqRoutingkey() {
        return mqRoutingkey;
    }
    public void setMqRoutingkey(String mqRoutingkey) {
        this.mqRoutingkey = mqRoutingkey;
    }
    public String getRequestBody() {
        return requestBody;
    }
    public void setRequestBody(String requestBody) {
        this.requestBody = requestBody;
    }
    public String getStatus() {
        return status;
    }
    public void setStatus(String status) {
        this.status = status;
    }
    public String getErrormsg() {
        return errormsg;
    }
    public void setErrormsg(String errormsg) {
        this.errormsg = errormsg;
    }
}