Spring和Spring Boot事务讲解和案例示范

引言

Spring框架提供了强大的事务管理支持，使得开发者能够更轻松地实现事务控制。在本篇文章中，我们将深入探讨Spring的事务管理机制，特别是编程式事务管理、声明式事务管理以及在多数据源环境下的事务处理。

第一章 编程式事务管理

编程式事务管理是指开发者在代码中手动控制事务的生命周期。对于基于POJO（Plain Old Java Object）的应用，这种方式是唯一的选择。编程式事务管理通常使用Spring的TransactionManager接口来实现事务的开始、提交和回滚。以下是编程式事务管理的一些重要概念和步骤。

1. 编程式事务管理的基本步骤

在编程式事务管理中，开发者需要显式地调用beginTransaction()、commit()和rollback()等方法来管理事务。以下是实现这一过程的步骤：

1. 获取PlatformTransactionManager实例：通过Spring的应用上下文获取事务管理器实例。
2. 创建事务定义：定义事务的传播行为和隔离级别等属性。
3. 开始事务：通过事务管理器的getTransaction()方法获取当前事务。
4. 执行业务逻辑：在事务中执行需要原子性的数据操作。
5. 提交或回滚事务：根据业务逻辑的执行结果选择提交或回滚。

2. 示例代码

下面是一个简单的电子商务交易系统中编程式事务管理的示例代码。假设我们有一个OrderService类，用于处理订单的创建：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

public class OrderService {

    @Autowired
    private PlatformTransactionManager transactionManager;

    public void createOrder(Order order) {
        // 定义事务属性
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setPropagationBehavior(DefaultTransactionDefinition.PROPAGATION_REQUIRED);
        
        // 开始事务
        TransactionStatus status = transactionManager.getTransaction(def);
        
        try {
            // 执行业务逻辑，例如保存订单
            saveOrder(order);
            
            // 提交事务
            transactionManager.commit(status);
        } catch (Exception e) {
            // 回滚事务
            transactionManager.rollback(status);
            throw new RuntimeException("Failed to create order", e);
        }
    }

    private void saveOrder(Order order) {
        // 保存订单到数据库的逻辑
    }
}

在上面的代码中，我们首先定义了事务的传播行为为PROPAGATION_REQUIRED，这意味着如果当前存在事务，则加入该事务；否则新建一个事务。接着，通过transactionManager.getTransaction(def)开始事务，执行业务逻辑后根据情况决定提交或回滚事务。

3. 编程式事务管理的优缺点

优点：

• 灵活性高：开发者可以在代码中完全控制事务的执行过程，适合复杂业务逻辑的处理。
• 透明性：可以清晰地看到每一步的事务处理过程，便于调试。

缺点：

• 代码冗长：每次处理事务都需要写大量的代码，降低了可读性和可维护性。
• 容易出错：手动管理事务增加了出错的可能性，尤其是在复杂的业务流程中。

第二章 声明式事务管理

声明式事务管理是Spring框架提供的一种简化事务处理的方式，允许开发者通过配置而非代码控制事务的行为。这种方式大大降低了代码的复杂性，提升了可维护性和可读性。声明式事务管理可以通过XML配置或者注解（如@Transactional）来实现。

1. 使用TransactionProxyFactoryBean

TransactionProxyFactoryBean是Spring提供的一种基于代理的声明式事务管理方式。通过配置此Bean，开发者可以定义事务的边界，而不需要在业务逻辑中显式地处理事务。

示例代码：

首先，在Spring的配置文件中定义一个TransactionProxyFactoryBean：

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

<bean id="orderService" class="com.example.OrderService">
    <property name="dataSource" ref="dataSource"/>
</bean>

<bean id="transactionProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    <property name="target" ref="orderService"/>
    <property name="transactionManager" ref="transactionManager"/>
    <property name="transactionAttributes">
        <map>
            <entry key="createOrder" value="PROPAGATION_REQUIRED"/>
        </map>
    </property>
</bean>

在上面的示例中，TransactionProxyFactoryBean将OrderService作为目标Bean，定义createOrder方法的事务属性为PROPAGATION_REQUIRED。

2. 基于@Transactional的声明式事务管理

随着Spring 2.0引入的@Transactional注解，声明式事务管理变得更加简单和直观。通过在方法或类上添加该注解，开发者可以指定该方法或类所需的事务属性。

示例代码：

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class OrderService {

    @Transactional(propagation = Propagation.REQUIRED)
    public void createOrder(Order order) {
        // 保存订单逻辑
        saveOrder(order);
    }

    private void saveOrder(Order order) {
        // 数据库保存逻辑
    }
}

在上面的代码中，@Transactional注解自动为createOrder方法添加了事务管理，开发者不再需要手动管理事务的开始和提交。

3. 事务传播行为

Spring定义了多种事务传播行为，开发者可以根据业务需求选择合适的策略。常用的传播行为包括：

• PROPAGATION_REQUIRED：如果当前有事务，则加入该事务；否则新建一个事务。
• PROPAGATION_REQUIRES_NEW：总是新建一个事务。
• PROPAGATION_NESTED：如果当前有事务，则嵌套事务；否则新建一个事务。

第三章 基于AspectJ的AOP配置事务

AspectJ是Spring提供的强大AOP支持，能够在方法执行前后进行横切逻辑处理。在基于AspectJ的配置中，事务管理是通过切面（Aspect）来实现的，这样可以将事务逻辑与业务逻辑分离，使得代码更加清晰。

1. AspectJ事务管理的配置

为了使用AspectJ配置事务管理，首先需要在Spring配置中启用AspectJ支持：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/tx
           http://www.springframework.org/schema/tx/spring-tx.xsd">

    <tx:annotation-driven transaction-manager="transactionManager"/>
    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

</beans>

2. 创建切面

接下来，创建一个切面类来处理事务逻辑：

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.transaction.annotation.Transactional;

@Aspect
public class TransactionAspect {

    @Pointcut("execution(* com.example..*(..))") // 定义切入点
    public void transactionPointcut() {}

    @Transactional
    public void aroundTransaction(ProceedingJoinPoint joinPoint) throws Throwable {
        try {
            joinPoint.proceed(); // 执行目标方法
        } catch (Throwable ex) {
            // 处理异常逻辑
            throw ex;
        }
    }
}

在上面的代码中，TransactionAspect类定义了一个切入点，用于匹配com.example包下的所有方法，并在方法执行前后处理事务。

3. 优缺点分析

优点：

• 解耦性：业务逻辑与事务逻辑分离，提高了代码的可读性。
• 可复用性：切面可以在多个业务逻辑中复用，减少代码重复。

缺点：

• 学习曲线：对于初学者来说，AOP的概念和配置可能会增加学习难度。
• 性能开销：切面处理增加了一定的性能开销，尤其是在高频调用的场景下。

第四章 多数据源下的事务管理

在复杂的电子商务系统中，往往需要使用多个数据源来存储不同类型的数据。例如，一个系统可能需要一个数据源来存储用户信息，另一个数据源来存储订单数据。处理多数据源的事务管理是一个重要的挑战，因为不同的数据源之间的事务管理需要确保一致性和隔离性。

1. 多数据源的配置

在Spring中，可以通过配置多个DataSource来支持多数据源。以下是一个简单的多数据源配置示例：

<bean id="dataSource1" class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/db1"/>
    <property name="username" value="user1"/>
    <property name="password" value="password1"/>
</bean>

<bean id="dataSource2" class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/db2"/>
    <property name="username" value="user2"/>
    <property name="password" value="password2"/>
</bean>

2. 配置事务管理器

对于多数据源，我们需要配置一个ChainedTransactionManager，以便在同一个事务中管理多个数据源：

<bean id="transactionManager" class="org.springframework.transaction.support.TransactionSynchronizationManager">
    <property name="transactionManagers">
        <list>
            <ref bean="dataSource1TransactionManager"/>
            <ref bean="dataSource2TransactionManager"/>
        </list>
    </property>
</bean>

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

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

3. 使用@Transactional管理多数据源事务

在多数据源的场景中，使用@Transactional注解时需要明确指定事务管理器，以确保事务能够跨多个数据源进行管理：

import org.springframework.transaction.annotation.Transactional;

public class OrderService {

    @Transactional(transactionManager = "transactionManager")
    public void createOrder(Order order, User user) {
        // 保存订单到dataSource1
        saveOrder(order);
        
        // 保存用户到dataSource2
        saveUser(user);
    }
}

在上述代码中，@Transactional注解的transactionManager属性指定了事务管理器，这样可以确保在createOrder方法中对多个数据源的操作都在同一个事务内执行。

4. 事务的一致性与隔离性

在多数据源环境下，确保事务的一致性和隔离性是非常重要的。开发者需要关注以下几个方面：

• 事务传播行为：确保操作在同一事务中执行，避免出现部分提交的情况。
• 隔离级别：根据业务需求选择合适的隔离级别，防止数据竞争和不可重复读等问题。

第五章 rollbackFor 属性

1. 默认事务回滚行为

默认情况下，Spring对事务的回滚行为如下：

• 自动回滚：当抛出 RuntimeException 或其子类异常时，事务会自动回滚。
• 不回滚：当抛出 Exception（即检查型异常）时，事务不会自动回滚，除非显式指定。

例如，以下代码在抛出 RuntimeException 时会回滚事务，但抛出 Exception 时不会回滚：

@Transactional
public void processOrder(Order order) throws Exception {
    // 订单处理逻辑
    if (someConditionFails()) {
        throw new Exception("订单处理失败！"); // 默认不会回滚事务
    }
    if (someOtherConditionFails()) {
        throw new RuntimeException("订单处理过程中出现运行时错误！"); // 默认会回滚事务
    }
}

在上述示例中，Exception 是检查型异常，Spring不会自动回滚它引发的事务。

2. 使用 rollbackFor 属性进行异常回滚控制

如果我们希望在抛出 Exception 或其他检查型异常时也回滚事务，可以通过 @Transactional 注解的 rollbackFor 属性来指定需要回滚的异常类型。

示例：指定在抛出 Exception 时回滚事务

@Transactional(rollbackFor = Exception.class)
public void processOrder(Order order) throws Exception {
    // 订单处理逻辑
    if (someConditionFails()) {
        throw new Exception("订单处理失败！"); // 现在会回滚事务
    }
    if (someOtherConditionFails()) {
        throw new RuntimeException("订单处理过程中出现运行时错误！"); // 依然会回滚事务
    }
}

在这个示例中，@Transactional(rollbackFor = Exception.class) 明确指定了当 Exception 被抛出时，事务也会回滚。

使用多个异常类型

可以指定多个异常类型，在多个异常类型下触发事务回滚：

@Transactional(rollbackFor = {Exception.class, SQLException.class})
public void processOrder(Order order) throws Exception {
    // 订单处理逻辑
    if (someConditionFails()) {
        throw new SQLException("数据库异常！"); // 现在会回滚事务
    }
    if (someOtherConditionFails()) {
        throw new Exception("订单处理失败！"); // 现在会回滚事务
    }
}

3. 在电商交易系统中的应用示例

在电商交易系统中，处理订单的过程中可能会发生多种不同类型的异常。比如，订单处理中可能抛出数据库相关的 SQLException，或者业务逻辑失败的 BusinessException。我们可以通过 rollbackFor 指定这些异常类型，以确保订单处理过程中发生这些异常时事务会正确回滚。

示例：电商系统中的订单处理

public class OrderService {
    @Transactional(rollbackFor = {SQLException.class, BusinessException.class})
    public void processOrder(Order order) throws BusinessException, SQLException {
        // 更新库存
        updateInventory(order);

        // 扣款操作
        if (!deductPayment(order)) {
            throw new BusinessException("扣款失败！");
        }

        // 提交订单
        if (!submitOrder(order)) {
            throw new SQLException("订单提交失败！");
        }
    }
    
    private void updateInventory(Order order) {
        // 库存更新逻辑
    }

    private boolean deductPayment(Order order) {
        // 扣款逻辑
        return false; // 模拟扣款失败
    }

    private boolean submitOrder(Order order) throws SQLException {
        // 订单提交逻辑
        return false; // 模拟数据库异常
    }
}

在上述示例中：

• 如果 deductPayment 方法失败，会抛出 BusinessException，这将导致事务回滚。
• 如果 submitOrder 方法失败，抛出的 SQLException 也会触发事务回滚。

第六章 Spring Boot 中使用 @Transactional 注解

在Spring Boot项目中，使用@Transactional注解非常简单，它主要用于控制业务逻辑中的事务处理，确保数据库操作的原子性。Spring Boot自动集成了事务管理，因此你无需进行过多的配置，只需要在方法或类上使用@Transactional注解即可。

1. Spring Boot 中的基本事务配置

默认情况下，Spring Boot会自动为你的项目启用事务管理。你只需要添加以下依赖：

Maven依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

Spring Boot使用spring-boot-starter-data-jpa为JPA提供支持，事务管理器会自动配置。

2. 启用事务管理

在Spring Boot中，事务管理默认是启用的。如果你使用的是非Spring Boot项目，你可能需要使用@EnableTransactionManagement注解来启用事务管理。但在Spring Boot中，默认就支持该功能，无需额外配置。

如果需要显式启用，可以通过在配置类上添加@EnableTransactionManagement注解：

@Configuration
@EnableTransactionManagement
public class TransactionConfig {
    // 自定义事务管理器（如果需要）
}

3. 使用 @Transactional 注解

@Transactional 注解可以用在类或方法上，控制在这些方法中的所有数据库操作是否作为一个事务执行。默认情况下，它会对运行时异常进行回滚。

在方法上使用 @Transactional

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    @Transactional
    public void processOrder(Order order) {
        // 执行数据库操作，例如保存订单
        orderRepository.save(order);

        // 执行其他相关操作，例如更新库存
        updateInventory(order);

        // 如果任何操作失败，抛出异常，事务将回滚
        if (!order.isValid()) {
            throw new RuntimeException("订单验证失败，事务回滚！");
        }
    }

    private void updateInventory(Order order) {
        // 更新库存逻辑
    }
}

在上面的示例中，processOrder方法标记为@Transactional，如果方法中抛出了RuntimeException或其子类的异常，所有的数据库操作都会被回滚。

在类上使用 @Transactional

你也可以将@Transactional注解应用于类上，标记类中的所有公共方法都参与事务管理：

@Service
@Transactional
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    public void processOrder(Order order) {
        orderRepository.save(order);
    }

    public void cancelOrder(Long orderId) {
        orderRepository.deleteById(orderId);
    }
}

在这个类中，processOrder和cancelOrder方法都将在事务中运行，任何一个方法抛出异常都会导致事务回滚。

4. 事务的传播行为和隔离级别

你可以通过@Transactional注解的属性自定义事务的传播行为和隔离级别：

• 传播行为：可以通过propagation属性控制，默认值为Propagation.REQUIRED。例如，如果一个事务已经存在，Spring将加入到该事务中；如果不存在，则创建一个新的事务。

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void createNewOrder(Order order) {
    orderRepository.save(order);
}

• 隔离级别：可以通过isolation属性设置，控制数据库并发访问的行为。默认值为Isolation.DEFAULT，即使用数据库的默认隔离级别。

@Transactional(isolation = Isolation.SERIALIZABLE)
public void updateOrder(Order order) {
    orderRepository.save(order);
}

5. 完整的 Spring Boot 事务管理案例

接下来，我们将构建一个完整的Spring Boot事务管理示例，展示如何使用@Transactional注解处理事务。

项目结构

src
 ├── main
 │   ├── java
 │   │   └── com.example.transactiondemo
 │   │       ├── TransactionDemoApplication.java
 │   │       ├── model
 │   │       │   └── Order.java
 │   │       ├── repository
 │   │       │   └── OrderRepository.java
 │   │       └── service
 │   │           └── OrderService.java
 ├── resources
 │   └── application.properties

5.1 Order 实体类

package com.example.transactiondemo.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Order {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String description;
    private boolean valid;

    // Getters and Setters
}

5.2 OrderRepository 接口

package com.example.transactiondemo.repository;

import com.example.transactiondemo.model.Order;
import org.springframework.data.jpa.repository.JpaRepository;

public interface OrderRepository extends JpaRepository<Order, Long> {
}

5.3 OrderService 服务类

package com.example.transactiondemo.service;

import com.example.transactiondemo.model.Order;
import com.example.transactiondemo.repository.OrderRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    @Transactional
    public void processOrder(Order order) {
        // 保存订单
        orderRepository.save(order);

        // 假设更新库存出错，抛出异常
        if (!order.isValid()) {
            throw new RuntimeException("订单无效，事务回滚！");
        }
    }

    @Transactional
    public void cancelOrder(Long orderId) {
        orderRepository.deleteById(orderId);
    }
}

5.4 TransactionDemoApplication 应用启动类

package com.example.transactiondemo;

import com.example.transactiondemo.model.Order;
import com.example.transactiondemo.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class TransactionDemoApplication implements CommandLineRunner {

    @Autowired
    private OrderService orderService;

    public static void main(String[] args) {
        SpringApplication.run(TransactionDemoApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        // 创建并处理订单
        Order order = new Order();
        order.setDescription("新订单");
        order.setValid(false);  // 模拟订单无效，抛出异常回滚事务

        try {
            orderService.processOrder(order);
        } catch (RuntimeException e) {
            System.out.println("事务回滚，订单处理失败！");
        }
    }
}

5.5 配置文件 application.properties

spring.datasource.url=jdbc:mysql://localhost:3306/transactiondemo
spring.datasource.username=root
spring.datasource.password=password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update

5.6 运行结果

当运行该应用程序时，创建的订单由于 valid 属性设置为 false，会触发异常，导致事务回滚。数据库中不会插入该订单的数据，保证了数据的完整性和一致性。

第七章 常见问题及解决方案

在实际开发中，使用Spring事务管理时可能会遇到一些常见问题。以下是一些常见问题及其解决方案：

1. 事务未生效

问题：在使用@Transactional时，事务未生效，方法执行后数据仍然被提交。

解决方案：

• 确保方法是public的，Spring的代理机制要求事务方法必须是公共的。
• 确保使用@Transactional注解的方法被Spring管理，即该方法不能在同一类中被直接调用。

2. 数据库连接泄漏

问题：由于长时间未关闭数据库连接，导致连接池资源耗尽。

解决方案：

• 确保在每个事务结束后正确关闭连接，Spring会自动处理事务结束时的连接释放。
• 在使用编程式事务时，确保在异常处理逻辑中回滚事务并关闭连接。

3. 事务回滚未生效

问题：当异常发生时，事务未按预期回滚。

解决方案：

• 默认情况下，Spring只会对运行时异常（RuntimeException）进行回滚，确保抛出的异常类型是运行时异常。
• 可以在@Transactional注解中设置rollbackFor属性，指定需要回滚的异常类型。

4. 多数据源事务管理问题

问题：在多数据源环境下，事务提交不一致，部分数据提交成功，部分数据失败。

解决方案：

• 确保使用ChainedTransactionManager或类似的事务管理器来处理多个数据源的事务。
• 检查每个数据源的事务配置，确保一致性和正确的事务传播行为。