分布式事务 LCN

十点 vha

于 2024-01-11 09:51:25 发布

阅读量1.3k

点赞数 29

CC 4.0 BY-SA版权

分类专栏： spring cloud 文章标签：分布式 spring cloud

本文链接：https://blog.csdn.net/m0_68933188/article/details/135519172

spring cloud 专栏收录该内容

17 篇文章

订阅专栏

第一节分布式事务的产生

数据库分库分表就产生了分布式事务；

项目拆分服务化也产生了分布式事务；

当单个数据库的性能产生瓶颈的时候，可能会对数据库进行分区（物理分区），分区之后可能不同的库就处于不同的服务器上了，此时单个数据库的ACID已经不能适应这种情况了，在集群环境下，再想保证ACID几乎是很难达到，这时就需要引入一个新的理论来适应这种集群的情况，这个理论就是CAP定理

第二节 CAP定理

CAP定理是由加州大学伯克利分校Eric Brewer教授提出来的，他指出WEB服务无法同时满足以下3个属性：

一致性(Consistency) ：客户端知道一系列的操作都会同时发生
可用性(Availability) ：每个操作都必须以可预期的响应结束
分区容错性(Partition tolerance) ：即使出现单个组件无法可用,操作依然可以完成

在分布式系统中的任何数据库设计，一个Web应用至多只能同时支持上面的两个属性。分区容错性是分布式系统必须要保证的，因此，设计人员必须在一致性与可用性之间做出选择。对于任何系统来说，可用性都是比较重要的，因此，在选择的时候，基本上都会选择可用性。那么，一致性就得不到保证，为了解决这个问题，也需要引入一个新的理论来适应这种情况，这个理论就是BASE理论。

第三节 BASE 理论

BASE理论指的是：

Basically Available（基本可用）
Soft state（软状态）
Eventually consistency（最终一致性）

BASE理论是对CAP中的一致性和可用性进行一个权衡的结果，理论的核心思想就是：既然无法做到强一致，但每个应用都可以根据自身的业务特点，采用适当的方式来使系统达到最终一致性。

第四节 `XA` 协议(`XA Transactions`)

XA 是一个两阶段提交协议，该协议分为以下两个阶段：

第一阶段：事务协调器要求每个涉及到事务的数据库预提交( precommit )此操作，并反映是否可以提交.
第二阶段：事务协调器要求每个数据库提交数据。

其中，如果有任何一个数据库否决此次提交，那么所有数据库都会被要求回滚它们在此事务中的那部分信息。

第五节分布式事务解决方案

1. 两阶段提交协议

1.1 概念

两阶段提交协议，简写2PC，2PC就是使用 XA 协议的原理。通过引入协调者（Coordinator）来协调参与者的行为，并最终决定这些参与者是否要真正执行事务。

1.2 执行流程

准备阶段：协调者询问参与者事务是否执行成功，参与者发回事务执行结果。
提交阶段：如果事务在每个参与者上都执行成功，事务协调者发送通知让参与者提交事务；否则，协调者发送通知让参与者回滚事务。需要注意的是，在准备阶段，参与者执行了事务，但是还未提交。只有在提交阶段接收到协调者发来的通知后，才进行提交或者回滚。

1.3 存在问题

所有事务参与者在等待其它参与者响应的时候都处于同步阻塞状态，无法进行其它操作
协调者在 2PC 中起到非常大的作用，发生故障将会造成很大影响。特别是在阶段二发生故障，所有参与者会一直等待状态，无法完成其它操作。
在阶段二，如果协调者只发送了部分 Commit 消息，此时网络发生异常，那么只有部分参与者接收到 Commit 消息，也就是说只有部分参与者提交了事务，使得系统数据不一致。
太过保守任意一个节点失败就会导致整个事务失败，没有完善的容错机制。

2. 补偿事务（`TCC`）

2.1 概念

TCC 其实就是采用的补偿机制，其核心思想是：针对每个操作，都要注册一个与其对应的确认和补偿（撤销）操作。TCC 一共包括两个阶段 Try阶段、 Confirm/Cancel阶段

2.2 执行流程

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

2.3 问题

代码侵入多，实现复杂
容易出现空回滚，需要使用代码解决
容易出现事务重试，需要考虑幂等性，也需要使用代码解决
容易出现资源悬挂，同样需要使用代码解决

第六节 LCN分布式事务框架

1. 什么是LCN分布式事务

LCN分布式事务框架其本身并不创建事务，而是基于对本地事务的协调从而达到事务一致性的效果。LCN常用的分布式事务有两种模式：LCN模式，TCC模式

1.1 `LCN`模式

LCN 模式是通过代理 Connection 的方式实现对本地事务的操作，然后在由 TxManager 统一协调控制事务。当本地事务提交回滚或者关闭连接时将会执行假操作，该代理的连接将由 LCN 连接池管理。

LCN模式的特点：

对代码的嵌入性为低。
仅限于本地存在连接对象且可通过连接对象控制事务的模块。
事务提交与回滚是由本地事务方控制，对于数据一致性上有较高的保障。
代理的连接需要随事务发起方一共释放连接，增加了连接占用的时间。

1.2 `TCC`模式

TCC事务机制相对于传统事务机制（X/Open XA Two-Phase-Commit），其特征在于它不依赖资源管理器(RM)对 XA 的支持，而是通过对（由业务系统提供的）业务逻辑的调度来实现分布式事务。主要由三步操作，Try : 尝试执行业务、 Confirm : 确认执行业务、Cancel : 取消执行业务。

TCC模式的特点：

对代码的嵌入性高，要求每个业务需要写三种步骤的操作。
对有无本地事务控制都可以支持使用面广。
数据一致性控制几乎完全由开发者控制，对业务开发难度要求高。

2. `LCN`分布式事务原理

LCN事务控制原理是由事务模块TxClient下的代理连接池与 TxManager 的协调配合完成的事务协调控制。TxClient 的代理连接池实现了 javax.sql.DataSource 接口，并重写了 close 方法，事务模块在提交关闭以后 TxClient 连接池将执行"假关闭"操作，等待 TxManager 协调完成事务以后在关闭连接。

核心步骤

创建事务组是指在事务发起方开始执行业务代码之前先调用 TxManager 创建事务组对象，然后拿到事务标示 GroupId的过程。
添加事务组添加事务组是指参与方在执行完业务方法以后，将该模块的事务信息添加通知给 TxManager 的操作。
关闭事务组是指在发起方执行完业务代码以后，将发起方执行结果状态通知给 TxManager 的动作。当执行完关闭事务组的方法以后，TxManager 将根据事务组信息来通知相应的参与模块提交或回滚事务。

第三节 `LCN`分布式事务实现

1. `LCN` 服务器搭建

1.1 编译源码

mvn install -Dmaven.test.skip=true

1.2 创建父工程 qf-cloud-tx

<?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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.qf</groupId>
    <artifactId>spring-cloud-tx</artifactId>
    <version>1.0</version>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Finchley.SR3</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.0.1.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

1.3 创建子工程 qf-lcn

<?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>spring-cloud-tx</artifactId>
        <groupId>com.qf</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>qf-lcn</artifactId>

    <dependencies>
        <!-- 参照例子引入需要的依赖jar -->
        <dependency>
            <groupId>com.codingapi.txlcn</groupId>
            <artifactId>txlcn-tm</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
    </dependencies>
</project>

1.4 配置 `application.properties`

spring.application.name=txlcn-tm
server.port=7970

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/tx-manager?characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.hibernate.ddl-auto=update


# TM后台登陆密码
tx-lcn.manager.admin-key=123456

tx-lcn.manager.host=127.0.0.1
tx-lcn.manager.port=8070

# 开启日志,默认为false
tx-lcn.logger.enabled=true
tx-lcn.logger.driver-class-name=${spring.datasource.driver-class-name}
tx-lcn.logger.jdbc-url=${spring.datasource.url}
tx-lcn.logger.username=${spring.datasource.username}
tx-lcn.logger.password=${spring.datasource.password}
logging.level.com.codingapi.txlcn=DEBUG

#redis 主机
spring.redis.host=127.0.0.1
#redis 端口
spring.redis.port=6379
#redis 密码
spring.redis.password=

1.5 编写启动类

package com.qf.lcn;

import com.codingapi.txlcn.tm.config.EnableTransactionManagerServer;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableTransactionManagerServer
public class QfLcnServer {

    public static void main(String[] args) {
        SpringApplication.run(QfLcnServer.class, args);
    }
}

2. 搭建注册中心

2.1 创建子工程 qf-registry

<?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>spring-cloud-tx</artifactId>
        <groupId>com.qf</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>qf-registry</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>
</project>

2.2 配置 `application.yml`

server:
  port: 11000
eureka:
  client:
    fetch-registry: false
    register-with-eureka: false
    service-url:
      defaultZone: http://localhost:11000/eureka

2.3 编写启动类

package com.qf.registry;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class QfRegistry {

    public static void main(String[] args) {
        SpringApplication.run(QfRegistry.class, args);
    }
}

3. 搭建商品服务

3.1创建子工程 `qf-goods`

<?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>spring-cloud-tx</artifactId>
        <groupId>com.qf</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>qf-goods</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.1</version>
        </dependency>

        <dependency>
            <groupId>com.codingapi.txlcn</groupId>
            <artifactId>txlcn-tc</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.codingapi.txlcn</groupId>
            <artifactId>txlcn-txmsg-netty</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.17</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>
    </dependencies>
</project>

3.2 配置 `application.yml`

server:
  port: 13000
eureka:
  client:
    service-url:
      defaultZone: http://localhost:11000/eureka/

spring:
  application:
    name: qf-goods
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/goods?serverTimezone=UTC
    username: root
    password: root
    type: com.alibaba.druid.pool.DruidDataSource
mybatis:
  mapper-locations: classpath:mapper/*Mapper.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
tx-lcn:
  primary-key-package:
  client:
    manager-address: 127.0.0.1:8070
  #是否启动LCN负载均衡策略(优化选项,开启与否,功能不受影响)
  ribbon:
    loadbalancer:
      dtx:
        enabled: true
  #是否开启日志记录,当开启以后需要配置对应logger的数据库连接配置信息
  logger:
    enabled: true
    driver-class-name: ${spring.datasource.driver-class-name}
    jdbc-url: ${spring.datasource.url}
    username: ${spring.datasource.username}
    password: ${spring.datasource.password}

3.3 编写启动类

package com.qf.goods;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
@MapperScan("com.qf.goods.mapper")
public class QfGoodsServer {

    public static void main(String[] args) {
        SpringApplication.run(QfGoodsServer.class, args);
    }
}

3.4 编写 `GoodsMapper` 接口

package com.qf.goods.mapper;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Update;

import java.util.Map;

@Mapper
public interface GoodsMapper {

    @Update("UPDATE goods SET num = num - #{goods.buyCount} WHERE id = #{goods.goodsId}")
    int buyGoods(@Param("goods") Map<String,Object> params);
}

3.5 编写业务层接口及实现

package com.qf.goods.service;

import java.util.Map;

public interface GoodsService {

    int updateGoods(Map<String,Object> params);
}


package com.qf.goods.service.impl;

import com.qf.goods.mapper.GoodsMapper;
import com.qf.goods.service.GoodsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Map;

@Service
public class GoodsServiceImpl implements GoodsService {

    @Autowired
    private GoodsMapper goodsMapper;

    @Transactional
    @Override
    public int buyGoods(Map<String, Object> params) {
        return goodsMapper.buyGoods(params);
    }
}

3.6 编写控制器

package com.qf.goods.controller;

import com.qf.goods.service.GoodsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;

@RestController
@RequestMapping("/goods")
public class GoodsController {


    @Autowired
    private GoodsService goodsService;

    @PutMapping
    public int buyGoods(@RequestBody Map<String,Object> params){
        return goodsService.buyGoods(params);
    }
}

4. 搭建订单服务

4.1 创建子工程 `qf-order`

<?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>spring-cloud-tx</artifactId>
        <groupId>com.qf</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>qf-order</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.1</version>
        </dependency>

        <dependency>
            <groupId>com.codingapi.txlcn</groupId>
            <artifactId>txlcn-tc</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.codingapi.txlcn</groupId>
            <artifactId>txlcn-txmsg-netty</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.17</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>
    </dependencies>
</project>

4.2 配置 `application.yml`

server:
  port: 12000
eureka:
  client:
    service-url:
      defaultZone: http://localhost:11000/eureka/

spring:
  application:
    name: qf-order
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/order?serverTimezone=UTC
    username: root
    password: root
    type: com.alibaba.druid.pool.DruidDataSource
mybatis:
  mapper-locations: classpath:mapper/*Mapper.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
tx-lcn:
  client:
    manager-address: 127.0.0.1:8070
  primary-key-package:
  #是否启动LCN负载均衡策略(优化选项,开启与否,功能不受影响)
  ribbon:
    loadbalancer:
      dtx:
        enabled: true
#是否开启日志记录,当开启以后需要配置对应logger的数据库连接配置信息
  logger:
    enabled: true
    driver-class-name: ${spring.datasource.driver-class-name}
    jdbc-url: ${spring.datasource.url}
    username: ${spring.datasource.username}
    password: ${spring.datasource.password}

4.3 编写启动类

package com.qf.order;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
@MapperScan("com.qf.order.mapper")
public class QfOrderServer {

    public static void main(String[] args) {
        SpringApplication.run(QfOrderServer.class, args);
    }
}

4.4 编写 `OrderMapper` 接口

package com.qf.order.mapper;

import org.apache.ibatis.annotations.*;

import java.util.Map;

@Mapper
public interface OrderMapper {

    @Insert("INSERT INTO orders(goods_id,buy_count,payment) VALUES(#{order.goodsId}, #{order.buyCount}, #{order.payment})")
    @SelectKey(keyProperty = "order.id", before = false, statement = "SELECT LAST_INSERT_ID()", resultType = Long.class)
    int addOrder(@Param("order") Map<String,Object> params);
}

4.5 编写业务层接口及实现

package com.qf.order.service;

import java.util.Map;

public interface OrderService {

    int addOrder(Map<String,Object> params);
}


package com.qf.order.service.impl;

import com.qf.order.mapper.OrderMapper;
import com.qf.order.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Map;

@Service
public class OrderServiceImpl implements OrderService {

    @Autowired
    private OrderMapper orderMapper;

    @Transactional
    @Override
    public int addOrder(Map<String, Object> params) {
        return orderMapper.addOrder(params);
    }
}

4.6 编写控制层

package com.qf.order.controller;

import com.qf.order.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;

@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private OrderService orderService;

    @PostMapping
    public int addOrder(@RequestBody Map<String,Object> params){
        return orderService.addOrder(params);
    }
}

现有有一用户购买了商品，购买之后需要产生订单，如何保证订单的正确创建？

5. `LCN`模式实现

5.1 在 `qf-goods` 工程中添加Feign接口

package com.qf.goods.client;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

import java.util.Map;

@FeignClient(name = "qf-order", path = "/order")
public interface OrderClient {

    @PostMapping
    int addOrder(@RequestBody Map<String,Object> params);
}

5.2 修改`qf-goods` 业务实现

package com.qf.goods.service.impl;

import com.codingapi.txlcn.tc.annotation.DTXPropagation;
import com.codingapi.txlcn.tc.annotation.LcnTransaction;
import com.qf.goods.client.OrderClient;
import com.qf.goods.mapper.GoodsMapper;
import com.qf.goods.service.GoodsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Map;

@Service
public class GoodsServiceImpl implements GoodsService {

    @Autowired
    private GoodsMapper goodsMapper;

    @Autowired
    private OrderClient orderClient;

    //开启LCN事务
    @LcnTransaction(propagation = DTXPropagation.REQUIRED)
    @Transactional
    @Override
    public int buyGoods(Map<String, Object> params) {
        int result1 = goodsMapper.buyGoods(params);
        double price = (double) params.remove("price");
        int buyCount = (int) params.get("buyCount");
        double payment = price * buyCount;
        params.put("payment", payment);
        int result2 = orderClient.addOrder(params);
        return result1 == 1 && result2 == 1 ? 1 : 0;
    }
}

5.3 修改`qf-goods` 启动类

package com.qf.goods;

import com.codingapi.txlcn.tc.config.EnableDistributedTransaction;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableDistributedTransaction //启用分布式事务
@EnableEurekaClient
@EnableFeignClients
@EnableCircuitBreaker
@MapperScan("com.qf.erp.mapper")
public class QfGoodsServer {

    public static void main(String[] args) {
        SpringApplication.run(QfGoodsServer.class, args);
    }
}

5.4 修改 `qf-order` 业务层

package com.qf.order.service.impl;

import com.codingapi.txlcn.tc.annotation.DTXPropagation;
import com.codingapi.txlcn.tc.annotation.LcnTransaction;
import com.qf.order.mapper.OrderMapper;
import com.qf.order.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Map;

@Service
public class OrderServiceImpl implements OrderService {

    @Autowired
    private OrderMapper orderMapper;

    @LcnTransaction(propagation = DTXPropagation.SUPPORTS) //开启LCN事务
    @Transactional
    @Override
    public int addOrder(Map<String, Object> params) {
        return orderMapper.addOrder(params);
    }
}

5.5 修改`qf-order` 启动类

package com.qf.order;

import com.codingapi.txlcn.tc.config.EnableDistributedTransaction;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
@EnableDistributedTransaction //开启分布式事务
@MapperScan("com.qf.order.mapper")
public class QfOrderServer {

    public static void main(String[] args) {
        SpringApplication.run(QfOrderServer.class, args);
    }
}