前言

在实际项目开发中，难免遇到Service之间的相互嵌套。如何控制这些嵌套Service的事务，则涉及到SpringFramework的事务传播行为。

10.5 声明式事务的传播行为控制

事务传播行为指的是外层事务传播到内层事务后，内层事务做出的行为。

SpringFramework通过事务传播行为可以控制一个Service中的事务传播到另一个Service方法中的方式。SpringFramework在TransactionDefinition类中定义了7种传播行为：

源码1：TransactionDefinition.javaint PROPAGATION_REQUIRED = 0;
int PROPAGATION_SUPPORTS = 1;
int PROPAGATION_MANDATORY = 2;
int PROPAGATION_REQUIRES_NEW = 3;
int PROPAGATION_NOT_SUPPORTED = 4;
int PROPAGATION_NEVER = 5;
int PROPAGATION_NESTED = 6;

这7种传播行为的含义分别是：

• PROPAGATION_REQUIRED：必需的。如果当前没有事务运行，则会开启一个新的事务；如果当前已有事务运行，则方法会运行在当前事务中。
• PROPAGATION_SUPPORTS：支持。如果当前没有事务运行，则方法也不会运行在事务中；如果当前已有事务运行，则方法也会运行在当前事务中。
• PROPAGATION_MANDATORY：强制。当前方法必须运行在事务中，如果没有事务则抛出异常。
• PROPAGATION_REQUIRES_NEW：新事务。如果当前没有事务运行，则会开启一个新的事务；如果当前已有事务运行，则会将该事务挂起（暂停），重新开启一个事务。当新的事务运行完毕后，释放原来的事务。
• PROPAGATION_NOT_SUPPORTED：不支持。如果当前没有事务运行，则方法也不运行在事务中；如果当前已有事务运行，则会将该事务挂起（暂停）。
• PROPAGATION_NEVER：不允许。当前方法不允许运行在事务中，如果有事务则抛出异常。
• PROPAGATION_NESTED：嵌套。如果当前没有事务运行，则会开启一个新的事务；如果当前已有事务运行，则会记录一个保存点，方法继续运行在当前事务中。如果方法出现异常，则不会全部回滚，而是回滚到上一个保存点。

简单总结如下：

	REQUIRED	SUPPORTS	MANDATORY	REQUIRES_NEW	NOT_SUPPORTED	NEVER	NESTED
已有事务运行	运行当前事务	运行当前事务	运行当前事务	挂起原事务，开启新事务；新事务运行完后释放原事务	挂起原事务，然后不运行事务	抛出异常	记录保存点，继续运行当前事务，如果出现异常则回滚到保存点
没有事务运行	开启新事务	不运行事务	抛出异常	开启新事务	不运行事务	不运行事务	开启新事务

10.5.1 修改测试代码

（1）新建一个Service类，并引用UserService

@Service
public class DeptService {@Autowiredprivate UserService userService;@Transactional(rollbackFor = Exception.class)public void save() {System.out.println("DeptService.save 执行了...");userService.test();}
}

通过引用UserService，实现Service的嵌套。

（2）修改主启动类

@SpringBootApplication
@EnableTransactionManagement
public class JDBCApp {public static void main(String[] args) {ConfigurableApplicationContext context = SpringApplication.run(JDBCApp.class, args);DeptService deptService = context.getBean(DeptService.class);deptService.save();}}

10.5.2 PROPAGATION_REQUIRED

默认情况下，标注@Transactional注解对应的事务传播行为是PROPAGATION_REQUIRED，这种传播行为的特征是执行Service方法时必定确保事务的开启。

创建事务的位置是TransactionAspectSupport类的invokeWithinTransaction方法。

源码2：TransactionAspectSupport.javaprotected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,final InvocationCallback invocation) throws Throwable {// ......PlatformTransactionManager ptm = asPlatformTransactionManager(tm);final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {// 创建事务TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);//......} // else ......
}

源码3：TransactionAspectSupport.javaprotected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,@Nullable TransactionAttribute txAttr, final String joinpointIdentification) {// 如果事务定义中没有指定name，则将方法名作为事务定义nameif (txAttr != null && txAttr.getName() == null) {txAttr = new DelegatingTransactionAttribute(txAttr) {@Overridepublic String getName() {return joinpointIdentification;}};}TransactionStatus status = null;if (txAttr != null) {if (tm != null) {// 获取事务定义信息对应的事务状态status = tm.getTransaction(txAttr);} else {// logger ...}}// 构建事务信息return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
}

由 源码3 可知，createTransactionIfNecessary方法有两个核心动作：根据事务定义信息获取事务状态，以及获取事务状态后事务信息构建。

10.5.2.1 tm.getTransaction

事务管理器的getTransaction方法定义在DataSourceTransactionManager的父类AbstractPlatformTransactionManager中。这个方法的篇幅很长，下面拆解来看。

（1）获取事务

源码4：AbstractPlatformTransactionManager.javapublic final TransactionStatus getTransaction(@Nullable TransactionDefinition definition)throws TransactionException {// 如果没有给定事务定义信息，则使用默认的TransactionDefinition def = (definition != null ? definition : TransactionDefinition.withDefaults());// （1）获取事务Object transaction = doGetTransaction();boolean debugEnabled = logger.isDebugEnabled();// ......
}

由 源码4 可知，getTransaction方法首先会转调do开头的doGetTransaction方法获取事务。该方法本身是一个模板方法，它的实现定义在DataSourceTransactionManager中。

源码5：DataSourceTransactionManager.javaprotected Object doGetTransaction() {// 创建DataSourceTransactionObject对象DataSourceTransactionObject txObject = new DataSourceTransactionObject();txObject.setSavepointAllowed(isNestedTransactionAllowed());// 组合ConnectionHolder对象ConnectionHolder conHolder =(ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());txObject.setConnectionHolder(conHolder, false);return txObject;
}

由 源码5 可知，doGetTransaction方法会创建并返回一个DataSourceTransactionObject对象，该对象内部包含了一个ConnectionHolder，而ConnectionHolder内部又组合了一个Connection对象。

换句话说，doGetTransaction方法执行后，返回了一个Connection对象。

（2）当前已有事务时的传播行为处理

源码6：AbstractPlatformTransactionManager.javapublic final TransactionStatus getTransaction(@Nullable TransactionDefinition definition)throws TransactionException {// （1）获取事务 ...// （2）当前已有事务时的传播行为处理if (isExistingTransaction(transaction)) {return handleExistingTransaction(def, transaction, debugEnabled);}// ......
}

由于在执行DeptService的save方法之前，当前线程还没有开启事务，因此该if判断的结果为false，不会进入handleExistingTransaction方法。

（3）超时检测

源码7：AbstractPlatformTransactionManager.javapublic final TransactionStatus getTransaction(@Nullable TransactionDefinition definition)throws TransactionException {// （1）获取事务 ...// （2）当前已有事务时的传播行为处理 ...// （3）超时检测if (def.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());}// ......
}

由 源码7 可知，接着的if结构进行超时校验，实际上就是校验@Transactional注解中的timeout属性。

SpringFramework支持的事务模型可以显式设置事务方法最长执行时间（@Transactional注解中的timeout属性），当方法的执行时间超过该时间，则会抛出异常。

默认情况下，timeout属性的值为-1，表示不限制事务方法的执行时间。这里的if结构判断显式设置的timeout属性值小于-1时，说明值本身设置不合理，抛出异常。

（4）当前事务不存在时的传播行为处理

源码8：AbstractPlatformTransactionManager.javapublic final TransactionStatus getTransaction(@Nullable TransactionDefinition definition)throws TransactionException {// （1）获取事务 ...// （2）外部事务已存在时的逻辑// （3）超时检测// （4）当前事务不存在时的传播行为处理if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {// 传播行为：PROPAGATION_MANDATORY// 强制要求方法运行在事务中，由于此时线程中没有事务，因此抛出异常// throw ...} else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {// 传播行为：PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、PROPAGATION_NESTED// 如果当前线程中没有事务，则开启一个新的事务SuspendedResourcesHolder suspendedResources = suspend(null);// logger ...try {// 开启一个新的事务return startTransaction(def, transaction, debugEnabled, suspendedResources);} // catch ...} else {// 剩余的传播行为：PROPAGATION_SUPPORTS、PROPAGATION_NOT_SUPPORTED、PROPAGATION_NEVER// 如果当前线程没有事务，则方法也不运行在事务中// logger ...boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);}
}

由 源码8 可知，getTransaction方法的第4部分逻辑是当前事务不存在时的传播行为处理。程序进入该部分源码，说明当前线程中没有开启事务，事实上也是如此，源码根据事务定义中配置的事务传播行为分别了做了不同处理。

• 传播行为是PROPAGATION_MANDATORY时，强制要求方法运行在事务中，由于此时线程中没有事务，因此抛出异常。
• 传播行为是PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、PROPAGATION_NESTED时，如果当前线程中没有事务，则开启一个新的事务（通过startTransaction方法）。
• 传播行为是PROPAGATION_SUPPORTS、PROPAGATION_NOT_SUPPORTED、PROPAGATION_NEVER时，如果当前线程没有事务，则方法也不运行在事务中，因此不作任何处理。

由于SpringFramework默认的事务传播行为是PROPAGATION_REQUIRED，因此程序会进行else-if结构中，通过startTransaction方法开启一个新事务。

（5）开启新事务：startTransaction

源码9：AbstractPlatformTransactionManager.javaprivate TransactionStatus startTransaction(TransactionDefinition definition, Object transaction,boolean debugEnabled, @Nullable SuspendedResourcesHolder suspendedResources) {boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);DefaultTransactionStatus status = newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);// 开启事务doBegin(transaction, definition);prepareSynchronization(status, definition);return status;
}

由 源码9 可知，startTransaction方法的核心动作是调用doBegin方法开启事务，该方法定义在DataSourceTransactionManager类中。

源码10：DataSourceTransactionManager.javaprotected void doBegin(Object transaction, TransactionDefinition definition) {DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;Connection con = null;try {// ......txObject.getConnectionHolder().setSynchronizedWithTransaction(true);// 从ConnectionHolder中获取到Connection对象con = txObject.getConnectionHolder().getConnection();//......if (con.getAutoCommit()) {txObject.setMustRestoreAutoCommit(true);// 设置autoCommit属性为false，关闭自动提交，开启事务con.setAutoCommit(false);}// ......} // catch ...
}

由 源码10 可知，doBegin方法的核心动作是从DataSourceTransactionObject中取出内部组合的ConnectionHolder，再从ConnectionHolder中取出组合的Connection对象，随后执行setAutoCommit(false)方法设置autoCommit属性为false，关闭自动提交，开启事务。

10.5.2.2 prepareTransactionInfo

回到 源码3 的createTransactionIfNecessary方法，getTransaction方法执行完毕后，开始执行prepareTransactionInfo方法。

源码11：TransactionAspectSupport.javaprotected TransactionInfo prepareTransactionInfo(@Nullable PlatformTransactionManager tm,@Nullable TransactionAttribute txAttr, String joinpointIdentification,@Nullable TransactionStatus status) {// 创建TransactionInfo对象TransactionInfo txInfo = new TransactionInfo(tm, txAttr, joinpointIdentification);if (txAttr != null) {// logger ...// 设置事务信息txInfo.newTransactionStatus(status);} else {// logger ...}// 绑定到当前线程中txInfo.bindToThread();return txInfo;
}

由 源码11 可知，prepareTransactionInfo方法会创建一个TransactionInfo对象，把事务状态信息放入其中，并绑定到当前线程中。

当TransactionInfo创建完毕并返回，createTransactionIfNecessary方法执行完毕，事务也就创建好了。

10.5.2.3 UserServie.test

DeptService的save方法的事务开启之后，它的内部会调用UserService的test方法，由于UserServie也是被AOP代理的代理对象，在调用其test方法时会再次进入createTransactionIfNecessary方法处理事务逻辑。

由于此时线程中已经存在事务，因此在getTransaction方法中，会进入到 源码4 的第1个if结构中，即当前已有事务时的传播行为处理（即 源码6 的handleExistingTransaction方法）。

10.5.2.4 handleExistingTransaction

（1）传播行为PROPAGATION_NEVER的处理

源码13：AbstractPlatformTransactionManager.javaprivate TransactionStatus handleExistingTransaction(TransactionDefinition definition, Object transaction, boolean debugEnabled)throws TransactionException {// （1）传播行为PROPAGATION_NEVER的处理if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {// throw ex...}// ......}

由 源码13 可知，如果是传播行为PROPAGATION_NEVER，要求线程中不能有事务，所以当线程中已有事务时，会直接抛出异常。

（2）传播行为PROPAGATION_NOT_SUPPORTED的处理

源码14：AbstractPlatformTransactionManager.javaprivate TransactionStatus handleExistingTransaction(TransactionDefinition definition, Object transaction, boolean debugEnabled)throws TransactionException {// （1）传播行为PROPAGATION_NEVER的处理...// （2）传播行为PROPAGATION_NOT_SUPPORTED的处理if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {// logger...// 挂起DeptService的save方法的事务Object suspendedResources = suspend(transaction);boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);return prepareTransactionStatus(definition, null, false, newSynchronization, debugEnabled, suspendedResources);}// ......}

由 源码14 可知，如果是传播行为PROPAGATION_NOT_SUPPORTED，要求方法不能执行在事务中，因此此处会把DeptService的save方法的事务挂起，并执行UserService的test方法。

（3）传播行为PROPAGATION_REQUIRES_NEW的处理

源码15：AbstractPlatformTransactionManager.javaprivate TransactionStatus handleExistingTransaction(TransactionDefinition definition, Object transaction, boolean debugEnabled)throws TransactionException {// （1）传播行为PROPAGATION_NEVER的处理...// （2）传播行为PROPAGATION_NOT_SUPPORTED的处理...// （3）传播行为PROPAGATION_REQUIRES_NEW的处理if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {// logger...// 挂起DeptService的save方法的事务SuspendedResourcesHolder suspendedResources = suspend(transaction);try {// 为UserService的```test```方法开启一个新的事务return startTransaction(definition, transaction, debugEnabled, suspendedResources);} catch (RuntimeException | Error beginEx) {// 如果UserService的```test```方法抛出异常，则还原外层事务resumeAfterBeginException(transaction, suspendedResources, beginEx);throw beginEx;}}// ......}

如果传播行为是PROPAGATION_REQUIRES_NEW，会挂起之前的事务，并开启一个新的事务。

由 源码15 可知，此处会把DeptService的save方法的事务挂起，并为UserService的test方法开启一个新的事务。同时，如果UserService的test方法抛出异常，则还原外层事务。

（4）传播行为PROPAGATION_NESTED的处理

源码16：AbstractPlatformTransactionManager.javaprivate TransactionStatus handleExistingTransaction(TransactionDefinition definition, Object transaction, boolean debugEnabled)throws TransactionException {// （1）传播行为PROPAGATION_NEVER的处理...// （2）传播行为PROPAGATION_NOT_SUPPORTED的处理...// （3）传播行为PROPAGATION_REQUIRES_NEW的处理...// （4）传播行为PROPAGATION_NESTED的处理if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {// 检查是否允许嵌套事务if (!isNestedTransactionAllowed()) {// throw ex...}// logger...// 检查是否支持保存点if (useSavepointForNestedTransaction()) {DefaultTransactionStatus status =prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);status.createAndHoldSavepoint();return status;} else {// 如果不支持创建保存点，则会开启一个新的事务return startTransaction(definition, transaction, debugEnabled, null);}}// ......}

如果传播行为是PROPAGATION_NESTED，则会记录一个保存点，方法继续运行在当前事务上。如果出现异常，不会全部回滚，而是回滚到上一个保存点。

由 源码16 可知，处理逻辑首先会检查是否允许嵌套事务以及是否支持保存点，如果两个条件都成立，则会创建保存点，UserService的test方法继续运行在当前事务中。

如果不支持创建保存点，则会调用startTransaction方法开启一个新的事务，相当于降级到了传播行为PROPAGATION_REQUIRES_NEW。

（5）传播行为PROPAGATION_REQUIRED和PROPAGATION_SUPPORTS的处理

源码17：AbstractPlatformTransactionManager.javaprivate TransactionStatus handleExistingTransaction(TransactionDefinition definition, Object transaction, boolean debugEnabled)throws TransactionException {// （1）传播行为PROPAGATION_NEVER的处理...// （2）传播行为PROPAGATION_NOT_SUPPORTED的处理...// （3）传播行为PROPAGATION_REQUIRES_NEW的处理...// （4）传播行为PROPAGATION_NESTED的处理...// （5）传播行为PROPAGATION_REQUIRED和PROPAGATION_SUPPORTS的处理if (isValidateExistingTransaction()) {// ...}boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);}

如果程序没有进入（1）-（4）的处理，则会进入最后的处理逻辑，即传播行为PROPAGATION_REQUIRED和PROPAGATION_SUPPORTS的处理。

由 源码17 可知，由于isValidateExistingTransaction方法默认返回false，因此不会进入if结构，而最后的两行源码是把现有的事务信息封装并返回。

10.5.3 PROPAGATION_REQUIRES_NEW

将UserService的test方法上的@Transactional注解的事务传播行为改为PROPAGATION_REQUIRES_NEW，并重新执行主启动类。

@Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
public void test() {

由 10.5.2 的分析可知，该传播行为下会进入传播行为PROPAGATION_REQUIRES_NEW的处理逻辑，在handleExistingTransaction方法中挂起之前的事务，并开启一个新的事务，即 源码15 中的逻辑。

10.5.3.1 挂起原事务：suspend

源码18：AbstractPlatformTransactionManager.javaprotected final SuspendedResourcesHolder suspend(@Nullable Object transaction) throws TransactionException {if (TransactionSynchronizationManager.isSynchronizationActive()) {List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization();try {Object suspendedResources = null;if (transaction != null) {// 事务和同步均开启，调用doSuspend方法suspendedResources = doSuspend(transaction);}// ...} // catch ...} else if (transaction != null) {// 事务开启，但同步未开启// 调用doSuspend方法Object suspendedResources = doSuspend(transaction);return new SuspendedResourcesHolder(suspendedResources);} else {// 事务和同步均未开启return null;}
}

由 源码18 可知，suspend方法会检查事务和事务同步是否已开启，如果事务开启了，不管同步是否开启，最终都会调用doSuspend方法真正挂起事务。doSuspend的实现在DataSourceTransactionManager类中。

源码19：DataSourceTransactionManager.java@Override
protected Object doSuspend(Object transaction) {DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;txObject.setConnectionHolder(null);return TransactionSynchronizationManager.unbindResource(obtainDataSource());
}

由 源码19 可知，doSuspend方法将DataSourceTransactionObject对象中的ConnectionHolder设置为null，即移除掉ConnectionHolder对象，然后解除事务同步管理器TransactionSynchronizationManager中的资源绑定。

通过Debug发现，doSuspend方法返回的是组合了Connection对象的ConnectionHolder对象。

随后，suspend继续执行，doSuspend方法返回的ConnectionHolder对象被封装成SuspendedResourcesHolder对象并返回。

10.5.3.2 开启新事务：startTransaction

源码20：AbstractPlatformTransactionManager.javaprivate TransactionStatus startTransaction(TransactionDefinition definition, Object transaction,boolean debugEnabled, @Nullable SuspendedResourcesHolder suspendedResources) {boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);// SuspendedResourcesHolder对象被存入TransactionStatusDefaultTransactionStatus status = newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);// 开启新事务doBegin(transaction, definition);prepareSynchronization(status, definition);return status;
}

由 源码20 可知，startTransaction方法的最后一个参数就是上一步返回的SuspendedResourcesHolder对象，该对象被存入了TransactionStatus中，随后调用doBegin方法开启新事务。

这样做的目的是，当内层新事务执行完成后清理相关的线程同步等信息时，可以从事务状态信息中提取出被挂起的事务，然后恢复外层事务。

10.5.3.3 内层新事务执行完成后的处理

在 SpringBoot源码解读与原理分析(三十三)SpringBoot整合JDBC(二)声明式事务的生效原理和控制流程 10.4.2.5 事务执行的后处理 中提到，无论是成功提交事务（processCommit方法）还是回滚事务（processRollback方法），最终都会执行一个cleanupAfterCompletion方法。

源码21：AbstractPlatformTransactionManager.javaprivate void cleanupAfterCompletion(DefaultTransactionStatus status) {status.setCompleted();// 组件资源清除if (status.isNewSynchronization()) {TransactionSynchronizationManager.clear();}if (status.isNewTransaction()) {doCleanupAfterCompletion(status.getTransaction());}// 释放挂起的事务if (status.getSuspendedResources() != null) {// logger ...Object transaction = (status.hasTransaction() ? status.getTransaction() : null);resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources());}
}protected final void resume(@Nullable Object transaction, @Nullable SuspendedResourcesHolder resourcesHolder)throws TransactionException {if (resourcesHolder != null) {// 取出其中的ConnectionHolder对象Object suspendedResources = resourcesHolder.suspendedResources;if (suspendedResources != null) {doResume(transaction, suspendedResources);}// ......}
}

由 源码21 可知，前两个if结构与组件资源清除相关，最后一个if结构用于释放挂起的事务。在resume方法中，取出SuspendedResourcesHolder对象中封装的ConnectionHolder对象，并调用doResume方法真正地释放事务。

源码22：DataSourceTransactionManager.java@Override
protected void doResume(@Nullable Object transaction, Object suspendedResources) {TransactionSynchronizationManager.bindResource(obtainDataSource(), suspendedResources);
}

由 源码22 可知，doResume方法会将ConnectionHolder对象重新绑定到事务同步管理器TransactionSynchronizationManager中。

可以发现，doResume方法的逻辑和doSuspend方法的逻辑是相反的，doResume方法中的是bindResource方法，而doSuspend方法中的是unbindResource方法。

等resume方法执行完毕，原来的外层事务又重新被绑定到线程上，相当于恢复了被挂起之前的状态。

10.6 小结

第10章到此就梳理完毕了，本章的主题是：SpringBoot整合JDBC。回顾一下本章的梳理的内容：

(三十二)SpringBoot整合JDBC(一)JDBC组件的自动装配
(三十二)SpringBoot整合JDBC(二)声明式事务的生效原理和控制流程
(三十四)SpringBoot整合JDBC(三)声明式事务的传播行为控制

更多内容请查阅分类专栏：SpringBoot源码解读与原理分析

第11章主要梳理：SpringBoot整合MyBatis。主要内容包括：

• MyBatis框架概述与工程整合；
• SpringBoot整合MyBatis的核心组件自动装配。