Spring事务传播原理及数据库事务操作原理

谁借莪１个温暖的怀抱￠ 2023-10-09 17:48 12阅读 0赞

#### MySQL事务的基本概念 ####

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

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

#### Spring事务的传播属性 ####

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

<table> 
 <thead> 
  <tr> 
   <th>常量名称</th> 
   <th>常量解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>PROPAGATION REQUIRED</td> 
   <td>支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择，也是Spring默认的事务的传播。</td> 
  </tr> 
  <tr> 
   <td>PROPAGATION REQUIRES NEW</td> 
   <td>新建事务，如果当前存在事务，把当前事务挂起。新建的事务将和被挂起的事务没有任何关系，是两个独立的事务，外层事务失败回滚之后，不能回滚内层事务执行的结果，内层事务失败抛出异常，外层事务捕获，也可以不处理回滚操作</td> 
  </tr> 
  <tr> 
   <td>PROPAGATION SUPPORTS</td> 
   <td>支持当前事务，如果当前没有事务就以非事务方式执行</td> 
  </tr> 
  <tr> 
   <td>PROPAGATION MANDATORY</td> 
   <td>支持当前事务，如果当前没有事务，就抛出异常。</td> 
  </tr> 
  <tr> 
   <td>PROPAGATION NOT SUPPORTED</td> 
   <td>以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。</td> 
  </tr> 
  <tr> 
   <td>PROPAGATION NEVER</td> 
   <td>如果一个活动的事务存在，则运行在一个嵌套的事务中。如果没有活动事务，则按REQUIRED 属性执行。它使用了一个单独的事务，这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionManager 事务管理器起效。</td> 
  </tr> 
 </tbody> 
</table>

#### 数据库的隔离级别 ####

<table> 
 <thead> 
  <tr> 
   <th>隔离级别</th> 
   <th>值</th> 
   <th>问题</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Read-Uncommitted</td> 
   <td>0</td> 
   <td>导致脏读</td> 
   <td>脏读：一个事务对数据进行了增删改，但未提交，另一事务可以读取到未提交的数据。如果第一个事务这时候回滚了，那么第二个事务就读到了脏数据。</td> 
  </tr> 
  <tr> 
   <td>Read-Committed</td> 
   <td>1</td> 
   <td>避免脏读，允许不可重复读和幻读</td> 
   <td>不可重复读：一个事务中发生了两次读操作，第一次读操作和第二次操作之间，另外一个事务对数据进行了修改，这时候两次读取的数据是不一致的。</td> 
  </tr> 
  <tr> 
   <td>Repeatable-Read</td> 
   <td>2</td> 
   <td>避免脏读，不可重复读，允许幻读</td> 
   <td>幻读：第一个事务对一定范围的数据进行批量修改，第二个事务在这个范围增加一条数据，这时候第一个事务就会丢失对新增数据的修改。</td> 
  </tr> 
  <tr> 
   <td>Serializable</td> 
   <td>3</td> 
   <td>串行化读，事务只能一个一个执行，避免了脏读、不可重复读、幻读。执行效率慢，使用时慎重</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

#### Spring数据隔离级别 ####

<table> 
 <thead> 
  <tr> 
   <th>隔离级别</th> 
   <th>解读</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ISOLATION DEFAULT</td> 
   <td>这是个 PlatfromTransactionManager 默认的隔离级别，使用数据库默认的事务隔离级别。另外四个与 JDBC 的隔离级别相对应。</td> 
  </tr> 
  <tr> 
   <td>ISOLATION READ UNCOMMITTED</td> 
   <td>这是事务最低的隔离级别，它允许另外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。</td> 
  </tr> 
  <tr> 
   <td>ISOLATION READ COMMITTED</td> 
   <td>保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。</td> 
  </tr> 
  <tr> 
   <td>ISOLATION REPEATABLE READ</td> 
   <td>这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。</td> 
  </tr> 
  <tr> 
   <td>ISOLATION SERIALIZABLE</td> 
   <td>这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。</td> 
  </tr> 
 </tbody> 
</table>

#### 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之前的数据先放到内存区域中，提交完成后才会持久化到磁盘中。如下图所示:

![format_png][]

比如我们现在有一个`Select`操作 并不是说直接从持久化层读取数据然后返回，而是先读取到内存，检查数据无误后返回 再看一个UPDATE命令

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

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

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

作者：Potato\_土豆  
链接：https://juejin.cn/post/7221740907233443900

[format_png]: https://img-blog.csdnimg.cn/img_convert/071285a713fee2f37b61b078129a0c5d.webp?x-oss-process=image/format,png