程序化事务管理 (Programmatic Transaction Management) | Spring Framework6.1.11-SNAPSHOT中文文档|Spring官方文档|SpringBoot 教程|Spring中文网

此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Framework 6.1.10！

Spring Framework 提供了两种编程事务管理方法，分别使用：

或 .TransactionTemplateTransactionalOperator
直接实现。TransactionManager

Spring 团队通常建议将 for programmatic 命令式流和响应式代码中的事务管理。第二种方法类似于使用 JTA API，但有例外处理不那么麻烦。TransactionTemplateTransactionalOperatorUserTransaction

使用`TransactionTemplate`

它采用与其他 Spring 模板相同的方法，例如这。它使用回调方法（将应用程序代码从必须执行样板获取并释放事务资源）并导致意图驱动的代码，因为您的代码只关注什么你想做。TransactionTemplateJdbcTemplate

正如下面的例子所示，使用绝对将您与 Spring 的交易基础设施和 API 相结合。无论是否程序化事务管理是否适合您的开发需求是您的决定必须让自己。TransactionTemplate

必须在事务上下文中运行且显式使用的应用程序代码类似于下一个示例。您，作为应用程序开发人员，可以编写实现（通常表示为 anonymous inner class），其中包含您需要在上下文中运行的代码事务。然后，可以将自定义实例传递给 .以下示例演示如何执行此操作：TransactionTemplateTransactionCallbackTransactionCallbackexecute(..)TransactionTemplate

Java
Kotlin

public class SimpleService implements Service {

	// single TransactionTemplate shared amongst all methods in this instance
	private final TransactionTemplate transactionTemplate;

	// use constructor-injection to supply the PlatformTransactionManager
	public SimpleService(PlatformTransactionManager transactionManager) {
		this.transactionTemplate = new TransactionTemplate(transactionManager);
	}

	public Object someServiceMethod() {
		return transactionTemplate.execute(new TransactionCallback() {
			// the code in this method runs in a transactional context
			public Object doInTransaction(TransactionStatus status) {
				updateOperation1();
				return resultOfUpdateOperation2();
			}
		});
	}
}

// use constructor-injection to supply the PlatformTransactionManager
class SimpleService(transactionManager: PlatformTransactionManager) : Service {

	// single TransactionTemplate shared amongst all methods in this instance
	private val transactionTemplate = TransactionTemplate(transactionManager)

	fun someServiceMethod() = transactionTemplate.execute<Any?> {
		updateOperation1()
		resultOfUpdateOperation2()
	}
}

如果没有返回值，则可以使用方便的类使用匿名类，如下所示：TransactionCallbackWithoutResult

Java
Kotlin

transactionTemplate.execute(new TransactionCallbackWithoutResult() {
	protected void doInTransactionWithoutResult(TransactionStatus status) {
		updateOperation1();
		updateOperation2();
	}
});

transactionTemplate.execute(object : TransactionCallbackWithoutResult() {
	override fun doInTransactionWithoutResult(status: TransactionStatus) {
		updateOperation1()
		updateOperation2()
	}
})

回调中的代码可以通过对提供的对象调用方法回滚事务，如下所示：setRollbackOnly()TransactionStatus

Java
Kotlin

transactionTemplate.execute(new TransactionCallbackWithoutResult() {

	protected void doInTransactionWithoutResult(TransactionStatus status) {
		try {
			updateOperation1();
			updateOperation2();
		} catch (SomeBusinessException ex) {
			status.setRollbackOnly();
		}
	}
});

transactionTemplate.execute(object : TransactionCallbackWithoutResult() {

	override fun doInTransactionWithoutResult(status: TransactionStatus) {
		try {
			updateOperation1()
			updateOperation2()
		} catch (ex: SomeBusinessException) {
			status.setRollbackOnly()
		}
	}
})

指定事务设置

您可以指定事务设置（例如传播模式、隔离级别、超时等）以编程方式或配置。默认情况下，实例具有默认的事务设置。这以下示例演示了一个特定的TransactionTemplateTransactionTemplateTransactionTemplate:

Java
Kotlin

public class SimpleService implements Service {

	private final TransactionTemplate transactionTemplate;

	public SimpleService(PlatformTransactionManager transactionManager) {
		this.transactionTemplate = new TransactionTemplate(transactionManager);

		// the transaction settings can be set here explicitly if so desired
		this.transactionTemplate.setIsolationLevel(TransactionDefinition.ISOLATION_READ_UNCOMMITTED);
		this.transactionTemplate.setTimeout(30); // 30 seconds
		// and so forth...
	}
}

class SimpleService(transactionManager: PlatformTransactionManager) : Service {

	private val transactionTemplate = TransactionTemplate(transactionManager).apply {
		// the transaction settings can be set here explicitly if so desired
		isolationLevel = TransactionDefinition.ISOLATION_READ_UNCOMMITTED
		timeout = 30 // 30 seconds
		// and so forth...
	}
}

下面的示例定义了一个具有一些自定义事务的使用 Spring XML 配置进行设置：TransactionTemplate

<bean id="sharedTransactionTemplate"
		class="org.springframework.transaction.support.TransactionTemplate">
	<property name="isolationLevelName" value="ISOLATION_READ_UNCOMMITTED"/>
	<property name="timeout" value="30"/>
</bean>

然后，您可以根据需要将其注入到任意数量的服务中。sharedTransactionTemplate

最后，在该实例中，该类的实例是线程安全的不要保持任何对话状态。但是，实例确实如此维护配置状态。因此，虽然许多类可以共享一个实例的，如果类需要使用不同的设置（例如，不同的隔离级别），您需要创建两个不同的实例。TransactionTemplateTransactionTemplateTransactionTemplateTransactionTemplateTransactionTemplate

使用`TransactionalOperator`

遵循类似于其他反应式运算符的运算符设计运营商。它使用回调方法（将应用程序代码从必须执行样板获取和释放事务资源），并生成以下代码意图驱动，因为你的代码只关注你想做的事情。TransactionalOperator

正如下面的例子所示，使用绝对将您与 Spring 的交易基础设施和 API 相结合。无论是否程序化事务管理是否适合您的开发需求是您做出的决定让自己。TransactionalOperator

必须在事务上下文中运行且显式使用类似于下一个示例：TransactionalOperator

Java
Kotlin

public class SimpleService implements Service {

	// single TransactionalOperator shared amongst all methods in this instance
	private final TransactionalOperator transactionalOperator;

	// use constructor-injection to supply the ReactiveTransactionManager
	public SimpleService(ReactiveTransactionManager transactionManager) {
		this.transactionalOperator = TransactionalOperator.create(transactionManager);
	}

	public Mono<Object> someServiceMethod() {

		// the code in this method runs in a transactional context

		Mono<Object> update = updateOperation1();

		return update.then(resultOfUpdateOperation2).as(transactionalOperator::transactional);
	}
}

// use constructor-injection to supply the ReactiveTransactionManager
class SimpleService(transactionManager: ReactiveTransactionManager) : Service {

	// single TransactionalOperator shared amongst all methods in this instance
	private val transactionalOperator = TransactionalOperator.create(transactionManager)

	suspend fun someServiceMethod() = transactionalOperator.executeAndAwait<Any?> {
		updateOperation1()
		resultOfUpdateOperation2()
	}
}

TransactionalOperator可以通过两种方式使用：

使用 Project Reactor 类型（mono.as(transactionalOperator::transactional))
所有其他情况的回调样式（transactionalOperator.execute(TransactionCallback<T>))

回调中的代码可以通过对提供的对象调用方法回滚事务，如下所示：setRollbackOnly()ReactiveTransaction

Java
Kotlin

transactionalOperator.execute(new TransactionCallback<>() {

	public Mono<Object> doInTransaction(ReactiveTransaction status) {
		return updateOperation1().then(updateOperation2)
					.doOnError(SomeBusinessException.class, e -> status.setRollbackOnly());
		}
	}
});

transactionalOperator.execute(object : TransactionCallback() {

	override fun doInTransactionWithoutResult(status: ReactiveTransaction) {
		updateOperation1().then(updateOperation2)
					.doOnError(SomeBusinessException.class, e -> status.setRollbackOnly())
	}
})

取消信号

在反应式流中，a 可以取消其并停止其 .Project Reactor 以及其他库（如、、等）中的操作员可以发出取消通知。没有办法了解取消的原因，无论是由于错误还是只是缺乏进一步消费的兴趣。从版本 5.3 开始，取消信号会导致回滚。因此，重要的是要考虑事务下游使用的运算符。特别是在 a 或其他多值的情况下，必须消耗完整输出才能完成事务。SubscriberSubscriptionPublishernext()take(long)timeout(Duration)PublisherFluxPublisher

指定事务设置

您可以指定事务设置（例如传播模式、隔离级别、超时等）的 .默认情况下，实例具有默认的事务设置。这以下示例显示了特定事务设置的自定义TransactionalOperatorTransactionalOperatorTransactionalOperator:

Java
Kotlin

public class SimpleService implements Service {

	private final TransactionalOperator transactionalOperator;

	public SimpleService(ReactiveTransactionManager transactionManager) {
		DefaultTransactionDefinition definition = new DefaultTransactionDefinition();

		// the transaction settings can be set here explicitly if so desired
		definition.setIsolationLevel(TransactionDefinition.ISOLATION_READ_UNCOMMITTED);
		definition.setTimeout(30); // 30 seconds
		// and so forth...

		this.transactionalOperator = TransactionalOperator.create(transactionManager, definition);
	}
}

class SimpleService(transactionManager: ReactiveTransactionManager) : Service {

	private val definition = DefaultTransactionDefinition().apply {
		// the transaction settings can be set here explicitly if so desired
		isolationLevel = TransactionDefinition.ISOLATION_READ_UNCOMMITTED
		timeout = 30 // 30 seconds
		// and so forth...
	}
	private val transactionalOperator = TransactionalOperator(transactionManager, definition)
}

使用`TransactionManager`

以下各节介绍命令式事务和响应式事务的编程用法经理。

使用`PlatformTransactionManager`

对于命令易，您可以直接使用来管理您的交易。为此，请传递 u 的实现通过 Bean 引用用于您的 Bean。然后，通过使用和对象，可以启动事务、回滚和提交。这以下示例演示如何执行此操作：org.springframework.transaction.PlatformTransactionManagerPlatformTransactionManagerTransactionDefinitionTransactionStatus

Java
Kotlin

DefaultTransactionDefinition def = new DefaultTransactionDefinition();
// explicitly setting the transaction name is something that can be done only programmatically
def.setName("SomeTxName");
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

TransactionStatus status = txManager.getTransaction(def);
try {
	// put your business logic here
} catch (MyException ex) {
	txManager.rollback(status);
	throw ex;
}
txManager.commit(status);

val def = DefaultTransactionDefinition()
// explicitly setting the transaction name is something that can be done only programmatically
def.setName("SomeTxName")
def.propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRED

val status = txManager.getTransaction(def)
try {
	// put your business logic here
} catch (ex: MyException) {
	txManager.rollback(status)
	throw ex
}

txManager.commit(status)

使用`ReactiveTransactionManager`

在处理反应式事务时，您可以直接使用交易。为此，请传递 u 的实现通过 Bean 引用用于您的 Bean。然后，通过使用和对象，可以启动事务、回滚和提交。这以下示例演示如何执行此操作：org.springframework.transaction.ReactiveTransactionManagerReactiveTransactionManagerTransactionDefinitionReactiveTransaction

Java
Kotlin

DefaultTransactionDefinition def = new DefaultTransactionDefinition();
// explicitly setting the transaction name is something that can be done only programmatically
def.setName("SomeTxName");
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

Mono<ReactiveTransaction> reactiveTx = txManager.getReactiveTransaction(def);

reactiveTx.flatMap(status -> {

	Mono<Object> tx = ...; // put your business logic here

	return tx.then(txManager.commit(status))
			.onErrorResume(ex -> txManager.rollback(status).then(Mono.error(ex)));
});

val def = DefaultTransactionDefinition()
// explicitly setting the transaction name is something that can be done only programmatically
def.setName("SomeTxName")
def.propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRED

val reactiveTx = txManager.getReactiveTransaction(def)
reactiveTx.flatMap { status ->

	val tx = ... // put your business logic here

	tx.then(txManager.commit(status))
			.onErrorResume { ex -> txManager.rollback(status).then(Mono.error(ex)) }
}

使用TransactionTemplate

指定事务设置

使用TransactionalOperator

取消信号

指定事务设置

使用TransactionManager

使用PlatformTransactionManager

使用ReactiveTransactionManager

使用`TransactionTemplate`

使用`TransactionalOperator`

使用`TransactionManager`

使用`PlatformTransactionManager`

使用`ReactiveTransactionManager`