Spring数据访问和数据访问层与业务或服务层之间的交互

版本 6.0.0

参考文档的这一部分涉及数据访问和数据访问层与业务或服务层之间的交互。

Spring的全面事务管理支持已经详细介绍，然后全面涵盖各种数据访问框架和技术 Spring 框架与之集成。

1. 交易管理

全面的事务支持是使用Spring的最令人信服的理由之一。框架。Spring 框架为事务提供了一致的抽象具有以下优势的管理：

跨不同事务 API（如 Java）的一致编程模型事务 API （JTA）、JDBC、Hibernate 和 Java Persistence API （JPA）。
支持声明式事务管理。
用于编程事务管理的更简单的 API 而不是复杂的事务 API，例如 JTA。
与 Spring 的数据访问抽象完美集成。

以下部分描述了 Spring 框架的事务特性和技术：

Spring 框架事务支持的优势模型描述了为什么你会使用Spring Framework的事务抽象而不是 EJB 容器管理事务（CMT）或选择在本地驱动通过专有 API 进行交易，例如 Hibernate。
了解 Spring 框架事务抽象概述了核心类，并描述了如何配置和获取来自各种来源的实例。DataSource
将资源与事务同步说明应用程序代码如何确保创建、重用和清理资源适当地。
声明性事务管理描述了对声明式事务管理。
程序化事务管理涵盖对以下各项的支持编程（即显式编码）事务管理。
事务绑定事件描述如何使用应用程序事务中的事件。

本章还包括对最佳实践、应用服务器集成、以及常见问题的解决方案。

1.1. Spring 框架事务支持模型的优势

传统上，EE 应用程序开发人员有两种事务管理选择：全球或本地交易，两者都有深刻的局限性。全球和本地事务管理将在接下来的两个部分中进行回顾，然后是讨论 Spring 框架的事务管理支持如何解决全局和本地事务模型的局限性。

1.1.1. 全球交易

全局事务允许您使用多个事务资源，通常关系数据库和消息队列。应用程序服务器管理全局通过 JTA 进行交易，这是一个繁琐的 API（部分原因是异常模型）。此外，JTA通常需要来自 JNDI，这意味着您还需要使用 JNDI 才能使用 JTA。用途的全局事务限制了应用程序代码的任何潜在重用，因为 JTA 是通常仅在应用程序服务器环境中可用。UserTransaction

以前，使用全局事务的首选方法是通过 EJB CMT （容器管理事务）。CMT 是声明式交易的一种形式管理（有别于程序化事务管理）。EJB CMT 消除了与事务相关的 JNDI 查找的需要，尽管使用了 EJB 本身需要使用 JNDI。它消除了大部分但不是全部的写入需求用于控制事务的 Java 代码。显着的缺点是CMT与JTA绑定。和应用程序服务器环境。此外，它仅在选择时才可用在 EJB 中实现业务逻辑（或至少在事务性 EJB 外观后面）。这一般来说，EJB的负面因素是如此之大，以至于这不是一个有吸引力的主张，特别是面对声明式事务管理的令人信服的替代方案。

1.1.2. 本地交易

本地事务是特定于资源的，例如与 JDBC 关联的事务连接。本地事务可能更易于使用，但有一个明显的缺点：它们不能跨多个事务资源工作。例如，管理使用 JDBC 连接的事务不能在全局 JTA 事务中运行。因为应用程序服务器不参与事务管理，它不能帮助确保跨多个资源的正确性。（值得注意的是，大多数应用程序使用单个事务资源。另一个缺点是本地交易是侵入性的到编程模型。

1.1.3. Spring 框架的一致编程模型

Spring 解决了全球和本地交易的缺点。它让应用程序开发人员在任何环境中都使用一致的编程模型。您编写一次代码，它就可以从不同的事务管理中受益不同环境中的策略。Spring 框架提供了声明式和程序化事务管理。大多数用户更喜欢声明式事务管理，我们在大多数情况下建议这样做。

通过编程事务管理，开发人员可以使用 Spring 框架事务抽象，可以在任何底层事务基础结构上运行。使用首选的声明性模型，开发人员通常编写很少或没有代码与事务管理相关，因此不依赖于 Spring 框架事务 API 或任何其他事务 API。

您是否需要应用程序服务器进行事务管理？

Spring 框架的事务管理支持改变了传统的规则：当企业 Java 应用程序需要应用程序服务器时。

特别是，您不需要纯粹用于声明性事务的应用程序服务器通过 EJB。事实上，即使您的应用服务器具有强大的 JTA 功能，你可能会决定 Spring 框架的声明式事务提供更多的功能和比 EJB CMT 更高效的编程模型。

通常，仅当应用程序需要时才需要应用程序服务器的 JTA 功能。处理跨多个资源的事务，这不是许多资源的要求应用。许多高端应用程序使用单个高度可扩展的数据库（例如甲骨文 RAC）取而代之。独立的事务管理器（如Atomikos Transactions和JOTM）是其他选项。当然，您可能需要其他应用程序服务器功能，例如 Java Message Service （JMS）和 Jakarta EE Connector Architecture （JCA）。

Spring 框架使您可以选择何时将应用程序扩展到完全加载的应用程序服务器。使用 EJB 的唯一替代方法的日子已经一去不复返了 CMT或JTA是用本地事务（例如JDBC连接上的事务）编写代码如果您需要该代码在容器管理的全局范围内运行，则需要大量返工交易。使用 Spring 框架，只有配置文件需要更改（而不是您的代码）。

1.2. 理解 Spring 框架事务抽象

Spring 事务抽象的关键是事务策略的概念。一个事务策略由 A 定义，具体接口为命令式事务管理和反应式接口事务管理。以下清单显示了 API 的定义：TransactionManagerorg.springframework.transaction.PlatformTransactionManagerorg.springframework.transaction.ReactiveTransactionManagerPlatformTransactionManager

public interface PlatformTransactionManager extends TransactionManager {

    TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;

    void commit(TransactionStatus status) throws TransactionException;

    void rollback(TransactionStatus status) throws TransactionException;
}

这主要是一个服务提供程序接口（SPI），尽管您可以从应用程序代码以编程方式使用它。因为是一个接口，所以它可以很容易地被嘲笑或存根为必要。它不依赖于查找策略，例如JNDI.实现的定义与任何其他对象（或bean）相同。在 Spring Framework IoC 容器中。仅此好处就使 Spring 框架事务是一个有价值的抽象，即使您使用 JTA 也是如此。你可以测试事务代码比直接使用 JTA 容易得多。PlatformTransactionManagerPlatformTransactionManager

再次，为了与春天的哲学保持一致，可以抛出通过任何接口的方法都是未选中的（那是，它扩展了类）。事务基础结构失败几乎总是致命的。在极少数情况下，应用程序代码实际上可以从事务失败中恢复，应用程序开发人员仍然可以选择捕获和处理。突出的一点是开发人员不是*这样做的。TransactionExceptionPlatformTransactionManagerjava.lang.RuntimeExceptionTransactionException

该方法返回一个对象，具体取决于参数。返回的可能表示新事务或可以表示现有事务（如果是匹配事务）存在于当前调用堆栈中。后一种情况的含义是，与 Jakarta EE 事务上下文，与执行。getTransaction(..)TransactionStatusTransactionDefinitionTransactionStatusTransactionStatus

从Spring Framework 5.2开始，Spring还提供了事务管理抽象使用反应式类型或 Kotlin 协程的反应式应用程序。以下列表显示由以下人员定义的交易策略：org.springframework.transaction.ReactiveTransactionManager

public interface ReactiveTransactionManager extends TransactionManager {

    Mono<ReactiveTransaction> getReactiveTransaction(TransactionDefinition definition) throws TransactionException;

    Mono<Void> commit(ReactiveTransaction status) throws TransactionException;

    Mono<Void> rollback(ReactiveTransaction status) throws TransactionException;
}

反应式事务管理器主要是一个服务提供者接口（SPI），尽管您可以从您的应用程序代码。因为是一个界面，所以很容易必要时嘲笑或存根。ReactiveTransactionManager

该接口指定：TransactionDefinition

传播：通常，事务范围内的所有代码都在那笔交易。但是，您可以指定行为，如果当事务上下文已存在时，将运行事务方法。为例如，代码可以继续在现有事务中运行（常见情况），或者可以暂停现有事务并创建新事务。春天提供了 EJB CMT 中熟悉的所有事务传播选项。要阅读关于 Spring 中事务传播的语义，请参阅事务传播。
隔离：此事务与其他事务的工作隔离的程度交易。例如，此事务是否可以看到来自其他事务的未提交写入交易？
超时：此事务在超时并自动回滚之前运行的时间通过底层事务基础结构。
只读状态：当代码读取但不修改数据。在某些方面，只读事务可能是一个有用的优化情况，例如当您使用休眠时。

这些设置反映了标准的事务概念。如有必要，请参阅资源讨论事务隔离级别和其他核心事务概念。理解这些概念对于使用 Spring 框架或任何事务管理解决方案。

该接口为事务代码提供了一种简单的方法控制事务执行和查询事务状态。这些概念应该是熟悉，因为它们对所有事务 API 都是通用的。以下清单显示了界面：TransactionStatusTransactionStatus

public interface TransactionStatus extends TransactionExecution, SavepointManager, Flushable {

    @Override
    boolean isNewTransaction();

    boolean hasSavepoint();

    @Override
    void setRollbackOnly();

    @Override
    boolean isRollbackOnly();

    void flush();

    @Override
    boolean isCompleted();
}

无论您在春天，定义正确的实现是绝对必要的。通常通过依赖关系注入来定义此实现。TransactionManager

TransactionManager实现通常需要了解以下环境：他们工作：JDBC，JTA，Hibernate等。以下示例演示如何定义一个本地实现（在本例中，使用 plain JDBC.）PlatformTransactionManager

您可以通过创建类似于以下内容的 Bean 来定义 JDBC：DataSource

<bean  class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="${jdbc.driverClassName}" />
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
</bean>

然后，相关 bean 定义具有对定义的引用。它应类似于以下示例：PlatformTransactionManagerDataSource

<bean  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

如果您在 Jakarta EE 容器中使用 JTA，则使用容器，获得通过JNDI，与Spring's一起。以下示例显示了 JTA 和 JNDI 查找版本的外观：DataSourceJtaTransactionManager

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/jee
        https://www.springframework.org/schema/jee/spring-jee.xsd">

    <jee:jndi-lookup  jndi-name="jdbc/jpetstore"/>

    <bean  class="org.springframework.transaction.jta.JtaTransactionManager" />

    <!-- other <bean/> definitions here -->

</beans>

不需要知道（或任何其他特定资源），因为它使用容器的全局事务管理基础设施。JtaTransactionManagerDataSource

在所有 Spring 事务设置中，应用程序代码不需要更改。您可以更改如何仅通过更改配置来管理事务，即使该更改意味着从本地事务转移到全局事务，反之亦然。

1.2.1. 休眠事务设置

您还可以轻松使用 Hibernate 本地事务，如以下示例所示。在这种情况下，您需要定义一个休眠，您的应用程序代码可用于获取休眠实例。LocalSessionFactoryBeanSession

Thebean 定义类似于前面显示的本地 JDBC 示例因此，以下示例中未显示。DataSource

在这种情况下，Thebean属于该类型。在与需要引用的方式相同，需要引用。以下示例声明和豆子：txManagerHibernateTransactionManagerDataSourceTransactionManagerDataSourceHibernateTransactionManagerSessionFactorysessionFactorytxManager

<bean  class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="mappingResources">
        <list>
            <value>org/springframework/samples/petclinic/hibernate/petclinic.hbm.xml</value>
        </list>
    </property>
    <property name="hibernateProperties">
        <value>
            hibernate.dialect=${hibernate.dialect}
        </value>
    </property>
</bean>

<bean  class="org.springframework.orm.hibernate5.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory"/>
</bean>

如果使用 Hibernate 和 Jakarta EE 容器管理的 JTA 事务，则应使用与前面的 JDBC JTA 示例中相同，如下所示示例显示。此外，建议通过其使Hibernate知道JTA 事务协调器，可能还有其连接释放模式配置：JtaTransactionManager

<bean  class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="mappingResources">
        <list>
            <value>org/springframework/samples/petclinic/hibernate/petclinic.hbm.xml</value>
        </list>
    </property>
    <property name="hibernateProperties">
        <value>
            hibernate.dialect=${hibernate.dialect}
            hibernate.transaction.coordinator_class=jta
            hibernate.connection.handling_mode=DELAYED_ACQUISITION_AND_RELEASE_AFTER_STATEMENT
        </value>
    </property>
</bean>

<bean  class="org.springframework.transaction.jta.JtaTransactionManager"/>

或者，您也可以将 ther传递给您的以强制执行相同的默认值：JtaTransactionManagerLocalSessionFactoryBean

<bean  class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="mappingResources">
        <list>
            <value>org/springframework/samples/petclinic/hibernate/petclinic.hbm.xml</value>
        </list>
    </property>
    <property name="hibernateProperties">
        <value>
            hibernate.dialect=${hibernate.dialect}
        </value>
    </property>
    <property name="jtaTransactionManager" ref="txManager"/>
</bean>

<bean  class="org.springframework.transaction.jta.JtaTransactionManager"/>

1.3. 将资源与事务同步

如何创建不同的事务管理器以及如何将它们链接到相关资源需要同步到事务（例如，到 JDBC，到休眠，等等）现在应该很清楚了。本节介绍应用程序如何编码（直接或间接地，通过使用持久性 API，如 JDBC、Hibernate 或 JPA）确保正确创建、重用和清理这些资源。该部分还讨论了如何（可选）通过相关。DataSourceTransactionManagerDataSourceHibernateTransactionManagerSessionFactoryTransactionManager

1.3.1. 高级同步方法

首选方法是使用 Spring *别的基于模板的持久性集成 API 或将本机 ORM API 与事务感知工厂 Bean 一起使用，或用于管理本机资源工厂的代理。这些事务感知解决方案内部处理资源创建和重用、清理、可选事务资源同步和异常映射。因此，用户数据访问代码确实不必处理这些任务，但可以完全专注于非样板持久性逻辑。通常，您使用本机ORM API或采用模板方法对于 JDBC 访问，请使用。这些解决方案将在后续中详细介绍部分。JdbcTemplate

1.3.2. 低级同步方法

诸如（对于JDBC），（对于JPA），（对于Hibernate）等类存在于较低的级别。当您想要直接处理本机持久性 API 的资源类型的应用程序代码，您可以使用这些类来确保获得正确的 Spring 框架管理的实例，事务（可选）同步，流程中发生的异常是正确映射到一致的 API。DataSourceUtilsEntityManagerFactoryUtilsSessionFactoryUtils

例如，在 JDBC 的情况下，而不是传统的 JDBC 调用方法方法上，你可以改用 Spring 的类，如下所示：getConnection()DataSourceorg.springframework.jdbc.datasource.DataSourceUtils

Connection conn = DataSourceUtils.getConnection(dataSource);

如果现有事务已具有同步（链接）的连接，则返回实例。否则，方法调用将触发创建新的连接，（可选）同步到任何现有事务并已建立可用于同一事务中的后续重用。如前所述，anyis 包装在一个 Spring 框架中，一个的 Spring 框架的未选中类型层次结构。这种方法为您提供比从和轻松获得的更多信息确保跨数据库甚至跨不同持久性技术的可移植性。SQLExceptionCannotGetJdbcConnectionExceptionDataAccessExceptionSQLException

这种方法也可以在没有 Spring 事务管理的情况下工作（事务同步是可选的），因此无论您是否将 Spring 用于事务管理。

当然，一旦你使用了 Spring 的 JDBC 支持、JPA 支持或 Hibernate 支持，您通常不希望使用其他帮助程序类，因为通过 Spring 抽象工作比直接工作更快乐使用相关 API。例如，如果使用 Springorpackage 来简化 JDBC 的使用，则会发生正确的连接检索在幕后，您无需编写任何特殊代码。DataSourceUtilsJdbcTemplatejdbc.object

1.3.3. `TransactionAwareDataSourceProxy`

在最低的层次上存在类。这是一个目标的代理，它包装目标以增加对弹簧管理的交易。在这方面，它类似于雅加达EE服务器提供的事务性JNDI。TransactionAwareDataSourceProxyDataSourceDataSourceDataSource

你几乎永远不需要或想要使用这个类，除非存在必须调用代码并传递标准的 JDBC接口实现。在在这种情况下，此代码可能可用，但正在参与 Spring 托管交易。可以使用更高级别编写新代码前面提到的抽象。DataSource

1.4. 声明式事务管理

Spring 框架的声明式事务管理可以通过 Spring 实现面向方面的编程（AOP）。但是，随着事务方面的代码出现与 Spring 框架发行版一起使用，可以以样板方式使用 AOP 通常不必理解概念即可有效使用此代码。

Spring 框架的声明式事务管理类似于 EJB CMT，因为它您可以指定事务行为（或缺少事务行为）到单个方法级别。您可以在事务上下文中进行 acall，如果必要。两种类型的事务管理之间的区别是：setRollbackOnly()

与与JTA绑定的EJB CMT不同，Spring Framework的声明式事务。管理适用于任何环境。它可以与JTA事务或本地使用 JDBC、JPA 或休眠通过调整配置进行事务文件。
您可以将 Spring 框架声明式事务管理应用于任何类，不仅仅是像EJB这样的特殊类。
Spring 框架提供了声明式回滚规则，这是一个没有 EJB 的特性等效。提供对回滚规则的编程和声明性支持。
Spring 框架允许您使用 AOP 自定义事务行为。例如，您可以在事务回滚的情况下插入自定义行为。你还可以添加任意建议以及事务性建议。使用 EJB CMT，您可以不能影响容器的事务管理，除非。setRollbackOnly()
Spring 框架不支持跨事务上下文的传播远程调用，就像高端应用程序服务器一样。如果您需要此功能，我们建议您使用 EJB。但是，在使用此类功能之前，请仔细考虑，因为，通常情况下，人们不希望事务跨越远程调用。

回滚规则的概念很重要。它们允许您指定哪些例外（和可抛掷对象）应导致自动回滚。您可以在配置，而不是在 Java 代码中。所以，虽然你仍然可以打电话对象回滚当前事务，最常见的是可以指定必须始终导致回滚的规则。这此选项的显著优点是业务对象不依赖于事务基础结构。例如，他们通常不需要导入Spring。事务 API 或其他 Spring API。setRollbackOnly()TransactionStatusMyApplicationException

尽管 EJB 容器缺省行为会自动回滚系统异常（通常是运行时异常），EJB CMT 不会回滚在应用程序异常（即已检查的异常）上自动执行事务除此之外）。虽然 Spring 默认行为声明式事务管理遵循 EJB 约定（回滚仅自动进行在未经检查的异常中），自定义此行为通常很有用。java.rmi.RemoteException

1.4.1. 理解 Spring 框架的声明式事务实现

仅仅告诉你用注释来注释你的类是不够的，添加到你的配置中，并期望您了解这一切是如何工作的。为了提供更深入的理解，这部分解释了 Spring 框架声明式事务的内部工作原理交易相关问题背景下的基础设施。@Transactional@EnableTransactionManagement

关于 Spring 框架的声明式要掌握的最重要的概念事务支持是通过AOP 代理启用的，并且事务建议由元数据（目前基于 XML 或注释）驱动。AOP的组合使用事务元数据生成使用 ain 的 AOP 代理结合适当的实现来驱动事务围绕方法调用。TransactionInterceptorTransactionManager

Spring 框架提供事务管理命令式和响应式编程模型。拦截器检测所需的风味通过检查方法返回类型进行事务管理。返回反应式的方法诸如 Kotlin 的类型（或其中的子类型）有资格进行反应事务管理。所有其他返回类型，包括使用命令式事务管理。TransactionInterceptorPublisherFlowvoid

事务管理风格会影响需要哪个事务管理器。祈使的事务需要 A，而响应式事务使用实现。PlatformTransactionManagerReactiveTransactionManager

下图显示了在事务代理上调用方法的概念视图：

Spring数据访问和数据访问层与业务或服务层之间的交互

1.4.2. 声明式事务实现示例

请考虑以下接口及其伴随的实现。此示例使用 andclasses 作为占位符，以便您可以专注于事务不关注特定域模型的使用情况。就本例而言， TheClass 在每个实现方法的主体中抛出实例这一事实很好。该行为可让您看到正在创建事务，然后回滚以响应实例。以下清单显示了界面：FooBarDefaultFooServiceUnsupportedOperationExceptionUnsupportedOperationExceptionFooService

// the service interface that we want to make transactional

package x.y.service;

public interface FooService {

    Foo getFoo(String fooName);

    Foo getFoo(String fooName, String barName);

    void insertFoo(Foo foo);

    void updateFoo(Foo foo);

}

以下示例显示了上述接口的实现：

package x.y.service;

public class DefaultFooService implements FooService {

    @Override
    public Foo getFoo(String fooName) {
        // ...
    }

    @Override
    public Foo getFoo(String fooName, String barName) {
        // ...
    }

    @Override
    public void insertFoo(Foo foo) {
        // ...
    }

    @Override
    public void updateFoo(Foo foo) {
        // ...
    }
}

假设接口的前两种方法，并且，必须在事务的上下文中以只读方式运行语义和其他方法，并且，必须在具有读写语义的事务上下文中运行。以下配置将在接下来的几段中详细说明：FooServicegetFoo(String)getFoo(String, String)insertFoo(Foo)updateFoo(Foo)

<!-- from the file 'context.xml' -->
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- this is the service object that we want to make transactional -->
    <bean  class="x.y.service.DefaultFooService"/>

    <!-- the transactional advice (what 'happens'; see the <aop:advisor/> bean below) -->
    <tx:advice  transaction-manager="txManager">
        <!-- the transactional semantics... -->
        <tx:attributes>
            <!-- all methods starting with 'get' are read-only -->
            <tx:method name="get*" read-only="true"/>
            <!-- other methods use the default transaction settings (see below) -->
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>

    <!-- ensure that the above transactional advice runs for any execution
        of an operation defined by the FooService interface -->
    <aop:config>
        <aop:pointcut  expression="execution(* x.y.service.FooService.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="fooServiceOperation"/>
    </aop:config>

    <!-- don't forget the DataSource -->
    <bean  class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
        <property name="url" value="jdbc:oracle:thin:@rj-t42:1521:elvis"/>
        <property name="username" value="scott"/>
        <property name="password" value="tiger"/>
    </bean>

    <!-- similarly, don't forget the TransactionManager -->
    <bean  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- other <bean/> definitions here -->

</beans>

检查上述配置。它假定您要创建一个服务对象，底豆，事务性。要应用的事务语义已封装在定义中。该定义读作“所有方法从 ARE 开始在只读事务的上下文中运行，并且所有其他方法是使用默认事务语义运行”。标签的属性设置为将驱动事务的bean的名称（在本例中为bean）。fooService<tx:advice/><tx:advice/>gettransaction-manager<tx:advice/>TransactionManagertxManager

该定义确保由 bean 定义的事务建议在程序中的适当点运行。首先，定义一个与接口中定义的任何操作的执行相匹配的切入点 ().然后，您将切入点与 theby 使用顾问。结果表明，在执行 a 时，定义 by 的建议运行。<aop:config/>txAdviceFooServicefooServiceOperationtxAdvicefooServiceOperationtxAdvice

元素中定义的表达式是AspectJ切入点表达。有关切入点的更多详细信息，请参阅AOP 部分春天的表情。<aop:pointcut/>

一个常见的要求是使整个服务层具有事务性。最好的方式这样做是为了更改切入点表达式以匹配服务层。以下示例演示如何执行此操作：

<aop:config>
    <aop:pointcut  expression="execution(* x.y.service.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="fooServiceMethods"/>
</aop:config>

现在我们已经分析了配置，您可能会问自己， “所有这些配置实际上有什么作用？”

前面显示的配置用于围绕对象创建事务代理这是根据 Thebean 定义创建的。代理配置为事务性建议，以便在代理上调用适当的方法时，事务已启动、挂起、标记为只读等，具体取决于与该方法关联的事务配置。考虑以下程序该测试驱动前面显示的配置：fooService

public final class Boot {

    public static void main(final String[] args) throws Exception {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("context.xml");
        FooService fooService = ctx.getBean(FooService.class);
        fooService.insertFoo(new Foo());
    }
}

运行上述程序的输出应类似于以下内容（Log4J 为清楚起见，来自 thePose by Theclass 方法的输出和堆栈跟踪已被截断）：UnsupportedOperationExceptioninsertFoo(..)DefaultFooService

<!-- the Spring container is starting up... -->
[AspectJInvocationContextExposingAdvisorAutoProxyCreator] - Creating implicit proxy for bean 'fooService' with 0 common interceptors and 1 specific interceptors

<!-- the DefaultFooService is actually proxied -->
[JdkDynamicAopProxy] - Creating JDK dynamic proxy for [x.y.service.DefaultFooService]

<!-- ... the insertFoo(..) method is now being invoked on the proxy -->
[TransactionInterceptor] - Getting transaction for x.y.service.FooService.insertFoo

<!-- the transactional advice kicks in here... -->
[DataSourceTransactionManager] - Creating new transaction with name [x.y.service.FooService.insertFoo]
[DataSourceTransactionManager] - Acquired Connection [org.apache.commons.dbcp.PoolableConnection@a53de4] for JDBC transaction

<!-- the insertFoo(..) method from DefaultFooService throws an exception... -->
[RuleBasedTransactionAttribute] - Applying rules to determine whether transaction should rollback on java.lang.UnsupportedOperationException
[TransactionInterceptor] - Invoking rollback for transaction on x.y.service.FooService.insertFoo due to throwable [java.lang.UnsupportedOperationException]

<!-- and the transaction is rolled back (by default, RuntimeException instances cause rollback) -->
[DataSourceTransactionManager] - Rolling back JDBC transaction on Connection [org.apache.commons.dbcp.PoolableConnection@a53de4]
[DataSourceTransactionManager] - Releasing JDBC Connection after transaction
[DataSourceUtils] - Returning JDBC Connection to DataSource

Exception in thread "main" java.lang.UnsupportedOperationException at x.y.service.DefaultFooService.insertFoo(DefaultFooService.java:14)
<!-- AOP infrastructure stack trace elements removed for clarity -->
at $Proxy0.insertFoo(Unknown Source)
at Boot.main(Boot.java:11)

要使用反应式事务管理，代码必须使用反应式类型。

下面的清单显示了以前使用的修改版本，但是这次代码使用反应式类型：FooService

// the reactive service interface that we want to make transactional

package x.y.service;

public interface FooService {

    Flux<Foo> getFoo(String fooName);

    Publisher<Foo> getFoo(String fooName, String barName);

    Mono<Void> insertFoo(Foo foo);

    Mono<Void> updateFoo(Foo foo);

}

以下示例显示了上述接口的实现：

package x.y.service;

public class DefaultFooService implements FooService {

    @Override
    public Flux<Foo> getFoo(String fooName) {
        // ...
    }

    @Override
    public Publisher<Foo> getFoo(String fooName, String barName) {
        // ...
    }

    @Override
    public Mono<Void> insertFoo(Foo foo) {
        // ...
    }

    @Override
    public Mono<Void> updateFoo(Foo foo) {
        // ...
    }
}

命令式和响应式事务管理共享相同的事务语义边界和事务属性定义。命令式的主要区别反应式事务是后者的延迟性质。使用事务运算符修饰返回的反应式类型以开始和清理事务。因此，调用事务反应式方法会延迟实际对激活反应式处理的订阅类型的事务管理类型。TransactionInterceptor

反应式事务管理的另一个方面与数据转义有关，即编程模型的自然结果。

命令性事务的方法返回值从事务方法返回成功终止方法后，使部分计算的结果不会逃逸方法闭包。

反应式事务方法返回一个反应式包装器类型，该类型表示计算序列以及开始和完成计算的承诺。

Acan 可以在事务正在进行但不一定完成时发出数据。因此，依赖于成功完成整个事务的方法需要以确保调用代码中的完成和缓冲结果。Publisher

1.4.3. 回滚声明式事务

上一节概述了如何为类，通常是服务层类，在应用程序中以声明方式提供。本节描述如何在简单的声明性中控制事务的回滚 XML 配置中的时尚。有关以声明方式控制回滚语义的详细信息使用注释，请参阅@Transactional设置。@Transactional

向 Spring 框架的事务基础结构指示的推荐方法事务的工作要回滚是抛出一个代码当前正在事务上下文中执行。Spring 框架的事务基础结构代码在冒泡时捕获任何未处理的内容调用堆栈，并确定是否将事务标记为回滚。ExceptionException

在其默认配置中，Spring 框架的事务基础结构代码仅在运行时、未经检查的异常情况下将事务标记为回滚。也就是说，当抛出的异常是的实例或子类时。（默认情况下，实例也会导致回滚）。已检查的异常从事务方法引发不会导致默认回滚配置。RuntimeExceptionError

您可以准确配置哪些类型将事务标记为回滚，通过指定回滚规则包括已检查的异常。Exception

回滚规则

回滚规则确定当给定异常抛出，规则基于异常类型或异常模式。

回滚规则可以通过 theandattributes 在 XML 中配置，这允许将规则定义为模式。使用@Transactional时，回滚规则可能会通过 /和/属性进行配置，这允许规则分别基于异常类型或模式定义。rollback-forno-rollback-forrollbackFornoRollbackForrollbackForClassNamenoRollbackForClassName

使用异常类型定义回滚规则时，该类型将用于匹配针对抛出的异常类型及其超类型，提供类型安全和避免使用模式时可能发生的任何意外匹配。例如，一个值将仅匹配抛出的异常类型及其子类。jakarta.servlet.ServletException.classjakarta.servlet.ServletException

使用例外模式定义回滚规则时，该模式可以是完全异常类型的限定类名或完全限定类名的子字符串（必须是的子类），目前没有通配符支持。为例如，一个值 oforwill 匹配及其子类。Throwable"jakarta.servlet.ServletException""ServletException"jakarta.servlet.ServletException

以下 XML 代码段演示如何为选中的、应用程序特定类型，通过属性提供异常模式：Exceptionrollback-for

<tx:advice  transaction-manager="txManager">
    <tx:attributes>
    <tx:method name="get*" read-only="true" rollback-for="NoProductInStockException"/>
    <tx:method name="*"/>
    </tx:attributes>
</tx:advice>

如果您不希望在引发异常时回滚事务，您还可以指定“无回滚”规则。下面的例子告诉 Spring 框架的事务基础结构，即使在面对未处理：InstrumentNotFoundException

<tx:advice >
    <tx:attributes>
    <tx:method name="updateStock" no-rollback-for="InstrumentNotFoundException"/>
    <tx:method name="*"/>
    </tx:attributes>
</tx:advice>

当 Spring 框架的事务基础结构捕获异常并查询配置的回滚规则，以确定是否将事务标记为回滚，最强的匹配规则获胜。因此，在以下配置的情况下，任何除 an 以外的异常导致回滚服务员交易：InstrumentNotFoundException

<tx:advice >
    <tx:attributes>
    <tx:method name="*" rollback-for="Throwable" no-rollback-for="InstrumentNotFoundException"/>
    </tx:attributes>
</tx:advice>

还可以以编程方式指示所需的回滚。虽然简单，但这个过程非常具有侵入性，并且将您的代码与 Spring 框架的事务紧密耦合基础设施。下面的示例演示如何以编程方式指示必需的反转：

爪哇岛

科特林

public void resolvePosition() {
    try {
        // some business logic...
    } catch (NoProductInStockException ex) {
        // trigger rollback programmatically
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
}

强烈建议您使用声明性方法进行回滚（如果有的话）可能。如果您绝对需要，可以使用编程回滚，但它使用与实现基于 POJO 的干净架构背道而驰。

1.4.4. 为不同的 bean 配置不同的事务语义

考虑以下场景：您有许多服务层对象，并且您希望对它们中的每一个应用完全不同的事务配置。你可以这样做通过定义具有不同和属性值的不同元素。<aop:advisor/>pointcutadvice-ref

作为比较点，首先假设所有服务图层类都是在根包中定义。使所有 bean 都是类的实例在该包（或子包）中定义，并且名称以 with 结尾默认事务配置，您可以编写以下内容：x.y.serviceService

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <aop:config>

        <aop:pointcut 
                expression="execution(* x.y.service..*Service.*(..))"/>

        <aop:advisor pointcut-ref="serviceOperation" advice-ref="txAdvice"/>

    </aop:config>

    <!-- these two beans will be transactional... -->
    <bean  class="x.y.service.DefaultFooService"/>
    <bean  class="x.y.service.extras.SimpleBarService"/>

    <!-- ... and these two beans won't -->
    <bean  class="org.xyz.SomeService"/> <!-- (not in the right package) -->
    <bean  class="x.y.service.SimpleBarManager"/> <!-- (doesn't end in 'Service') -->

    <tx:advice >
        <tx:attributes>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>

    <!-- other transaction infrastructure beans such as a TransactionManager omitted... -->

</beans>

以下示例显示了如何使用完全不同的 Bean 配置两个不同的 bean 事务设置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <aop:config>

        <aop:pointcut 
                expression="execution(* x.y.service.*Service.*(..))"/>

        <aop:pointcut 
                expression="execution(* x.y.service.ddl.DefaultDdlManager.*(..))"/>

        <aop:advisor pointcut-ref="defaultServiceOperation" advice-ref="defaultTxAdvice"/>

        <aop:advisor pointcut-ref="noTxServiceOperation" advice-ref="noTxAdvice"/>

    </aop:config>

    <!-- this bean will be transactional (see the 'defaultServiceOperation' pointcut) -->
    <bean  class="x.y.service.DefaultFooService"/>

    <!-- this bean will also be transactional, but with totally different transactional settings -->
    <bean  class="x.y.service.ddl.DefaultDdlManager"/>

    <tx:advice >
        <tx:attributes>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>

    <tx:advice >
        <tx:attributes>
            <tx:method name="*" propagation="NEVER"/>
        </tx:attributes>
    </tx:advice>

    <!-- other transaction infrastructure beans such as a TransactionManager omitted... -->

</beans>

1.4.5. <tx：建议/>设置

本节总结了可以使用以下命令指定的各种事务设置标签。默认设置为：<tx:advice/><tx:advice/>

传播设置为REQUIRED.
隔离级别为DEFAULT.
事务是读写的。
事务超时默认为基础事务的默认超时系统或无（如果不支持超时）。
任何触发器回滚，任何选中的都不会。RuntimeExceptionException

您可以更改这些默认设置。下表总结了标签的各种属性嵌套在标签中：<tx:method/><tx:advice/><tx:attributes/>

表 1.<tx：方法/>设置

属性	必填？	违约	描述
`name`	是的		要与事务属性关联的方法名称。这通配符（）字符可用于关联同一事务属性具有多种方法（例如,,,,等）的设置四）。`get``handle``onEvent`
`propagation`	不	`REQUIRED`	事务传播行为。
`isolation`	不	`DEFAULT`	事务隔离级别。仅适用于传播设置 ofor。`REQUIRED``REQUIRES_NEW`
`timeout`	不	-1	事务超时（秒）。仅适用于传播器。`REQUIRED``REQUIRES_NEW`
`read-only`	不	假	读写事务与只读事务。仅适用于 toor。`REQUIRED``REQUIRES_NEW`
`rollback-for`	不		以逗号分隔的触发回滚的实例列表。例如。`Exception``com.foo.MyBusinessException,ServletException`
`no-rollback-for`	不		以逗号分隔的不触发回滚的实例列表。例如。`Exception``com.foo.MyBusinessException,ServletException`

1.4.6. 使用`@Transactional`

除了基于 XML 的事务配置声明性方法之外，您还可以使用基于注释的方法。直接在 Java 中声明事务语义源代码使声明更接近受影响的代码。没有多少过度耦合的危险，因为用于事务性的代码是无论如何，几乎总是以这种方式部署。

使用注释提供的易用性是最好的用一个示例进行说明，该示例在下面的文本中进行了说明。请考虑以下类定义：@Transactional

// the service class that we want to make transactional
@Transactional
public class DefaultFooService implements FooService {

    @Override
    public Foo getFoo(String fooName) {
        // ...
    }

    @Override
    public Foo getFoo(String fooName, String barName) {
        // ...
    }

    @Override
    public void insertFoo(Foo foo) {
        // ...
    }

    @Override
    public void updateFoo(Foo foo) {
        // ...
    }
}

使 Bean 实例具有事务性的行。

如上所述在类级别使用，注释指示所有方法的默认值声明类（及其子类）。或者，每种方法都可以单独注释。有关方法可见性和@Transactional 有关 Spring 认为哪些方法具有事务性的更多详细信息。请注意，类级别注释不适用于类层次结构中的祖先类;在这种情况下，继承的方法需要在本地重新声明才能参与子类级别注释。

当像上面这样的 POJO 类被定义为 Spring 上下文中的 bean 时，您可以通过 aclass 中的 anannotation 使 Bean 实例成为事务性实例。有关完整的详细信息，请参阅javadoc。@EnableTransactionManagement@Configuration

在 XML 配置中，标记提供了类似的便利：<tx:annotation-driven/>

<!-- from the file 'context.xml' -->
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- this is the service object that we want to make transactional -->
    <bean  class="x.y.service.DefaultFooService"/>

    <!-- enable the configuration of transactional behavior based on annotations -->
    <!-- a TransactionManager is still required -->
    <tx:annotation-driven transaction-manager="txManager"/> 

    <bean  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- (this dependency is defined somewhere else) -->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- other <bean/> definitions here -->

</beans>

与命令式相反，反应式事务方法使用反应式返回类型编程安排如下表所示：

// the reactive service class that we want to make transactional
@Transactional
public class DefaultFooService implements FooService {

    @Override
    public Publisher<Foo> getFoo(String fooName) {
        // ...
    }

    @Override
    public Mono<Foo> getFoo(String fooName, String barName) {
        // ...
    }

    @Override
    public Mono<Void> insertFoo(Foo foo) {
        // ...
    }

    @Override
    public Mono<Void> updateFoo(Foo foo) {
        // ...
    }
}

请注意，对于返回的反应流取消信号。请参阅下面的取消信号部分 “使用事务运算符”以获取更多详细信息。Publisher

方法可见性和@Transactional

当您使用具有 Spring 标准配置的事务代理时，您应该应用仅对具有可见性的方法进行注释。如果你这样做注释，或包可见的方法使用注释，不会引发错误，但注释方法不显示已配置的事务设置。如果需要注释非公共方法，请考虑中的提示以下段落用于基于类的代理或考虑使用 AspectJ 编译时或加载时编织（稍后描述）。@Transactionalpublicprotectedprivate@Transactional

在类中使用时，或包可见的方法也可以通过以下方式为基于类的代理提供事务性注册自定义Bean，如以下示例所示。但请注意，基于接口的代理中的事务方法必须始终在代理接口中定义。@EnableTransactionManagement@ConfigurationprotectedtransactionAttributeSourcepublic

Spring TestContext Framework通过以下方式支持非私有测试方法违约。请参阅测试中的事务管理章节为例。@Transactional

/**
 * Register a custom AnnotationTransactionAttributeSource with the
 * publicMethodsOnly flag set to false to enable support for
 * protected and package-private @Transactional methods in
 * class-based proxies.
 *
 * @see ProxyTransactionManagementConfiguration#transactionAttributeSource()
 */
@Bean
TransactionAttributeSource transactionAttributeSource() {
    return new AnnotationTransactionAttributeSource(false);
}

您可以将注释应用于接口定义，一种方法在接口、类定义或类上的方法上。然而，仅仅存在注释不足以激活事务行为。注释只是元数据，可以被一些感知的运行时基础结构使用，并且可以使用元数据来配置具有事务行为的相应 Bean。在前面的示例中，元素打开事务行为。@Transactional@Transactional@Transactional@Transactional<tx:annotation-driven/>

请考虑使用 AspectJ 模式（请参阅下表中的属性），如果您期望自我调用也与事务一起包装。在这种情况下，有首先没有代理。相反，目标类是编织的（即，它的字节码修改）以支持任何类型的方法上的运行时行为。mode@Transactional

表 2.注释驱动的事务设置

XML 属性	注释属性	违约	描述
`transaction-manager`	N/A （参见TransactionManagementConfigurerjavadoc）	`transactionManager`	要使用的事务管理器的名称。仅当事务名称时才需要管理器不是，如前面的示例所示。`transactionManager`
`mode`	`mode`	`proxy`	默认模式（）使用 Spring 的 AOP 处理要代理的带注释的 bean 框架（遵循代理语义，如前所述，应用于方法调用仅通过代理进入）。替代模式（）相反，编织了受影响的类与 Spring 的 AspectJ 事务方面，修改目标类应用于任何类型的方法调用的字节码。AspectJ 编织要求在类路径中以及具有加载时编织（或编译时）编织）启用。（有关如何设置加载时间编织的详细信息，请参见Spring 配置。`proxy``aspectj``spring-aspects.jar`
`proxy-target-class`	`proxyTargetClass`	`false`	仅适用于模式。控制创建哪种类型的事务代理对于用注释注释的类。如果属性设置为，则创建基于类的代理。如果省略该属性，则为标准 JDK 创建基于接口的代理。（有关不同代理类型的详细检查，请参阅代理机制。`proxy``@Transactional``proxy-target-class``true``proxy-target-class``false`
`order`	`order`	`Ordered.LOWEST_PRECEDENCE`	定义应用于注释的 bean 的事务通知的顺序。（有关 AOP 排序相关规则的更多信息建议，请参阅建议排序。没有指定的顺序意味着 AOP 子系统确定建议的顺序。`@Transactional`

在评估事务设置时，派生位置最多优先对于方法。在以下示例中，类是在类级别使用只读事务的设置进行注释，但对同一类中的方法进行注释需要优先于在类级别定义的事务设置。DefaultFooService@TransactionalupdateFoo(Foo)

@Transactional(readOnly = true)
public class DefaultFooService implements FooService {

    public Foo getFoo(String fooName) {
        // ...
    }

    // these settings have precedence for this method
    @Transactional(readOnly = false, propagation = Propagation.REQUIRES_NEW)
    public void updateFoo(Foo foo) {
        // ...
    }
}

`@Transactional`设置

注释是指定接口、类、或方法必须具有事务语义（例如，“启动全新的只读调用此方法时的事务，暂停任何现有事务“）。默认设置如下：@Transactional@Transactional

传播设置为PROPAGATION_REQUIRED.
隔离级别为ISOLATION_DEFAULT.
事务是读写的。
事务超时默认为基础事务的默认超时系统，如果不支持超时，则为无。
任何触发器回滚，以及任何选中的回滚不。RuntimeExceptionErrorException

您可以更改这些默认设置。下表总结了各种注释的属性：@Transactional

表 3.@Transactional设置

财产	类型	描述
价值	`String`	指定要使用的事务管理器的可选限定符。
`transactionManager`	`String`	别名。`value`
`label`	用于向事务添加富有表现力的描述的标签数组。`String`	事务管理器可以评估标签，以将特定于实现的行为与实际事务相关联。
增殖	`enum`: `Propagation`	可选的传播设置。
`isolation`	`enum`: `Isolation`	可选隔离级别。仅适用于传播值 ofor。`REQUIRED``REQUIRES_NEW`
`timeout`	`int`（以秒为单位）	可选的事务超时。仅适用于传播值 ofor。`REQUIRED``REQUIRES_NEW`
`timeoutString`	`String`（以秒为单位）	将秒数指定为值的替代方法，例如，作为占位符。`timeout``String`
`readOnly`	`boolean`	读写事务与只读事务。仅适用于值 ofor。`REQUIRED``REQUIRES_NEW`
`rollbackFor`	对象数组，必须派生自`Class``Throwable.`	必须导致回滚的异常类型的可选数组。
`rollbackForClassName`	异常名称模式数组。	必须导致回滚的异常名称模式的可选数组。
`noRollbackFor`	对象数组，必须派生自`Class``Throwable.`	不得导致回滚的异常类型的可选数组。
`noRollbackForClassName`	异常名称模式数组。	不得导致回滚的异常名称模式的可选数组。

目前，您无法显式控制事务的名称，其中“名称” 表示事务监视器中显示的事务名称（如果适用）（例如，WebLogic 的事务监视器），并在日志记录输出中。对于声明性事务，事务名称始终是完全限定的类名 ++ 事务建议类的方法名称。例如，如果类的方法启动了一个事务，则事务的名称将是：。.handlePayment(..)BusinessServicecom.example.BusinessService.handlePayment

多个事务管理器`@Transactional`

大多数 Spring 应用程序只需要一个事务管理器，但可能存在您希望在单个事务管理器中具有多个独立事务管理器的情况应用。您可以使用注释的 theorattribute 来选择性地指定要使用的标识。这可以是 Bean 名称或限定符值的事务管理器 Bean。例如，使用限定符表示法，您可以将以下 Java 代码与以下事务管理器 Bean 声明相结合在应用程序上下文中：valuetransactionManager@TransactionalTransactionManager

public class TransactionalService {

    @Transactional("order")
    public void setSomething(String name) { ... }

    @Transactional("account")
    public void doSomething() { ... }

    @Transactional("reactive-account")
    public Mono<Void> doSomethingReactive() { ... }
}

以下清单显示了 Bean 声明：

<tx:annotation-driven/>

    <bean  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        ...
        <qualifier value="order"/>
    </bean>

    <bean  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        ...
        <qualifier value="account"/>
    </bean>

    <bean  class="org.springframework.data.r2dbc.connectionfactory.R2dbcTransactionManager">
        ...
        <qualifier value="reactive-account"/>
    </bean>

在这种情况下，各个方法在单独的事务管理器，由、和限定符区分。默认目标 Bean 名称，，如果未找到特定限定的 Bean，则仍使用。TransactionalServiceorderaccountreactive-account<tx:annotation-driven>transactionManagerTransactionManager

自定义撰写批注

如果你发现你反复使用相同的属性和许多不同的方法，Spring的元标注支持让你为您的特定用例定义自定义组合注释。例如，考虑以下注释定义：@Transactional

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Transactional(transactionManager = "order", label = "causal-consistency")
public @interface OrderTx {
}

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Transactional(transactionManager = "account", label = "retryable")
public @interface AccountTx {
}

前面的注释让我们编写上一节中的示例，如下所示：

public class TransactionalService {

    @OrderTx
    public void setSomething(String name) {
        // ...
    }

    @AccountTx
    public void doSomething() {
        // ...
    }
}

在前面的示例中，我们使用语法来定义事务管理器限定符和事务标签，但我们也可以包括传播行为，回滚规则、超时和其他功能。

1.4.7. 事务传播

本节介绍 Spring 中事务传播的一些语义。注意本节不是对事务传播的正确介绍。相反，它详细介绍了 Spring 中有关事务传播的一些语义。

在 Spring 管理的交易中，请注意物理和逻辑事务，以及传播设置如何应用于此差异。

理解`PROPAGATION_REQUIRED`

Spring数据访问和数据访问层与业务或服务层之间的交互

PROPAGATION_REQUIRED强制实施物理事务，无论是本地的当前范围，如果尚不存在事务或参与现有的“外部”事务为更大的范围定义。这是常见调用堆栈安排中的良好默认值在同一线程中（例如，委托给多个存储库方法的服务外观其中所有底层资源都必须参与服务级别事务）。

当传播设置为逻辑事务范围时为应用设置的每个方法创建。每个这样的逻辑事务范围可以单独确定仅回滚状态，具有外部事务范围在逻辑上独立于内部事务范围。在标准行为的情况下，所有这些作用域都是映射到同一物理事务。因此，在内部设置了仅回滚标记事务范围确实会影响外部事务实际提交的机会。PROPAGATION_REQUIREDPROPAGATION_REQUIRED

但是，在内部事务范围设置仅回滚标记的情况下，外部事务尚未决定回滚本身，因此回滚（静默由内部事务范围触发）是意外的。一个对应的是抛出的那个点。这是预期行为，因此事务的调用方永远不会被误导，认为提交是当它真的不是时执行。因此，如果一个内部事务（其中外部调用者不知道）静默地将事务标记为仅回滚，外部调用方仍然调用提交。外部调用方需要接收 anto 清楚地指示已执行回滚。UnexpectedRollbackExceptionUnexpectedRollbackException

理解`PROPAGATION_REQUIRES_NEW`

Spring数据访问和数据访问层与业务或服务层之间的交互

PROPAGATION_REQUIRES_NEW，相反，始终使用每个受影响的事务范围的独立物理事务，从不参与外部范围的现有事务。在这样的安排下，基础资源事务是不同的，因此可以提交或回滚独立，外部事务不受内部事务回滚的影响状态，并在内部事务完成后立即释放其锁。这样独立的内部事务还可以声明自己的隔离级别、超时、和只读设置，并且不继承外部事务的特征。PROPAGATION_REQUIRED

理解`PROPAGATION_NESTED`

PROPAGATION_NESTED使用具有多个保存点的单个物理事务它可以回滚到。这种部分回滚允许内部事务范围触发其范围的回滚，外部事务能够继续尽管某些操作已回滚，但物理事务。此设置通常映射到 JDBC 保存点，因此它仅适用于 JDBC 资源交易。请参阅 Spring 的DataSourceTransactionManager。

1.4.8. 为交易操作提供建议

假设您要同时运行事务操作和一些基本的分析建议。您如何在上下文中对此产生影响？<tx:annotation-driven/>

调用该方法时，希望看到以下操作：updateFoo(Foo)

配置的分析方面将启动。
事务性建议运行。
建议对象上的方法将运行。
事务提交。
分析方面报告整个事务方法调用的确切持续时间。

以下代码显示了前面讨论的简单性能分析方面：

package x.y;

public class SimpleProfiler implements Ordered {

    private int order;

    // allows us to control the ordering of advice
    public int getOrder() {
        return this.order;
    }

    public void setOrder(int order) {
        this.order = order;
    }

    // this method is the around advice
    public Object profile(ProceedingJoinPoint call) throws Throwable {
        Object returnValue;
        StopWatch clock = new StopWatch(getClass().getName());
        try {
            clock.start(call.toShortString());
            returnValue = call.proceed();
        } finally {
            clock.stop();
            System.out.println(clock.prettyPrint());
        }
        return returnValue;
    }
}

建议的顺序通过接口进行控制。有关建议排序的完整详细信息，请参阅建议排序。Ordered

以下配置创建具有分析和按所需顺序应用于它的事务方面：fooService

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean  class="x.y.service.DefaultFooService"/>

    <!-- this is the aspect -->
    <bean  class="x.y.SimpleProfiler">
        <!-- run before the transactional advice (hence the lower order number) -->
        <property name="order" value="1"/>
    </bean>

    <tx:annotation-driven transaction-manager="txManager" order="200"/>

    <aop:config>
            <!-- this advice runs around the transactional advice -->
            <aop:aspect  ref="profiler">
                <aop:pointcut 
                        expression="execution(!void x.y..*Service.*(..))"/>
                <aop:around method="profile" pointcut-ref="serviceMethodWithReturnValue"/>
            </aop:aspect>
    </aop:config>

    <bean  class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
        <property name="url" value="jdbc:oracle:thin:@rj-t42:1521:elvis"/>
        <property name="username" value="scott"/>
        <property name="password" value="tiger"/>
    </bean>

    <bean  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

</beans>

您可以配置任何号码以类似的方式进行的其他方面。

下面的示例创建与前两个示例相同的设置，但使用纯 XML 声明性方法：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean  class="x.y.service.DefaultFooService"/>

    <!-- the profiling advice -->
    <bean  class="x.y.SimpleProfiler">
        <!-- run before the transactional advice (hence the lower order number) -->
        <property name="order" value="1"/>
    </bean>

    <aop:config>
        <aop:pointcut  expression="execution(* x.y..*Service.*(..))"/>
        <!-- runs after the profiling advice (cf. the order attribute) -->

        <aop:advisor advice-ref="txAdvice" pointcut-ref="entryPointMethod" order="2"/>
        <!-- order value is higher than the profiling aspect -->

        <aop:aspect  ref="profiler">
            <aop:pointcut 
                    expression="execution(!void x.y..*Service.*(..))"/>
            <aop:around method="profile" pointcut-ref="serviceMethodWithReturnValue"/>
        </aop:aspect>

    </aop:config>

    <tx:advice  transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>

    <!-- other <bean/> definitions such as a DataSource and a TransactionManager here -->

</beans>

上述配置的结果是具有分析和事务方面按该顺序应用于它。如果您需要分析建议在交易建议之后运行交易建议在出路时，您可以交换分析的价值方面豆的属性，使其高于交易建议的订单价值。fooServiceorder

您可以以类似的方式配置其他方面。

1.4.9. 与方面J一起使用`@Transactional`

你也可以在Spring之外使用Spring Framework的支持。容器通过AspectJ方面。为此，请先为课程添加批注（以及可选的类的方法）与注释，然后将您的应用程序与文件中定义的应用程序链接（编织）。您还必须使用事务配置方面经理。你可以使用 Spring 框架的 IoC 容器来处理依赖注入方面。配置事务的最简单方法管理方面是使用元素并指定属性 toas 中所述@Transactional。因为我们在这里重点介绍在 Spring 容器之外运行的应用程序，我们展示你如何以编程方式做到这一点。@Transactional@Transactionalorg.springframework.transaction.aspectj.AnnotationTransactionAspectspring-aspects.jar<tx:annotation-driven/>modeaspectj

下面的示例演示如何创建事务管理器并配置使用它：AnnotationTransactionAspect

// construct an appropriate transaction manager
DataSourceTransactionManager txManager = new DataSourceTransactionManager(getDataSource());

// configure the AnnotationTransactionAspect to use it; this must be done before executing any transactional methods
AnnotationTransactionAspect.aspectOf().setTransactionManager(txManager);

类上的注释指定默认事务语义用于执行类中的任何公共方法。@Transactional

类中方法的注释将覆盖默认值由类注释（如果存在）给出的事务语义。您可以注释任何方法，无论能见度如何。@Transactional

要编织您的应用程序，您必须构建您使用AspectJ的应用程序（请参阅AspectJ开发指南）或使用加载时间编织。请参阅加载时编织 Spring 框架中的AspectJ 讨论使用 AspectJ 进行加载时间编织。AnnotationTransactionAspect

1.5. 程序化交易管理

Spring 框架提供了两种编程事务管理方法，方法是：

理论。TransactionTemplateTransactionalOperator
直接实施。TransactionManager

春季团队通常推荐用于程序化命令式流和响应式代码中的事务管理。第二种方法类似于使用 JTAAPI，尽管有例外处理不那么麻烦。TransactionTemplateTransactionalOperatorUserTransaction

1.5.1. 使用`TransactionTemplate`

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

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

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();
            }
        });
    }
}

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

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

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

transactionTemplate.execute(new TransactionCallbackWithoutResult() {

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

指定事务设置

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

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...
    }
}

以下示例使用一些自定义事务定义使用 Spring XML 配置进行设置：TransactionTemplate

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

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

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

1.5.2. 使用`TransactionalOperator`

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

必须在事务上下文中运行且显式使用的应用程序代码下面是下一个示例：TransactionalOperator

爪哇岛

科特林

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);
    }
}

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

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

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

爪哇岛

科特林

transactionalOperator.execute(new TransactionCallback<>() {

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

取消信号

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

指定事务设置

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

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);
    }
}

1.5.3. 使用`TransactionManager`

以下部分解释命令式事务和反应式事务的编程用法经理。

使用`PlatformTransactionManager`

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

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);

使用`ReactiveTransactionManager`

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

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)));
});

1.6. 在程序化和声明式事务管理之间进行选择

程序化事务管理通常是一个好主意，只有当你有一个小事务操作数。例如，如果您有一个 Web 应用程序仅对某些更新操作需要事务，您可能不想设置使用 Spring 或任何其他技术的交易代理。在这种情况下，使用可能是一个很好的方法。能够设置交易名称显式也是只能通过使用编程方法才能完成的事情到事务管理。TransactionTemplate

另一方面，如果应用程序具有大量事务操作，声明式事务管理通常是值得的。它保持交易管理脱离业务逻辑，配置起来并不困难。使用 Spring Framework，而不是 EJB CMT，声明式事务的配置成本管理大大减少。

1.7. 交易绑定事件

从 Spring 4.2 开始，事件的侦听器可以绑定到事务的某个阶段。典型的示例是在事务成功完成时处理事件。这样做可以让事件在当前结果时更灵活地使用事务实际上对侦听器很重要。

您可以使用注释注册常规事件侦听器。如果需要将其绑定到事务，请使用。执行此操作时，默认情况下侦听器绑定到事务的提交阶段。@EventListener@TransactionalEventListener

下一个示例演示了此概念。假设组件发布订单创建事件，并且我们想要定义一个侦听器，该侦听器应该只处理该事件一次已发布它的事务已成功提交。以下示例设置这样的事件侦听器：

@Component
public class MyComponent {

    @TransactionalEventListener
    public void handleOrderCreatedEvent(CreationEvent<Order> creationEvent) {
        // ...
    }
}

Theannotation 公开了一个属性，让你自定义侦听器应绑定到的事务阶段。有效阶段是（默认）以及聚合事务完成的阶段（无论是提交还是回滚）。@TransactionalEventListenerphaseBEFORE_COMMITAFTER_COMMITAFTER_ROLLBACKAFTER_COMPLETION

如果没有事务正在运行，则根本不调用侦听器，因为我们无法遵循必需的语义。但是，您可以通过将批注的属性设置为来覆盖该行为。fallbackExecutiontrue

`@TransactionalEventListener`仅适用于由管理的线程绑定事务。由 Reactor 上下文而不是线程本地属性管理的反应式事务，因此从事件侦听器，则没有可以参与的兼容活动事务。`PlatformTransactionManager``ReactiveTransactionManager`

1.8. 特定于应用程序服务器的集成

Spring 的事务抽象通常与应用程序服务器无关。此外 Spring'sclass（可以选择性地执行 JNDI 查找 JTAand对象）自动检测位置后一个对象，因应用程序服务器而异。访问 JTA 可以增强事务语义 — 特别是，支持交易暂停。有关详细信息，请参阅JtaTransactionManagerjavadoc。JtaTransactionManagerUserTransactionTransactionManagerTransactionManager

Spring's是运行Jakarta EE应用程序的标准选择服务器，并且已知可在所有常见服务器上工作。高级功能，例如交易暂停，也适用于许多服务器（包括GlassFish，JBoss和杰罗尼莫），无需任何特殊配置。但是，对于完全支持交易暂停和进一步的高级集成，Spring 包括特殊的适配器适用于 WebLogic Server 和 WebSphere。下面将讨论这些适配器部分。JtaTransactionManager

对于标准方案，包括 WebLogic Server 和 WebSphere，请考虑使用方便的配置元素。配置后，此元素会自动检测底层服务器并选择最佳可用于平台的事务管理器。这意味着您不需要明确配置特定于服务器的适配器类（如以下各节所述）。相反，它们是自动选择的，标准作为默认回退。<tx:jta-transaction-manager/>JtaTransactionManager

1.8.1. IBM WebSphere

在 WebSphere 6.1.0.9 及更高版本上，建议使用的 Spring JTA 事务管理器是。这个特殊的适配器使用 IBM 的 API，在 WebSphere Application Server 6.1.0.9 及更高版本中可用。使用此适配器， Spring 驱动的事务暂停（由发起者暂停和恢复）由 IBM 正式支持。WebSphereUowTransactionManagerUOWManagerPROPAGATION_REQUIRES_NEW

1.8.2. Oracle WebLogic Server

在 WebLogic Server 9.0 或更高版本上，您通常会使用 the，而不是 stockclass。这 normal的特殊WebLogic特定子类支持： Spring 的事务定义在 WebLogic 管理的事务中的全部功能环境，超越标准 JTA 语义。功能包括交易名称，每个事务的隔离级别，并在所有情况下正确恢复事务。WebLogicJtaTransactionManagerJtaTransactionManagerJtaTransactionManager

1.9. 常见问题的解决方案

本节介绍一些常见问题的解决方案。

1.9.1. 对特定事务管理器使用错误的事务管理器`DataSource`

根据您选择的事务技术和要求。正确使用，Spring 框架仅提供简单且可移植的抽象。如果使用全局事务，您必须使用类（或特定于应用程序服务器的子类 it）用于您的所有事务操作。否则，事务基础结构尝试对容器实例等资源执行本地事务。这样的本地事务没有意义，一个好的应用服务器将它们视为错误。PlatformTransactionManagerorg.springframework.transaction.jta.JtaTransactionManagerDataSource

1.10. 更多资源

有关 Spring 框架的事务支持的更多信息，请参阅：

分散式 Spring中的事务，有和没有XA是一个JavaWorld演示，其中 Spring的David Syer将引导您了解分布式的七种模式 Spring 应用程序中的事务，其中三个带有 XA，四个没有。
《Java事务设计策略》是一本书可从InfoQ获得，提供节奏良好的介绍到爪哇中的事务。它还包括有关如何配置的并行示例并使用 Spring 框架和 EJB3 的事务。

Spring数据访问和数据访问层与业务或服务层之间的交互

1. 交易管理

1.1. Spring 框架事务支持模型的优势

1.1.1. 全球交易

1.1.2. 本地交易

1.1.3. Spring 框架的一致编程模型

1.2. 理解 Spring 框架事务抽象

1.2.1. 休眠事务设置

1.3. 将资源与事务同步

1.3.1. 高级同步方法

1.3.2. 低级同步方法

1.3.3. ​​TransactionAwareDataSourceProxy​​

1.4. 声明式事务管理

1.4.1. 理解 Spring 框架的声明式事务实现

1.4.2. 声明式事务实现示例

1.4.3. 回滚声明式事务

1.4.4. 为不同的 bean 配置不同的事务语义

1.4.5. <tx：建议/>设置

1.4.6. 使用​​@Transactional​​

​​@Transactional​​设置

多个事务管理器​​@Transactional​​

自定义撰写批注

1.4.7. 事务传播

理解​​PROPAGATION_REQUIRED​​

理解​​PROPAGATION_REQUIRES_NEW​​

理解​​PROPAGATION_NESTED​​

1.4.8. 为交易操作提供建议

1.4.9. 与方面J一起使用​​@Transactional​​

1.5. 程序化交易管理

1.5.1. 使用​​TransactionTemplate​​

指定事务设置

1.5.2. 使用​​TransactionalOperator​​

取消信号

指定事务设置

1.5.3. 使用​​TransactionManager​​

使用​​PlatformTransactionManager​​

使用​​ReactiveTransactionManager​​

1.6. 在程序化和声明式事务管理之间进行选择

1.7. 交易绑定事件

1.8. 特定于应用程序服务器的集成

1.8.1. IBM WebSphere

1.8.2. Oracle WebLogic Server

1.9. 常见问题的解决方案

1.9.1. 对特定事务管理器使用错误的事务管理器​​DataSource​​

1.10. 更多资源

相关文章

1.3.3. `TransactionAwareDataSourceProxy`

1.4.6. 使用`@Transactional`

`@Transactional`设置

多个事务管理器`@Transactional`

理解`PROPAGATION_REQUIRED`

理解`PROPAGATION_REQUIRES_NEW`

理解`PROPAGATION_NESTED`

1.4.9. 与方面J一起使用`@Transactional`

1.5.1. 使用`TransactionTemplate`

1.5.2. 使用`TransactionalOperator`

1.5.3. 使用`TransactionManager`

使用`PlatformTransactionManager`

使用`ReactiveTransactionManager`

1.9.1. 对特定事务管理器使用错误的事务管理器`DataSource`