1.[UVM源代码研究] UVM的field_automation实现的print()函数如何灵活控制打印数组元素的数量
2.bitcoin源码解析 - 交易 Transcation (一)
3.openGauss数据库源码解析系列文章——事务机制源码解析（一）
4.@Transactional 详解
5.一文带你掌握Spring事务核心：TransactionDefinition详解！
6.BoltDB源码解析（二）事务

[UVM源代码研究] UVM的field_automation实现的print()函数如何灵活控制打印数组元素的数量

       实际工作中，我们常遇到需打印包含多个数组或队列元素的transaction时，仅默认显示开始5个和最后5个元素。若需查看更多元素值或完整内容，可考虑两种方法：一是sip回拨源码重写transaction的do_print()函数，自定义打印内容与格式；二是探索现有UVM源代码，修改相关设定以实现打印更多元素。

       首先，分析can_txrx_transfer的注册方式，发现其默认仅显示特定数量的元素。通过查看源代码，发现实现打印机制的关键在于UVM_FIELD_QDA_INT宏与UVM_FIELD_UTILS_BEGIN宏的结合，它们共同调用_m_uvm_field_automation函数，该函数根据指定的what_参数（如UVM_PRINT）调用相应的打印函数。

       在调用print()函数时，最终调用_m_uvm_field_automation，进一步调用uvm_print_array_int3宏。该宏通过uvm_print_qda_int4宏实现打印逻辑，对静态或动态数组、队列元素的打印格式进行统一处理。在uvm_print_qda_int4宏中，定义了uvm_printer与uvm_printer_knobs变量，用于接收打印参数与配置信息。

       uvm_default_printer作为全局变量，其配置决定了打印格式。在打印数组时，通过设置uvm_printer_knobs中的begin_elements与end_elements变量，可以灵活控制打印元素的数量。具体配置方法可将uvm_default_printer配置在test_base的build_phase中，实现对打印数量的精确控制。

       通过上述分析，我们了解了UVM源代码实现打印机制的原理，并掌握灵活配置数组/队列元素打印数量的方法。这种方法不仅提供了更为灵活的打印控制，还能根据实际需求调整打印内容与格式，增强代码的可读性和实用性。

bitcoin源码解析 - 交易 Transcation (一)

       在比特币的核心机制中，交易起着至关重要的黑马趋势源码免费作用，它是比特币存在的载体，其复杂性体现了中本聪的精妙设计。我们将逐步解析比特币源码中的交易结构。首先，交易在比特币的分布式系统中被表示为CTransaction类，它是“交易”(Tx)的中心，尽管看似简单，但其内部的vin和vout成员变量定义了交易的流入和流出，而非传统的账户转账记录。

       每个Tx的vin和vout都是向量，允许一个交易有多条流入和流出路径。比特币的规则要求每个交易的流出必须等于所有流入的总和，包括交易费用，确保了交易的平衡性。例如，当A转账给B，若A的流出不足以满足转账，剩余的比特币会自动锁定，形成一个新的流出，确保交易的完整性。

       交易的流入和流出通过CTxIn和CTxOut类进一步具体化，CTxIn引用了上一个交易的输出点(COutPoint)，代表了交易的来源，而nSequence则在后续版本中增加了更多功能。CTxOut则记录了流出的金额和附带的条件，通过scriptSig和scriptPubkey控制钱的流出权限，这是比特币智能合约的基础。

       交易的流转被比作水流的分叉，每个交易就像一个中转节点，其vin和vout定义了货币流的方向。scriptSig和scriptPubkey就像锁和钥匙，通过脚本(CScript)实现控制，确保了交易的合法性和安全性。COutPoint和CInPoint则扮演了键值对应的角色，用于追踪交易的来源和去向。

       最后，CTxIndex和CDiskTxPos负责本地存储和索引交易，确保了交易状态的波段kdj公式源码跟踪，而CMerkleTx和CWalletTx是交易在区块和钱包中的特定版本。理解这些类和它们的属性是理解比特币交易机制的关键，后续文章将深入探讨交易的具体运作原理和源码实现。

openGauss数据库源码解析系列文章——事务机制源码解析（一）

       事务是数据库操作的核心单位，必须满足原子性、一致性、隔离性、持久性（ACID）四大属性，确保数据操作的可靠性与一致性。以下是openGauss数据库中事务机制的详细解析：

       ### 事务整体架构与代码概览

       在openGauss中，事务的实现与存储引擎紧密关联，主要集中在源代码的`gausskernel/storage/access/transam`与`gausskernel/storage/lmgr`目录下。事务系统包含关键组件：

       1. **事务管理器**：事务系统的中枢，基于有限循环状态机，接收外部命令并根据当前事务状态决定下一步执行。

       2. **日志管理器**：记录事务执行状态及数据变化过程，包括事务提交日志（CLOG）、事务提交序列日志（CSNLOG）与事务日志（XLOG）。

       3. **线程管理机制**：通过内存区域记录所有线程的事务信息，支持跨线程事务状态查询。

       4. **MVCC机制**：采用多版本并发控制（MVCC）实现读写隔离，结合事务提交的CSN序列号，确保数据读取的正确性。

       5. **锁管理器**：实现写并发控制，通过锁机制保证事务执行的隔离性。

       ### 事务并发控制

       事务并发控制机制保障并发执行下的数据库ACID属性，主要由以下部分构成：

       - **事务状态机**：分上层与底层两个层次，上层状态机通过分层设计，支持灵活处理客户端事务执行语句（BEGIN/START TRANSACTION/COMMIT/ROLLBACK/END），底层状态机记录事务具体状态，包括事务的开启、执行、结束等状态变化。

       #### 事务状态机分解

       - **事务块状态**：支持多条查询语句的事务块，包含默认、已开始、事务开始、运行中、debian源码在哪里结束状态。

       - **底层事务状态**：状态包括TRANS_DEFAULT、TRANS_START、TRANS_INPROGRESS、TRANS_COMMIT、TRANS_ABORT、TRANS_DEFAULT，分别对应事务的初始、开启、运行、提交、回滚及结束状态。

       #### 事务状态转换与实例

       通过状态机实例展示事务执行流程，包括BEGIN、SELECT、END语句的执行过程，以及相应的状态转换。

       - **BEGIN**：开始一个事务，状态从默认转为已开始，之后根据语句执行逻辑状态转换。

       - **SELECT**：查询语句执行，状态保持为已开始或运行中，事务状态不发生变化。

       - **END**：结束事务，状态从运行中或已开始转换为默认状态。

       #### 事务ID分配与日志

       事务ID（xid）以uint单调递增序列分配，用于标识每个事务，CLOG与CSNLOG分别记录事务的提交状态与序列号，采用SLRU机制管理日志，确保资源高效利用。

       ### 总结

       事务机制在openGauss数据库中起着核心作用，通过详细的架构设计与状态管理，确保了数据操作的ACID属性，支持高并发环境下的高效、一致的数据处理。MVCC与事务ID的合理使用，进一步提升了数据库的性能与数据一致性。未来，标准查询系统源码将深入探讨事务并发控制的MVCC可见性判断机制与进程内的多线程管理机制，敬请期待。

@Transactional 详解

       @Transactional 是声明式事务管理编程中使用的注解

       1. 添加位置

       1）接口实现类或接口实现方法上，而不是接口类中。2）访问权限：public 的方法才起作用。@Transactional 注解应该只被应用到 public 方法上，这是由 Spring AOP 的本质决定的。系统设计：将标签放置在需要进行事务管理的方法上，而不是放在所有接口实现类上：只读的接口就不需要事务管理，由于配置了@Transactional就需要AOP拦截及事务的处理，可能影响系统性能。

       3）错误使用：

       1. 接口中A、B两个方法，A无@Transactional标签，B有，上层通过A间接调用B，此时事务不生效。2. 接口中异常（运行时异常）被捕获而没有被抛出。默认配置下，spring 只有在抛出的异常为运行时 unchecked 异常时才回滚该事务，也就是抛出的异常为RuntimeException 的子类(Errors也会导致事务回滚)，而抛出 checked 异常则不会导致事务回滚。可通过 @Transactional rollbackFor进行配置。3. 多线程下事务管理因为线程不属于 spring 托管，故线程不能默认使用 spring 的事务，也不能获取spring 注入的 bean。在被 spring 声明式事务管理的方法内开启多线程，多线程内的方法不被事务控制。一个使用了@Transactional 的方法，如果方法内包含多线程的使用，方法内部出现异常，不会回滚线程中调用方法的事务。

       2. 声明式事务管理实现方式：基于 tx 和 aop 名字空间的 xml 配置文件

       // 基本配置 // MyBatis 自动参与到 spring 事务管理中，无需额外配置，只要 org.mybatis.spring.SqlSessionFactoryBean 引用的数据源与 DataSourceTransactionManager 引用的数据源一致即可，否则事务管理会不起作用。 // 标签的声明，是在 Spring 内部启用 @Transactional 来进行事务管理，使用 @Transactional 前需要配置。

       3. @Transactional注解 @Transactional 实质是使用了 JDBC 的事务来进行事务控制的 @Transactional 基于 Spring 的动态代理的机制

       @Transactional 实现原理：1) 事务开始时，通过AOP机制，生成一个代理connection对象，并将其放入 DataSource 实例的某个与 DataSourceTransactionManager 相关的某处容器中。在接下来的整个事务中，客户代码都应该使用该 connection 连接数据库，执行所有数据库命令。[不使用该 connection 连接数据库执行的数据库命令，在本事务回滚的时候得不到回滚]（物理连接 connection 逻辑上新建一个会话session； DataSource 与 TransactionManager 配置相同的数据源）2) 事务结束时，回滚在第1步骤中得到的代理 connection 对象上执行的数据库命令，然后关闭该代理 connection 对象。（事务结束后，回滚操作不会对已执行完毕的SQL操作命令起作用）

       4. 声明式事务的管理实现本质：事务的两种开启方式：显示开启 start transaction | begin，通过 commit | rollback 结束事务 关闭数据库中自动提交 autocommit set autocommit = 0；MySQL 默认开启自动提交；通过手动提交或执行回滚操作来结束事务

       Spring 关闭数据库中自动提交：在方法执行前关闭自动提交，方法执行完毕后再开启自动提交

       // org.springframework.jdbc.datasource.DataSourceTransactionManager.java 源码实现 // switch to manual commit if necessary. this is very expensive in some jdbc drivers, // so we don't want to do it unnecessarily (for example if we've explicitly // configured the connection pool to set it already). if (con.getautocommit()) { txobject.setmustrestoreautocommit(true); if (logger.isdebugenabled()) { logger.debug("switching jdbc connection [" + con + "] to manual commit"); } con.setautocommit(false); }

       问题：

       关闭自动提交后，若事务一直未完成，即未手动执行 commit 或 rollback 时如何处理已经执行过的SQL操作？

       C3P0 默认的策略是回滚任何未提交的事务 C3P0 是一个开源的JDBC连接池，它实现了数据源和 JNDI 绑定，支持 JDBC3 规范和 JDBC2 的标准扩展。目前使用它的开源项目有 Hibernate，Spring等 JNDI(Java Naming and Directory Interface,Java命名和目录接口)是SUN公司提供的一种标准的Java命名系统接口，JNDI提供统一的客户端API，通过不同的访问提供者接口JNDI服务供应接口(SPI)的实现，由管理者将JNDI API映射为特定的命名服务和目录系统，使得Java应用程序可以和这些命名服务和目录服务之间进行交互

       ------------------------------------------------------------------------------------------------------------------------------- 5. spring 事务特性 spring 所有的事务管理策略类都继承自 org.springframework.transaction.PlatformTransactionManager 接口

       public interface PlatformTransactionManager { TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException; void commit(TransactionStatus status) throws TransactionException; void rollback(TransactionStatus status) throws TransactionException; }

       事务的隔离级别：是指若干个并发的事务之间的隔离程度

       1. @Transactional(isolation = Isolation.READ_UNCOMMITTED)：读取未提交数据(会出现脏读, 不可重复读) 基本不使用 2. @Transactional(isolation = Isolation.READ_COMMITTED)：读取已提交数据(会出现不可重复读和幻读) 3. @Transactional(isolation = Isolation.REPEATABLE_READ)：可重复读(会出现幻读) 4. @Transactional(isolation = Isolation.SERIALIZABLE)：串行化

       事务传播行为：如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为

       1. TransactionDefinition.PROPAGATION_REQUIRED： 如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。这是默认值。2. TransactionDefinition.PROPAGATION_REQUIRES_NEW： 创建一个新的事务，如果当前存在事务，则把当前事务挂起。3. TransactionDefinition.PROPAGATION_SUPPORTS： 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。4. TransactionDefinition.PROPAGATION_NOT_SUPPORTED： 以非事务方式运行，如果当前存在事务，则把当前事务挂起。5. TransactionDefinition.PROPAGATION_NEVER： 以非事务方式运行，如果当前存在事务，则抛出异常。6. TransactionDefinition.PROPAGATION_MANDATORY： 如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。7. TransactionDefinition.PROPAGATION_NESTED： 如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。

       上表字段说明：

       1. value ：主要用来指定不同的事务管理器；主要用来满足在同一个系统中，存在不同的事务管理器。比如在Spring中，声明了两种事务管理器txManager1, txManager2。然后，用户可以根据这个参数来根据需要指定特定的txManager。2. value 适用场景：在一个系统中，需要访问多个数据源或者多个数据库，则必然会配置多个事务管理器。3. REQUIRED_NEW：内部的事务独立运行，在各自的作用域中，可以独立的回滚或者提交；而外部的事务将不受内部事务的回滚状态影响。4. ESTED 的事务，基于单一的事务来管理，提供了多个保存点。这种多个保存点的机制允许内部事务的变更触发外部事务的回滚。而外部事务在混滚之后，仍能继续进行事务处理，即使部分操作已经被混滚。由于这个设置基于 JDBC 的保存点，所以只能工作在 JDB C的机制。5. rollbackFor：让受检查异常回滚；即让本来不应该回滚的进行回滚操作。6. noRollbackFor：忽略非检查异常；即让本来应该回滚的不进行回滚操作。

一文带你掌握Spring事务核心：TransactionDefinition详解！

       TransactionDefinition是Spring框架中定义事务属性的核心接口。此接口允许开发者自定义事务的特性，包括隔离级别、传播行为、超时时间以及是否只读。

       基本介绍

       TransactionDefinition接口包含的主要方法包括设置隔离级别、传播行为、超时时间以及是否只读等属性，提供统一和灵活的事务配置。

       场景介绍：电商系统订单处理

       电商系统中，订单处理通常需要在数据库中创建订单记录、更新库存和付款状态，这些操作必须在事务中完成，以确保数据一致性。通过TransactionDefinition，可以定义隔离级别为READ_COMMITTED，传播行为为REQUIRES_NEW，配置适合的场景。

       场景介绍：银行转账系统

       银行转账系统要求从一个账户扣款至另一个账户的全过程是一个原子操作。如果扣款后存款失败，整个转账应回滚。在此场景中，TransactionDefinition可配置隔离级别为SERIALIZABLE，传播行为为REQUIRES_NEW，确保数据一致性。

       场景介绍：内容管理系统发布文章

       内容管理系统发布文章涉及数据库操作，包括创建文章记录、更新作者统计信息和发送通知等，这些操作需在一个事务中执行。TransactionDefinition配置可定义隔离级别、传播行为等，确保数据一致性。

       代码案例：简单银行转账系统

       在开发银行转账系统时，使用Spring框架的事务管理功能。通过TransactionDefinition设置事务属性，如隔离级别、传播行为等。核心代码包含创建DefaultTransactionDefinition，配置事务属性，通过PlatformTransactionManager获取事务状态，执行数据库操作，并根据结果提交或回滚事务。

       源码解读：TransactionDefinition核心方法与变量

       TransactionDefinition接口包含核心方法如设置属性、获取状态等，其中具体功能以实际实现为准。理解这些方法及变量对于正确使用TransactionDefinition至关重要。

       核心总结

       TransactionDefinition是Spring框架中定义事务属性的关键接口，提供标准化的事务管理方式。通过设置隔离级别、传播行为、超时时间和只读属性，确保数据在并发场景下的完整性和一致性。结合PlatformTransactionManager，TransactionDefinition在构建高效、安全的企业级应用中发挥关键作用。正确使用TransactionDefinition能显著提高系统性能与数据安全性。

BoltDB源码解析（二）事务

       最近几天一直在研究BoltDB的代码，现在对它有了更深入的了解。这篇主要介绍BoltDB的事务处理。

       BoltDB的事务主要分为两类：一类是只读事务，另一类是读写事务。只读事务仅允许读取操作，而读写事务则可以同时进行读取和写入操作。在并发控制方面，BoltDB允许任意多个只读事务同时进行，但读写事务只能有一个。

       BoltDB支持一定程度的多版本并发控制（MVCC），这意味着读事务不会阻塞写事务，反之亦然。在程序运行过程中，你可能会发现多个读事务和一个写事务在同时进行。

       只读事务是通过db.View方法执行的，具体代码如下：

       Bolt的注释非常清晰，每一步都标明了具体操作。db.begin是新建一个transaction，而fn参数是用户传递的事务主体函数。

       注意，只读事务不会调用transaction的commit函数，除非发生error，此时需要调用t.Rollback()进行清理工作。

       读写事务是通过db.update执行的，整体上和View的代码类似，但是会创建一个读写事务。

       读写事务如果没有发生错误，最后会调用Commit方法，将事务进行的修改持久化到DB文件里，实现事务ACID特性里的“D"。

       BoltDB使用B-tree作为磁盘数据结构，在事务commit时，所有在内存中的修改都要持久化到磁盘上。在事务commit时，所有修改都需要持久化到多个新page里。

       读事务实现得比较简单，就是在基于mmap的B-tree上搜索到具体的key，返回对应的value。为了提升性能，BoltDB全程尽量避免copy。

       写事务比读事务要复杂，BoltDB如果需要修改一个page上的数据，首先会通过B-tree搜索定位到具体的key所在的leaf page，但它不会直接在这个page上修改，而是把这个page的数据copy到一个叫node的内存结构体里，修改是在node结构体里做的。

       在写事务中，所有的修改都暂存在内存里，在事务commit之前不会持久化。在事务commit的时候，所有的修改都要持久化。

       因此，BoltDB的使用建议是，一个事务做的事情不要太多，这样不必耗费太多内存保存中间状态，commit也不至于耗时太多。

spring—AOP与事务

        title: spring——AOP与事务.md

        date: -- ::

        categories: [Spring]

        tags: [AOP,事务]

        toc: true

        先列出源码中比较重点的几个类：

        1、<aop:before method="before" pointcut-ref="myMethods"/>包装成一个advisor

        2、AspectJAwareAdvisorAutoProxyCreator，当实例化所有bean都会执行到AspectJAwareAdvisorAutoProxyCreatorç±»

        它会检测bean是否advisor以及advice存在，如果有就说明这个bean有切面，有切面那么就会生成代理

        3、jdk的代理，bean里面的所有advisor加入到proxyFactory。

        4、jdkDynamicProxy invoke，拿到bean里面的所有Interceptor，会循环proxyFactory里面的所有advisor

        里面有advice，里面的advice有两种类型，要么是advice，要么是MethodInterceptor类型的

        5、当代理对象调用方式，是一个MethodInterceptor类型的类的链式调用过程，直到容器的大小和索引一致的时候调用JoinPoint目标方法

        before：this.advice.before(),invocation.processd();

        装配参数，切面里面before方法的method对象，method.getParamterTypes()[0]

        最终会把advice封装成MethodInterceptor类型的对象

        程序执行的某个特定位置：如类开始初始化前、类初始化后、类某个方法调用前、调用后、方法抛出异常后。一个类或一段程序代码拥有一些具有边界性质的特定点，这些点中的特定点就称为“连接点”。Spring仅支持方法的连接点，即仅能在方法调用前、方法调用后、方法抛出异常时以及方法调用前后这些程序执行点织入增强。连接点由两个信息确定：第一是用方法表示的程序执行点；第二是用相对点表示的方位。

        每个程序类都拥有多个连接点，如一个拥有两个方法的类，这两个方法都是连接点，即连接点是程序类中客观存在的事物。AOP通过“切点”定位特定的连接点。连接点相当于数据库中的记录，而切点相当于查询条件。切点和连接点不是一对一的关系，一个切点可以匹配多个连接点。在Spring中，切点通过org.springframework.aop.Pointcut接口进行描述，它使用类和方法作为连接点的查询条件，Spring AOP的规则解析引擎负责切点所设定的查询条件，找到对应的连接点。其实确切地说，不能称之为查询连接点，因为连接点是方法执行前、执行后等包括方位信息的具体程序执行点，而切点只定位到某个方法上，所以如果希望定位到具体连接点上，还需要提供方位信息。

        增强是织入到目标类连接点上的一段程序代码，在Spring中，增强除用于描述一段程序代码外，还拥有另一个和连接点相关的信息，这便是执行点的方位。结合执行点方位信息和切点信息，我们就可以找到特定的连接点。

        增强逻辑的织入目标类。如果没有AOP，目标业务类需要自己实现所有逻辑，而在AOP的帮助下，目标业务类只实现那些非横切逻辑的程序逻辑，而性能监视和事务管理等这些横切逻辑则可以使用AOP动态织入到特定的连接点上。

        引介是一种特殊的增强，它为类添加一些属性和方法。这样，即使一个业务类原本没有实现某个接口，通过AOP的引介功能，我们可以动态地为该业务类添加接口的实现逻辑，让业务类成为这个接口的实现类。

        织入是将增强添加对目标类具体连接点上的过程。AOP像一台织布机，将目标类、增强或引介通过AOP这台织布机天衣无缝地编织到一起。根据不同的实现技术，AOP有三种织入的方式：

        a、编译期织入，这要求使用特殊的Java编译器。

        b、类装载期织入，这要求使用特殊的类装载器。

        c、动态代理织入，在运行期为目标类添加增强生成子类的方式。

        Spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。

        一个类被AOP织入增强后，就产出了一个结果类，它是融合了原类和增强逻辑的代理类。根据不同的代理方式，代理类既可能是和原类具有相同接口的类，也可能就是原类的子类，所以我们可以采用调用原类相同的方式调用代理类。

        切面由切点和增强（引介）组成，它既包括了横切逻辑的定义，也包括了连接点的定义，Spring AOP就是负责实施切面的框架，它将切面所定义的横切逻辑织入到切面所指定的连接点中。

        advisor： pointCut advice

        一类功能的增强

        around方法里面代码切面

        事务切面

        缓存切面

        日志切面

        事务（Transaction），一般是指要做的或所做的事情。在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。是数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列操作；这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行；事务是一组不可再分割的操作集合（工作逻辑单元）。

        大致流程形如

        数据库事务拥有几大特性：

        事务的四大特性：

        事务是数据库的逻辑工作单位，事务中包含的各操作要么都做，要么都不做

        事 务执行的结果必须是使数据库从一个一致性状态变到另一个一致性状态。因此当数据库只包含成功事务提交的结果时，就说数据库处于一致性状态。如果数据库系统 运行中发生故障，有些事务尚未完成就被迫中断，这些未完成事务对数据库所做的修改有一部分已写入物理数据库，这时数据库就处于一种不正确的状态，或者说是 不一致的状态。

        一个事务的执行不能其它事务干扰。即一个事务内部的操作及使用的数据对其它并发事务是隔离的，并发执行的各个事务之间不能互相干扰。

        也称永久性，指一个事务一旦提交，它对数据库中的数据的改变就应该是永久性的。接下来的其它操作或故障不应该对其执行结果有任何影响。

        个人理解，事务在Spring中是借助AOP技术来实现的，可以作为AOP中的一个事务切面。spring源码对事务的处理逻辑，自己研究吧！

        ORM框架中以Mybatis为例，事务处理就是用到了一个类Transaction，部分源码如下

        可以看出Transaction管理的就是一个connection，而connection我们很清楚是与用户会话挂钩的。

        那么关系就是Transaction 管理Connection ，而connection与 用户session一对一存在。

        在springBoot中，只需要加入POM就可以了，配合注解使用即可。

        接下来就是事务的控制了。

        首先事务有几大传播属性：

        其中最常见的，用得最多就 PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、 PROPAGATION_NESTED 这三种。事务的传播属性是 spring 特有的，是 spring 用来控制方法事务的一种手段，说直白点就是用来控制方法是否使用同一事务的一种属性，以及按照什么规则回滚的一种手段。

        下面用代码演示这三种属性的机制：

        事务的默认属性就是required，通过Transactional.java中的Propagation propagation() default Propagation.REQUIRED; 可以看出。

        这种情况就是事务1，事务2 都加入到了事务0中。不管是1，2哪个事务抛出异常，事务0都会回滚。数据添加会失败。

        这种情况就是：

        事务0（required） {

        ​ 事务1 （REQUIRES_NEW）

        ​ 事务2

        }

        此时。

        情况a：

        1、如果只是事务2出现了异常，那么事务1会提交，事务2加入到事务0中会回滚。

        2、如果只是事务1出现了异常，那么事务1会回滚，向上层事务0抛异常，事务2会加入到事务0中，这时都会回滚。

        情况b：

        如果事务1，事务2都是REQUIRES_NEW传播属性。那么结果就是：

        1、如果事务1，抛出了异常，那么事务2是不会执行的，那么事务0必然回滚。

        2、如果事务2，抛出异常，那么事务1会提交，表中会有数据。事务2有异常回滚并抛出，事务0回滚。

        NESTED属性其实就是创建了回滚点，有异常时，会回滚到指定的回滚点。

        在这通过代码测试，出现一种情况是，无论事务1，事务2哪个有异常，数据都不会插入成功，原因是，不论是事务1还是事务2都会向事务0抛出异常，事务0捕获到异常后，执行rollback()方法，这就操作成了，事务的全部回滚。

        如果想要事务1和事务2 想要根据自己的回滚点回滚，那么事务0必须自己处理异常，不让spring捕获到这个异常，那么就满足了。把代码改成这种：

        Jack大佬提供了，伪代码分析法。

        按照Spring源码的事务处理逻辑，伪代码大致为：