【Spring Framework】 Spring 事务管理

cangloe

于 2024-07-26 22:32:19 发布

阅读量383

点赞数 4

分类专栏： java 文章标签： spring 数据库 sql

本文链接：https://blog.csdn.net/u013675821/article/details/140725590

版权

java 专栏收录该内容

36 篇文章 0 订阅

订阅专栏

Spring 事务管理是 Spring 框架中的一项核心功能，用于管理应用程序中的事务。Spring 通过简化事务处理，提供了一种一致的编程模型，使开发人员可以轻松地在应用程序中实现事务管理。Spring 事务可以跨越多个数据库访问和业务操作，保证数据的一致性和完整性。本文将详细介绍 Spring 事务的概念、使用方法以及常见的配置方式。

一、事务的概念

在计算机科学中，事务（Transaction）是一系列操作的集合，这些操作作为一个单一的逻辑单元执行。事务具有以下四个特性，通常被称为 ACID 特性：

原子性（Atomicity）：事务是一个不可分割的工作单元，事务中的所有操作要么全部完成，要么全部不完成。
一致性（Consistency）：事务执行之前和执行之后，数据库的状态必须是一致的，即数据库从一个一致性状态转换到另一个一致性状态。
隔离性（Isolation）：在事务执行过程中，其他事务不能访问同一数据，事务之间的执行是相互隔离的。
持久性（Durability）：事务执行成功后，对数据库的更改是持久的，即使系统发生故障也不会丢失。

二、Spring 事务管理

Spring 事务管理是 Spring 提供的用于管理事务的功能模块。Spring 提供了两种主要的事务管理方式：

编程式事务管理：通过编写代码手动管理事务，通常使用 TransactionTemplate 或 PlatformTransactionManager。
声明式事务管理：通过注解或 XML 配置声明事务，Spring 自动管理事务的开始、提交和回滚。

1. 编程式事务管理

编程式事务管理允许开发者在代码中手动控制事务的开始、提交和回滚，适用于对事务管理有高度自定义需求的场景。

代码示例

package com.example.transaction;

import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

public class TransactionExample {

    private final PlatformTransactionManager transactionManager;

    public TransactionExample(PlatformTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    public void performTransaction() {
        // 定义事务属性
        TransactionDefinition definition = new DefaultTransactionDefinition();

        // 获取事务状态
        TransactionStatus status = transactionManager.getTransaction(definition);

        try {
            // 执行业务逻辑
            System.out.println("Performing transactional operation...");

            // 提交事务
            transactionManager.commit(status);
            System.out.println("Transaction committed successfully.");
        } catch (Exception e) {
            // 回滚事务
            transactionManager.rollback(status);
            System.out.println("Transaction rolled back due to an error: " + e.getMessage());
        }
    }
}

代码解析

PlatformTransactionManager：Spring 提供的事务管理器接口，定义了事务的基本操作。
TransactionDefinition：定义事务的属性，如隔离级别、传播行为等。
TransactionStatus：表示事务的当前状态，用于提交或回滚事务。

示例输出

Performing transactional operation...
Transaction committed successfully.

2. 声明式事务管理

声明式事务管理是 Spring 提供的一种更简单、更灵活的事务管理方式，开发者可以通过注解或 XML 配置来声明事务的属性，Spring 自动管理事务的开始、提交和回滚。

注解方式

Spring 提供了一组注解用于声明事务：

@Transactional：用于声明方法或类需要事务支持。
@EnableTransactionManagement：用于启用 Spring 的事务管理功能。

代码示例

package com.example.service;

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

@Service
public class UserService {

    @Transactional
    public void createUser(String username, String password) {
        // 创建用户
        System.out.println("Creating user: " + username);

        // 模拟抛出异常
        if ("error".equals(username)) {
            throw new RuntimeException("Simulated exception");
        }

        System.out.println("User created successfully.");
    }
}

配置类

package com.example.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

@Configuration
@EnableTransactionManagement
@ComponentScan(basePackages = "com.example") // 扫描指定包下的组件
public class AppConfig {

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/testdb");
        dataSource.setUsername("root");
        dataSource.setPassword("password");
        return dataSource;
    }

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

测试程序

package com.example;

import com.example.config.AppConfig;
import com.example.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        UserService userService = context.getBean(UserService.class);

        try {
            userService.createUser("Alice", "password123");
            userService.createUser("error", "password123"); // 触发异常
        } catch (Exception e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
    }
}

示例输出

Creating user: Alice
User created successfully.
Creating user: error
Exception caught: Simulated exception

XML 配置方式

Spring 还支持通过 XML 配置声明事务，适用于不使用注解的项目。

XML 配置示例

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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/tx
           http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 数据源配置 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
        <property name="username" value="root"/>
        <property name="password" value="password"/>
    </bean>

    <!-- 事务管理器配置 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 启用事务注解支持 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

    <!-- 扫描包路径 -->
    <context:component-scan base-package="com.example"/>

    <!-- 服务类配置 -->
    <bean id="userService" class="com.example.service.UserService"/>
</beans>

服务类示例

package com.example.service;

import org.springframework.transaction.annotation.Transactional;

public class UserService {

    @Transactional
    public void createUser(String username, String password) {
        // 创建用户
        System.out.println("Creating user: " + username);

        // 模拟抛出异常
        if ("error".equals(username)) {
            throw new RuntimeException("Simulated exception");
        }

        System.out.println("User created successfully.");
    }
}

测试程序

package com.example;

import com.example.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = context.getBean(UserService.class);

        try {
            userService.createUser("Alice", "password123");
            userService.createUser("error", "password123"); // 触发异常
        } catch (Exception e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
    }
}

示例输出

Creating user: Alice
User created successfully.
Creating user: error
Exception caught: Simulated exception

三、事务的传播行为

Spring 提供了多种事务传播行为，定义了事务方法如何传播或参与现有事务中。常见的传播行为如下：

PROPAGATION_REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。是默认的传播行为。
PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务方式执行。
PROPAGATION_MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
PROPAGATION_REQUIRES_NEW：无论当前是否存在事务，都创建一个新的事务。如果当前存在事务，则挂起该事务。
**

PROPAGATION_NOT_SUPPORTED**：以非事务方式执行，如果当前存在事务，则挂起该事务。

PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED：如果当前存在事务，则创建一个嵌套事务来执行；如果当前没有事务，则与 PROPAGATION_REQUIRED 类似。

代码示例

package com.example.service;

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

@Service
public class OrderService {

    @Transactional(propagation = Propagation.REQUIRED)
    public void createOrder(String orderId) {
        System.out.println("Creating order: " + orderId);
        // 执行订单创建逻辑

        // 调用辅助方法
        auxiliaryMethod(orderId);
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void auxiliaryMethod(String orderId) {
        System.out.println("Executing auxiliary operation for order: " + orderId);
        // 执行辅助操作逻辑

        // 模拟抛出异常
        if ("order123".equals(orderId)) {
            throw new RuntimeException("Simulated exception in auxiliaryMethod");
        }
    }
}

测试程序

package com.example;

import com.example.config.AppConfig;
import com.example.service.OrderService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        OrderService orderService = context.getBean(OrderService.class);

        try {
            orderService.createOrder("order123");
        } catch (Exception e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
    }
}

示例输出

Creating order: order123
Executing auxiliary operation for order: order123
Exception caught: Simulated exception in auxiliaryMethod

解析

在上面的代码中，createOrder 方法具有 PROPAGATION_REQUIRED 的传播行为，它将尝试参与现有的事务。如果没有现有事务，则会创建一个新的事务。auxiliaryMethod 方法具有 PROPAGATION_REQUIRES_NEW 的传播行为，它将总是创建一个新的事务，即使存在现有事务。这意味着 auxiliaryMethod 方法的事务与 createOrder 方法的事务是相互独立的。

四、事务的隔离级别

事务的隔离级别定义了一个事务中的更改在提交之前对其他事务的可见性。Spring 支持的事务隔离级别如下：

ISOLATION_DEFAULT：使用数据库默认的隔离级别。
ISOLATION_READ_UNCOMMITTED：允许读取未提交的数据，可能导致脏读、不可重复读和幻读。
ISOLATION_READ_COMMITTED：只能读取已提交的数据，可以防止脏读，但可能导致不可重复读和幻读。
ISOLATION_REPEATABLE_READ：确保在同一事务中多次读取同一数据的结果一致，可以防止脏读和不可重复读，但可能导致幻读。
ISOLATION_SERIALIZABLE：最高隔离级别，确保事务完全隔离，可以防止脏读、不可重复读和幻读，但性能最差。

示例代码

package com.example.service;

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

@Service
public class AccountService {

    @Transactional(isolation = Isolation.REPEATABLE_READ)
    public void transferMoney(String fromAccount, String toAccount, double amount) {
        System.out.println("Transferring " + amount + " from " + fromAccount + " to " + toAccount);
        // 执行转账逻辑
    }
}

测试程序

package com.example;

import com.example.config.AppConfig;
import com.example.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        AccountService accountService = context.getBean(AccountService.class);

        accountService.transferMoney("Alice", "Bob", 100.0);
    }
}

示例输出

Transferring 100.0 from Alice to Bob

解析

在上面的代码中，transferMoney 方法被配置为使用 ISOLATION_REPEATABLE_READ 隔离级别。这意味着在该方法中多次读取同一数据时，结果将保持一致，防止了不可重复读现象。

五、事务的回滚和提交

Spring 事务可以根据业务逻辑的需要选择性地回滚或提交。通常情况下，Spring 事务会在遇到 RuntimeException 或其子类异常时自动回滚，但不会在遇到检查异常（CheckedException）时回滚，除非在 @Transactional 注解中显式配置。

1. 自动回滚

Spring 默认会在 RuntimeException 或 Error 异常出现时自动回滚事务。

示例代码

package com.example.service;

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

@Service
public class BookingService {

    @Transactional
    public void bookTicket(String user, String event) {
        System.out.println("Booking ticket for " + user + " to " + event);

        // 模拟抛出运行时异常
        if ("errorUser".equals(user)) {
            throw new RuntimeException("Simulated runtime exception");
        }

        System.out.println("Ticket booked successfully.");
    }
}

测试程序

package com.example;

import com.example.config.AppConfig;
import com.example.service.BookingService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        BookingService bookingService = context.getBean(BookingService.class);

        try {
            bookingService.bookTicket("Alice", "Concert");
            bookingService.bookTicket("errorUser", "Concert"); // 触发异常
        } catch (Exception e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
    }
}

示例输出

Booking ticket for Alice to Concert
Ticket booked successfully.
Booking ticket for errorUser to Concert
Exception caught: Simulated runtime exception

解析

在上面的代码中，当 bookTicket 方法抛出 RuntimeException 时，Spring 会自动回滚事务。

2. 手动指定回滚规则

Spring 允许开发者在 @Transactional 注解中指定需要回滚的异常类型。

示例代码

package com.example.service;

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

@Service
public class PaymentService {

    @Transactional(rollbackFor = {IllegalArgumentException.class})
    public void processPayment(String account, double amount) {
        System.out.println("Processing payment of " + amount + " for account: " + account);

        // 模拟抛出检查异常
        if (amount < 0) {
            throw new IllegalArgumentException("Negative amount not allowed");
        }

        System.out.println("Payment processed successfully.");
    }
}

测试程序

package com.example;

import com.example.config.AppConfig;
import com.example.service.PaymentService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        PaymentService paymentService = context.getBean(PaymentService.class);

        try {
            paymentService.processPayment("Alice", 100.0);
            paymentService.processPayment("Bob", -50.0); // 触发异常
        } catch (Exception e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
    }
}

示例输出

Processing payment of 100.0 for account: Alice
Payment processed successfully.
Processing payment of -50.0 for account: Bob
Exception caught: Negative amount not allowed

解析

在上面的代码中，processPayment 方法被配置为在抛出 IllegalArgumentException 时回滚事务。即使 IllegalArgumentException 是一个检查异常，Spring 也会根据配置进行回滚。

六、Spring 事务管理器

Spring 提供了多种事务管理器实现，用于支持不同类型的数据访问和持久化技术：

DataSourceTransactionManager：用于管理 JDBC 数据源的事务。
JpaTransactionManager：用于管理 JPA 实体管理器的事务。
HibernateTransactionManager：用于管理 Hibernate 会话的事务。
JtaTransactionManager：用于管理 Java EE 应用程序中的全局事务。

示例配置

package com.example.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.orm.jpa.JpaTransactionManager

;
import org.springframework.orm.hibernate5.HibernateTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;

@Configuration
public class TransactionManagerConfig {

    // JDBC 事务管理器
    @Bean
    public PlatformTransactionManager jdbcTransactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    // JPA 事务管理器
    @Bean
    public PlatformTransactionManager jpaTransactionManager() {
        return new JpaTransactionManager();
    }

    // Hibernate 事务管理器
    @Bean
    public PlatformTransactionManager hibernateTransactionManager() {
        return new HibernateTransactionManager();
    }
}

解析

在上面的配置中，我们定义了三种不同的事务管理器：JDBC 事务管理器、JPA 事务管理器和 Hibernate 事务管理器。开发者可以根据项目的实际需求选择合适的事务管理器。

七、Spring 事务常见问题

1. 事务不生效

事务不生效通常是由于以下原因导致的：

缺少 @EnableTransactionManagement 注解或 <tx:annotation-driven/> 配置。
事务方法没有抛出异常，导致事务没有回滚。
事务方法被同一类中的其他方法调用，导致代理失效。
事务注解放在接口而不是实现类上。

2. 事务传播行为不当

事务传播行为不当可能导致事务的传播逻辑与预期不符，需要仔细分析事务传播的场景和需求，选择合适的传播行为。

3. 数据库连接池配置不当

数据库连接池配置不当可能导致事务执行过程中出现连接问题，如连接超时、连接泄漏等。建议合理配置连接池参数，如最大连接数、超时时间等。

八、总结

Spring 事务管理提供了一种灵活、强大的方式来管理应用程序中的事务。通过使用 Spring 事务，开发者可以轻松地实现数据的一致性和完整性。无论是编程式事务管理还是声明式事务管理，Spring 都能很好地支持各种场景的事务需求。在实际项目中，开发者应根据业务需求合理选择事务传播行为、隔离级别和事务管理器，以实现高效的事务管理。

cangloe

关注

4
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
【Spring Framework】 Spring 事务管理

Spring 事务管理提供了一种灵活、强大的方式来管理应用程序中的事务。通过使用 Spring 事务，开发者可以轻松地实现数据的一致性和完整性。无论是编程式事务管理还是声明式事务管理，Spring 都能很好地支持各种场景的事务需求。在实际项目中，开发者应根据业务需求合理选择事务传播行为、隔离级别和事务管理器，以实现高效的事务管理。
复制链接

扫一扫

专栏目录