文章目录
前言
有时候我们开发需求的过程中写单测，会往数据库里插入数据，但是这样的数据其实是没有意义的，要么测试数据中含有唯一主键，每次run之前都要改单测里的参数，要么，有时候公司上线的流水线会跑一遍单测，给数据库多次插入无意义的数据。那么我们就需要让单测在run完之后可以自动回滚。
一、问题
如果保证单测插入到数据库的数据回滚？
二、回答
最简单的方式就是在方法上加上@Transactional注解了
三、源码分析
1.TestContextManager
{@code TestContextManager} is the main entry point into the <em>Spring
* TestContext Framework</em>.
TestContextManager是Spring测试框架的主要进入点
*
* <p>Specifically, a {@code TestContextManager} is responsible for managing a
* single {@link TestContext} and signaling events to all registered
* {@link TestExecutionListener TestExecutionListeners} at the following test
<p>具体来说，{@code TestContextManager} 负责管理单个 {@link TestContext} 并在以下测试中向所有注册的 {@link TestExecutionListener TestExecutionListeners} 发送信号事件
根据上面的Java doc，我们便知道了两个重要的概念
TestContext 和 TestExecutionListener
剩下的就是listener和testContext的交互了
2.TestContext
{@code TestContext} encapsulates the context in which a test is executed,
* agnostic of the actual testing framework in use.
{@code TestContext} 封装了执行测试的上下文，与使用的实际测试框架无关。
可以来看看默认实现DefaultTestContext
public class DefaultTestContext implements TestContext {
private final Map<String, Object> attributes = new ConcurrentHashMap<>(4);
private final CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate;
private final MergedContextConfiguration mergedContextConfiguration;
private final Class<?> testClass;
@Nullable
private volatile Object testInstance;
@Nullable
private volatile Method testMethod;
@Nullable
private volatile Throwable testException;
}
对于我们一般的方法，最重要的其实就是testClass和testMethod
3.TestExecutionListener
3.1 AbstractTestContextBootstrapper#getTestExecutionListeners
testExecutionListeners是通过SpringFactory从spring.factories文件里的配置加载进来的
其中包含了我们本文关注的TransactionalTestExecutionListener
对于从spring.factories中加载配置类不熟悉的同学，可以参考这篇博客
3.2 钩子函数
其实钩子函数可以理解为静态AOP，也可以理解为spring框架开放给用户在某个时间点实现某些功能的扩展点。在spring源码里特别常见，譬如spring里的各种postProcessor的接口实现类，里面其实没有方法逻辑，用户可以通过自定义这些接口来在spring的bean的生命周期内对bean的实现进行个性化。
言归正传，咱们还是来看TestExecutionListener的钩子函数
/**
* Pre-processes a test class <em>before</em> execution of all tests within
* the class.
* <p>This method should be called immediately before framework-specific
* <em>before class</em> lifecycle callbacks.
* <p>The default implementation is <em>empty</em>. Can be overridden by
* concrete classes as necessary.
* @param testContext the test context for the test; never {@code null}
* @throws Exception allows any exception to propagate
* @since 3.0
*/
default void beforeTestClass(TestContext testContext) throws Exception {
/* no-op */
}
/**
* Prepares the {@link Object test instance} of the supplied
* {@link TestContext test context}, for example by injecting dependencies.
* <p>This method should be called immediately after instantiation of the test
* instance but prior to any framework-specific lifecycle callbacks.
* <p>The default implementation is <em>empty</em>. Can be overridden by
* concrete classes as necessary.
* @param testContext the test context for the test; never {@code null}
* @throws Exception allows any exception to propagate
*/
default void prepareTestInstance(TestContext testContext) throws Exception {
/* no-op */
}
/**
* Pre-processes a test <em>before</em> execution of <em>before</em>
* lifecycle callbacks of the underlying test framework — for example,
* by setting up test fixtures.
* <p>This method <strong>must</strong> be called immediately prior to
* framework-specific <em>before</em> lifecycle callbacks. For historical
* reasons, this method is named {@code beforeTestMethod}. Since the
* introduction of {@link #beforeTestExecution}, a more suitable name for
* this method might be something like {@code beforeTestSetUp} or
* {@code beforeEach}; however, it is unfortunately impossible to rename
* this method due to backward compatibility concerns.
* <p>The default implementation is <em>empty</em>. Can be overridden by
* concrete classes as necessary.
* @param testContext the test context in which the test method will be
* executed; never {@code null}
* @throws Exception allows any exception to propagate
* @see #afterTestMethod
* @see #beforeTestExecution
* @see #afterTestExecution
*/
default void beforeTestMethod(TestContext testContext) throws Exception {
/* no-op */
}
/**
* Pre-processes a test <em>immediately before</em> execution of the
* {@link java.lang.reflect.Method test method} in the supplied
* {@link TestContext test context} — for example, for timing
* or logging purposes.
* <p>This method <strong>must</strong> be called after framework-specific
* <em>before</em> lifecycle callbacks.
* <p>The default implementation is <em>empty</em>. Can be overridden by
* concrete classes as necessary.
* @param testContext the test context in which the test method will be
* executed; never {@code null}
* @throws Exception allows any exception to propagate
* @since 5.0
* @see #beforeTestMethod
* @see #afterTestMethod
* @see #afterTestExecution
*/
default void beforeTestExecution(TestContext testContext) throws Exception {
/* no-op */
}
/**
* Post-processes a test <em>immediately after</em> execution of the
* {@link java.lang.reflect.Method test method} in the supplied
* {@link TestContext test context} — for example, for timing
* or logging purposes.
* <p>This method <strong>must</strong> be called before framework-specific
* <em>after</em> lifecycle callbacks.
* <p>The default implementation is <em>empty</em>. Can be overridden by
* concrete classes as necessary.
* @param testContext the test context in which the test method will be
* executed; never {@code null}
* @throws Exception allows any exception to propagate
* @since 5.0
* @see #beforeTestMethod
* @see #afterTestMethod
* @see #beforeTestExecution
*/
default void afterTestExecution(TestContext testContext) throws Exception {
/* no-op */
}
/**
* Post-processes a test <em>after</em> execution of <em>after</em>
* lifecycle callbacks of the underlying test framework — for example,
* by tearing down test fixtures.
* <p>This method <strong>must</strong> be called immediately after
* framework-specific <em>after</em> lifecycle callbacks. For historical
* reasons, this method is named {@code afterTestMethod}. Since the
* introduction of {@link #afterTestExecution}, a more suitable name for
* this method might be something like {@code afterTestTearDown} or
* {@code afterEach}; however, it is unfortunately impossible to rename
* this method due to backward compatibility concerns.
* <p>The default implementation is <em>empty</em>. Can be overridden by
* concrete classes as necessary.
* @param testContext the test context in which the test method was
* executed; never {@code null}
* @throws Exception allows any exception to propagate
* @see #beforeTestMethod
* @see #beforeTestExecution
* @see #afterTestExecution
*/
default void afterTestMethod(TestContext testContext) throws Exception {
/* no-op */
}
/**
* Post-processes a test class <em>after</em> execution of all tests within
* the class.
* <p>This method should be called immediately after framework-specific
* <em>after class</em> lifecycle callbacks.
* <p>The default implementation is <em>empty</em>. Can be overridden by
* concrete classes as necessary.
* @param testContext the test context for the test; never {@code null}
* @throws Exception allows any exception to propagate
* @since 3.0
*/
default void afterTestClass(TestContext testContext) throws Exception {
/* no-op */
}
由于本文今天关注的重点是如何实现回滚的，那么咱们需要care的其实就是TransactionalTestExecutionListener的beforeTestMethod和afterTestMethod。
3.3 TransactionalTestExecutionListener
3.3.1 beforeTestMethod
public void beforeTestMethod(final TestContext testContext) throws Exception {
Method testMethod = testContext.getTestMethod();
Class<?> testClass = testContext.getTestClass();
Assert.notNull(testMethod, "Test method of supplied TestContext must not be null");
TransactionContext txContext = TransactionContextHolder.removeCurrentTransactionContext();
Assert.state(txContext == null, "Cannot start new transaction without ending existing transaction");
PlatformTransactionManager tm = null;
// 获取方法或者类上的@Transactional注解信息
TransactionAttribute transactionAttribute = this.attributeSource.getTransactionAttribute(testMethod, testClass);
// 如果加了@Transactional注解
if (transactionAttribute != null) {
transactionAttribute = TestContextTransactionUtils.createDelegatingTransactionAttribute(testContext,
transactionAttribute);
if (transactionAttribute.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
return;
}
// transactionManager默认情况下会获取容器里的PlatformTransactionManager
tm = getTransactionManager(testContext, transactionAttribute.getQualifier());
Assert.state(tm != null,
() -> "Failed to retrieve PlatformTransactionManager for @Transactional test: " + testContext);
}
if (tm != null) {
// 需要重点关注isRollback方法，新建了一个事务上下文txContext
txContext = new TransactionContext(testContext, tm, transactionAttribute, isRollback(testContext));
runBeforeTransactionMethods(testContext);
// 这里面通过TransactionManager的getTransaction获取了对应的transactionStatus，然后设置到了transactionContext上了
txContext.startTransaction();
// 将transactionContext放到了ThreadLocal上
TransactionContextHolder.setCurrentTransactionContext(txContext);
}
}
3.3.3.1 isRollback
protected final boolean isRollback(TestContext testContext) throws Exception {
// 如果类上面没有加@Rollback注解，那么此处rollback = true；只有@Rollback(value=false)，此处才是false
boolean rollback = isDefaultRollback(testContext);
// 获取方法上的@Rollback注解
Rollback rollbackAnnotation =
AnnotatedElementUtils.findMergedAnnotation(testContext.getTestMethod(), Rollback.class);
if (rollbackAnnotation != null) {
// 返回方法上的@Rollback注解的value
boolean rollbackOverride = rollbackAnnotation.value();
rollback = rollbackOverride;
}
else {
}
// 所以此处默认是true
return rollback;
}
3.3.1.2 isDefaultRollback
protected final boolean isDefaultRollback(TestContext testContext) throws Exception {
Class<?> testClass = testContext.getTestClass();
Rollback rollback = AnnotatedElementUtils.findMergedAnnotation(testClass, Rollback.class);
boolean rollbackPresent = (rollback != null);
if (rollbackPresent) {
boolean defaultRollback = rollback.value();
return defaultRollback;
}
// else
return true;
}
3.3.3.3 TransactionContext
TransactionContext(TestContext testContext, PlatformTransactionManager transactionManager,
TransactionDefinition transactionDefinition, boolean defaultRollback) {
this.testContext = testContext;
this.transactionManager = transactionManager;
this.transactionDefinition = transactionDefinition;
this.defaultRollback = defaultRollback;
// 因此此处的flaggedForRollback被设置成了true
this.flaggedForRollback = defaultRollback;
}
综上，可以发现，在beforeTestMethod中，会读取方法的@Transactional注解，如果类或者方法上没有@Rollback，那么默认的会设置一个 TransactionContext，并将其flaggedForRollback设置为true
3.3.2 afterTestMethod
public void afterTestMethod(TestContext testContext) throws Exception {
Method testMethod = testContext.getTestMethod();
Assert.notNull(testMethod, "The test method of the supplied TestContext must not be null");
// 从ThreadLocal上拿到了事务上下文txContext
TransactionContext txContext = TransactionContextHolder.removeCurrentTransactionContext();
// If there was (or perhaps still is) a transaction...
if (txContext != null) {
TransactionStatus transactionStatus = txContext.getTransactionStatus();
try {
// If the transaction is still active...
// 获取事务状态transactionStatus，
if (transactionStatus != null && !transactionStatus.isCompleted()) {
// 在该方法里进行回滚
txContext.endTransaction();
}
}
finally {
runAfterTransactionMethods(testContext);
}
}
}
3.3.2.1 endTransaction
void endTransaction() {
Assert.state(this.transactionStatus != null,
() -> "Failed to end transaction - transaction does not exist: " + this.testContext);
try {
if (this.flaggedForRollback) {
// 进入此处，调用了transactionManager的rollback方法
this.transactionManager.rollback(this.transactionStatus);
}
else {
this.transactionManager.commit(this.transactionStatus);
}
}
finally {
this.transactionStatus = null;
}
}
3.4 小结
大致流程如下
1. 执行beforeTestMethod，封装了一个TransactionContext，并把其中的flaggedForRollback设置成true，并把TransactionContext放到ThreadLocal里
2. 然后执行我们的单测方法
3. 执行afterTestMethod，从ThreadLocal里取出TransactionContext，判断里面的flaggedForRollback，如果为true，就rollback，否则就commit
在txContext.startTransaction();中，会调用transactionManager.getTransaction来获取当前的事务内容transactionStatus，关于这块的内容，可以参见这篇博客
总结
Spring这个盒子，很多实现方式都是类似的，特别这个SPI机制，很多地方使用，也是Spring框架开放给第三方框架用来接入的一个大杀器。
2153
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
