【分布式】分布式事务

一、CAP理论

CAP是 Consistency、Availability、Partition tolerance三个词语的缩写，分别表示一致性、可用性、分区容忍性。

C - Consistency

一致性是指写操作后的读操作可以读取到最新的数据状态，当数据分布在多个节点上，从任意结点读取到的数据都 是最新的状态。
如何实现一致性？
1、写入主数据库后要将数据同步到从数据库。
2、写入主数据库后，在向从数据库同步期间要将从数据库锁定，待同步完成后再释放锁，以免在新数据写入成功 后，向从数据库查询到旧的数据。
分布式系统一致性的特点?
1、由于存在数据同步的过程，写操作的响应会有一定的延迟。
2、为了保证数据一致性会对资源暂时锁定，待数据同步完成释放锁定资源。
3、如果请求数据同步失败的结点则会返回错误信息，一定不会返回旧数据。

A - Availability

可用性是指任何事务操作都可以得到响应结果，且不会出现响应超时或响应错误。
如何实现可用性？
1、写入主数据库后要将数据同步到从数据库。
2、由于要保证从数据库的可用性，不可将从数据库中的资源进行锁定。
3、即时数据还没有同步过来，从数据库也要返回要查询的数据，哪怕是旧数据，如果连旧数据也没有则可以按照 约定返回一个默认信息，但不能返回错误或响应超时。
分布式系统可用性的特点?
1、 所有请求都有响应，且不会出现响应超时或响应错误。

P - Partition tolerance

通常分布式系统的各各结点部署在不同的子网，这就是网络分区，不可避免的会出现由于网络问题而导致结点之间 通信失败，此时仍可对外提供服务，这叫分区容忍性。
如何实现分区容忍性？
1、尽量使用异步取代同步操作，例如使用异步方式将数据从主数据库同步到从数据，这样结点之间能有效的实现松耦合。
2、添加从数据库结点，其中一个从结点挂掉其它从结点提供服务。
分布式分区容忍性的特点?
1、分区容忍性分是布式系统具备的基本能力，必备，否则不能称之为分布式。

二、CAP组合

在所有分布式事务场景中不会同时具备CAP三个特性，因为在具备了P的前提下C和A是不能共存的。

AP

放弃一致性，追求分区容忍性和可用性。这是很多分布式系统设计时的选择。

CP

放弃可用性，追求一致性和分区容错性，我们的zookeeper其实就是追求的强一致，又比如跨行转账，一次转账请 求要等待双方银行系统都完成整个事务才算完成。

CA

放弃分区容忍性，即不进行分区，不考虑由于网络不通或结点挂掉的问题，则可以实现一致性和可用性。那么系统 将不是一个标准的分布式系统，我们最常用的关系型数据就满足了CA。

三、BASE理论

1、理解强一致性和最终一致性

CAP中的一致性要求 在任何时间查询每个结点数据都必须一致，它强调的是强一致性，但是最终一致性是允许可以在一段时间内每个结 点的数据不一致，但是经过一段时间每个结点的数据必须一致，它强调的是最终数据的一致性。

2、Base理论

BASE 是 Basically Available(基本可用)、Soft state(软状态)和 Eventually consistent (最终一致性)三个短语的缩 写。BASE理论是对CAP中AP的一个扩展，通过牺牲强一致性来获得可用性，当出现故障允许部分不可用但要保证 核心功能可用，允许数据在一段时间内是不一致的，但最终达到一致状态。满足BASE理论的事务，我们称之为“柔 性事务”。

• 基本可用：分布式系统在出现故障时，允许损失部分可用功能，保证核心功能可用。如，电商网站交易付款出 现问题了，商品依然可以正常浏览。
• 软状态：由于不要求强一致性，所以BASE允许系统中存在中间状态（也叫软状态），这个状态不影响系统可用 性，如订单的"支付中"、“数据同步中”等状态，待数据最终一致后状态改为“成功”状态。
• 最终一致：最终一致是指经过一段时间后，所有节点数据都将会达到一致。如订单的"支付中"状态，最终会变 为“支付成功”或者"支付失败"，使订单状态与实际交易结果达成一致，但需要一定时间的延迟、等待。

四、分布式事务解决方案之2PC(两阶段提交)-XA协议

2PC即两阶段提交协议，是将整个事务流程分为两个阶段，准备阶段（Prepare phase）、提交阶段（commit phase），2是指两个阶段，P是指准备阶段，C是指提交阶段。

1. 准备阶段（Prepare phase）：事务管理器给每个参与者发送Prepare消息，每个数据库参与者在本地执行事务，并写本地的Undo/Redo日志，此时事务没有提交。 （Undo日志是记录修改前的数据，用于数据库回滚，Redo日志是记录修改后的数据，用于提交事务后写入数据文件）。当事务管理器接收到XA协议第一阶段得到的所有数据库的就绪信息后，就会对所有数据库发送提交的命令。
2. 提交阶段（commit phase）：如果事务管理器收到了参与者的执行失败或者超时消息时，直接给每个参与者 发送回滚(Rollback)消息；否则，发送提交(Commit)消息；参与者根据事务管理器的指令执行提交或者回滚操作，并释放事务处理过程中使用的锁资源。注意:必须在最后阶段释放锁资源。
3. 当做完上一步后，本地资源管理器就会对事务管理器发送提交成功的信息，表明数据已经操作成功了

成功的情况：

失败的情况：

五、XA协议实现

Java方面定义了JTA（Java Transaction API）规范，和JDBC一样，JTA只是一个规范，它需要具体的数据库厂商进行实现，这是一种典型的桥接模式。在JTA中，定义了接口XAConnection和XADataSource，这两个接口的实现需要具体的数据库厂商提供。在MySQL中，5.0以后的版本才开始支持XA协议，因此在MySQL中使用JTA，需要使用MySQL 5.0以后的版本。MySQL中提供了XAConnection和XADataSource两个接口的具体实现类，因而支持XA协议。
为了更好地支持分布式事务，一些开源框架也提供了很好的支持，其中以Atomikos、Bitronix和Narayana最为出名。我们使用Atomikos来实现分布式事务。
POM文件导入实现框架

<?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>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.3</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>lwb-spring-XA</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--实现XA（两阶段提交协议——XA协议）-->
        <!--<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jta-bitronix</artifactId>
            <version>2.3.12.RELEASE</version>
        </dependency>-->
        <!--实现XA（两阶段提交协议——XA协议）-->
        <!--<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jta-narayana</artifactId>
            <version>2.0.9.RELEASE</version>
        </dependency>-->
        <!--实现XA（两阶段提交协议——XA协议）-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jta-atomikos</artifactId>
            <version>2.6.7</version>
        </dependency>
    </dependencies>
</project>

定义启动类：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author 隐市高手
 * @date 2022/5/17 20:15
 */
@SpringBootApplication
public class XAApplicationContext {
    public static void main(String[] args) {
        SpringApplication.run(XAApplicationContext.class, args);
    }
}

定义datasource和jdbcTemplate

import com.atomikos.jdbc.AtomikosDataSourceBean;
import com.mysql.cj.jdbc.MysqlXADataSource;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;

/**
 * @author 隐市高手
 * @date 2022/5/17 20:17
 */
@Configuration
public class DataSourceConfig {

    @Primary
    @Bean("ds1")
    public DataSource dataSource1() {
        AtomikosDataSourceBean ds = new AtomikosDataSourceBean();
        MysqlXADataSource xaDs = new MysqlXADataSource();
        xaDs.setUrl("jdbc:mysql://127.0.0.1:3306/test_01?serverTimezone=UTC");
        xaDs.setUser("root");
        xaDs.setPassword("root");
        ds.setXaDataSource(xaDs);
        ds.setUniqueResourceName("ds1");
        initPool(ds);
        return ds;
    }

    @Bean("ds2")
    public DataSource dataSource2() {
        AtomikosDataSourceBean ds = new AtomikosDataSourceBean();
        MysqlXADataSource xaDs = new MysqlXADataSource();
        xaDs.setUrl("jdbc:mysql://127.0.0.1:3306/test_02?serverTimezone=UTC");
        xaDs.setUser("root");
        xaDs.setPassword("root");
        ds.setXaDataSource(xaDs);
        ds.setUniqueResourceName("ds2");
        initPool(ds);
        return ds;
    }

    @Primary
    @Bean("jdbcTemplate1")
    public JdbcTemplate jdbcTemplate1(@Qualifier("ds1") DataSource dataSource) {
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    @Primary
    @Bean("jdbcTemplate2")
    public JdbcTemplate jdbcTemplate2(@Qualifier("ds2") DataSource dataSource) {
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    private void initPool(AtomikosDataSourceBean ds) {
        // 连接池最大连接数
        ds.setMaxPoolSize(50);
        // 连接池最小连接数
        ds.setMinPoolSize(10);
        // 连接池默认连接数
        ds.setPoolSize(30);
    }
}

定义service

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.Transactional;

/**
 * @author 隐市高手
 * @date 2022/5/17 20:38
 */
@Service
public class XaService {
    @Autowired
    @Qualifier("jdbcTemplate1")
    private JdbcTemplate jdbcTemplate1 = null;

    @Autowired
    @Qualifier("jdbcTemplate2")
    private JdbcTemplate jdbcTemplate2 = null;

    //注入事务管理器
    @Autowired
    private PlatformTransactionManager transactionManager = null;

    @Transactional
    public int insertStudent(String username, String password) {
        System.out.println("数据库事务管理器类型：" + transactionManager.getClass().getName());
        String sql = "insert into student(username,password) values(?,?)";
        int count = 0;
        count += jdbcTemplate2.update(sql, username, password);
        count += jdbcTemplate1.update(sql, username, password);
        return count;
    }
}

定义访问controller，提交数据

import cn.lwb.xa.service.XaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 隐市高手
 * @date 2022/5/17 20:46
 */
@RestController
public class XAController {

    @Autowired
    private XaService xaService;

    @GetMapping("/insert")
    public Integer insert(@RequestParam(value = "username", required = false)String username, @RequestParam("password") String password) {
        return xaService.insertStudent(username, password);
    }

}
``
创建两个测试数据库和两张表，用户测试：
```sql
create table student
(
    id       int auto_increment primary key,
    username varchar(200) null,
    password varchar(200) null
);

最终的数据库结构：

最终的项目结构：

至此2PC（XA）协议完成。

六、XA协议的弊端

• 需要本地数据库支持XA协议
• 性能不是很好，使用XA协议的性能和不使用XA协议的性能，相差接近10倍
• 造成更为严重的死锁问题，预编译SQL的时候会锁定数据，如果后续没有提交事务的命令或者回滚事务的命令，数据库就会一直锁定数据，造成数据库死锁的问题