Spring Framework 提供了两种编程事务管理方法,分别使用:
-
或 .
TransactionTemplate
TransactionalOperator
-
直接实现。
TransactionManager
Spring 团队通常建议将 for programmatic
命令式流和响应式代码中的事务管理。
第二种方法类似于使用 JTA API,但有例外
处理不那么麻烦。TransactionTemplate
TransactionalOperator
UserTransaction
使用TransactionTemplate
它采用与其他 Spring 模板相同的方法,例如
这。它使用回调方法(将应用程序代码从必须
执行样板获取并释放事务资源)并导致
意图驱动的代码,因为您的代码只关注什么
你想做。TransactionTemplate
JdbcTemplate
正如下面的例子所示,使用 绝对
将您与 Spring 的交易基础设施和 API 相结合。无论是否程序化
事务管理是否适合您的开发需求是您的决定
必须让自己。TransactionTemplate |
必须在事务上下文中运行且显式使用 的应用程序代码类似于下一个示例。您,作为应用程序
开发人员,可以编写实现(通常表示为
anonymous inner class),其中包含您需要在上下文中运行的代码
事务。然后,可以将自定义实例传递给 .以下示例演示如何执行此操作:TransactionTemplate
TransactionCallback
TransactionCallback
execute(..)
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()
}
}
})
指定事务设置
您可以指定事务设置(例如传播模式、隔离级别、
超时等)以编程方式或
配置。默认情况下,实例具有默认的事务设置。这
以下示例演示了
一个特定的TransactionTemplate
TransactionTemplate
TransactionTemplate:
-
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
最后,在该实例中,该类的实例是线程安全的
不要保持任何对话状态。 但是,实例确实如此
维护配置状态。因此,虽然许多类可以共享一个实例
的 ,如果类需要使用
不同的设置(例如,不同的隔离级别),您需要创建
两个不同的实例。TransactionTemplate
TransactionTemplate
TransactionTemplate
TransactionTemplate
TransactionTemplate
使用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 或其他多值的情况下,
必须消耗完整输出才能完成事务。Subscriber
Subscription
Publisher
next()
take(long)
timeout(Duration)
Publisher
Flux
Publisher
指定事务设置
您可以指定事务设置(例如传播模式、隔离级别、
超时等)的 .默认情况下,实例具有默认的事务设置。这
以下示例显示了特定事务设置的自定义TransactionalOperator
TransactionalOperator
TransactionalOperator:
-
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.PlatformTransactionManager
PlatformTransactionManager
TransactionDefinition
TransactionStatus
-
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.ReactiveTransactionManager
ReactiveTransactionManager
TransactionDefinition
ReactiveTransaction
-
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)) }
}