MySQL事务的基本概念

事务(Transaction)是访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。 特点：事务是恢复和并发控制的基本单元，事务应具有4个属性：原子性、一致性、 隔离性、持久性。这四个属性通常称为 ACID 特性。

1. 原子性（Automicity）。一个事务是一个不可分割的工作单位，事务中包括的诸多操作要 么都做，要么都不做。
2. 一致性( Consistency)。事务必须是使数据库从一个一致性状态变到另一个一致性状态。 一致性与原子性是密切相关的。
3. 隔离性(Isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及 使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
4. 持久性（Durability）。持久性也称永久性(Permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响

Spring事务的传播属性

所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。当事务存在嵌套关系时，子事务与父事务的关系以及回滚的影响范围（传播-回滚的传播）

数据库的隔离级别

Spring数据隔离级别

Spring事务原理

Spring事务的原理其实比较简单，应为Spring的事务其实就是基于数据库对事务支持的一种封装，如果数据库不支持事务Spring也是无法提供事务的，我们可以从源码来看，其实Connection其实就是一个socket它建立了和数据库的链接，所以为数据库连接池其实就是放了n多个socket,我们可以看一下提交的源码：

public void commit() throws SQLException {
    try {
        synchronized(this.getConnectionMutex()) {
            this.checkClosed();

            try {
                if (this.connectionLifecycleInterceptors != null) {
                    IterateBlock<ConnectionLifecycleInterceptor> iter = new IterateBlock<ConnectionLifecycleInterceptor>(this.connectionLifecycleInterceptors.iterator()) {
                        void forEach(ConnectionLifecycleInterceptor each) throws SQLException {
                            if (!each.commit()) {
                                this.stopIterating = true;
                            }

                        }
                    };
                    iter.doForAll();
                    if (!iter.fullIteration()) {
                        return;
                    }
                }

                if (this.session.getServerSession().isAutoCommit()) {
                    throw SQLError.createSQLException(Messages.getString("Connection.3"), this.getExceptionInterceptor());
                } else if (!(Boolean)this.useLocalTransactionState.getValue() || this.session.getServerSession().inTransactionOnServer()) {
                    this.session.execSQL((Query)null, "commit", -1, (NativePacketPayload)null, false, this.nullStatementResultSetFactory, (ColumnDefinition)null, false);
                }
            } catch (SQLException var10) {
                if ("08S01".equals(var10.getSQLState())) {
                    throw SQLError.createSQLException(Messages.getString("Connection.4"), "08007", this.getExceptionInterceptor());
                } else {
                    throw var10;
                }
            } finally {
                this.session.setNeedsPing((Boolean)this.reconnectAtTxEnd.getValue());
            }
        }
    } catch (CJException var13) {
        throw SQLExceptionsMapping.translateException(var13, this.getExceptionInterceptor());
    }
}
复制代码

可以看到其实就是给数据库发送commit指令告诉数据库提交这里是调用session，这个session里面会有一个connect方法

public void connect(HostInfo hi, String user, String password, String database, int loginTimeout, TransactionEventHandler transactionManager) throws IOException {
    this.hostInfo = hi;
    this.setSessionMaxRows(-1);
    SocketConnection socketConnection = new NativeSocketConnection();
    socketConnection.connect(this.hostInfo.getHost(), this.hostInfo.getPort(), this.propertySet, this.getExceptionInterceptor(), this.log, loginTimeout);
    if (this.protocol == null) {
        this.protocol = NativeProtocol.getInstance(this, socketConnection, this.propertySet, this.log, transactionManager);
    } else {
        this.protocol.init(this, socketConnection, this.propertySet, transactionManager);
    }

    this.protocol.connect(user, password, database);
    this.isClosed = false;
    this.commandBuilder = new NativeMessageBuilder(this.getServerSession().supportsQueryAttributes());
}
复制代码

发现就是创建一个SocketConnection

再看rollback源码：

public void rollback() throws SQLException {
    try {
        synchronized(this.getConnectionMutex()) {
            this.checkClosed();

            try {
                if (this.connectionLifecycleInterceptors != null) {
                    IterateBlock<ConnectionLifecycleInterceptor> iter = new IterateBlock<ConnectionLifecycleInterceptor>(this.connectionLifecycleInterceptors.iterator()) {
                        void forEach(ConnectionLifecycleInterceptor each) throws SQLException {
                            if (!each.rollback()) {
                                this.stopIterating = true;
                            }

                        }
                    };
                    iter.doForAll();
                    if (!iter.fullIteration()) {
                        return;
                    }
                }

                if (this.session.getServerSession().isAutoCommit()) {
                    throw SQLError.createSQLException(Messages.getString("Connection.20"), "08003", this.getExceptionInterceptor());
                }

                try {
                    this.rollbackNoChecks();
                    return;
                } catch (SQLException var11) {
                    if (!(Boolean)this.ignoreNonTxTables.getInitialValue() || var11.getErrorCode() != 1196) {
                        throw var11;
                    }
                }
            } catch (SQLException var12) {
                if ("08S01".equals(var12.getSQLState())) {
                    throw SQLError.createSQLException(Messages.getString("Connection.21"), "08007", this.getExceptionInterceptor());
                }

                throw var12;
            } finally {
                this.session.setNeedsPing((Boolean)this.reconnectAtTxEnd.getValue());
            }

        }
    } catch (CJException var15) {
        throw SQLExceptionsMapping.translateException(var15, this.getExceptionInterceptor());
    }
}
复制代码

也还是向数据库发送指令rollback

其实说白了也就是数据库提供一些命令，Spring关闭了自动提交，用户就可以根据自己的业务来判断是否需要提交或者是是否需要回滚

数据库事务操作原理

首先要清楚的是数据库是分两片区域的一个是磁盘存储区域最后持久化的数据会存放到这里还有一个是内存区域，也就是还没有commit之前的数据先放到内存区域中，提交完成后才会持久化到磁盘中。如下图所示:

比如我们现在有一个Select操作

并不是说直接从持久化层读取数据然后返回，而是先读取到内存，检查数据无误后返回 再看一个UPDATE命令

数据库会把所有的操作日志记录下来。
日志机制是实现事务持久性的重要手段。在事务执行过程中，数据 库会将所有的修改操作记录在日志中，包括修改前的数据和修改后 的数据。如果事务执行失败，可以通过日志回滚操作来恢复数据。如果事务执行成功，数据库会将日志写入磁盘，以保证数据的持久性。

还有一个就是锁机制： 锁机制是实现事务隔离性的重要手段。在并发执行的情况下，多个 事务可能同时访问同一数据，为了保证数据的一致性，需要对数据 进行加锁。锁分为共享锁和排他锁，共享锁允许多个事务同时读取 数据，但不允许修改数据，排他锁则只允许一个事务同时访问数据。 在事务执行过程中，需要根据需要对数据进行加锁和解锁，以保证 数据的一致性和隔离性。

需要注意的是临时表的每条数据都会有隐藏的两列创建版本号和删除版本号，用于解决不可重复度的问题

作者：Potato_土豆
链接：
https://juejin.cn/post/7221740907233443900