深入理解与实践Java事务管理技术

小码快撩

已于 2024-04-26 16:41:46 修改

阅读量9.7k

点赞数 27

文章标签： java 分布式开发语言

于 2024-03-15 10:15:00 首次发布

本文链接：https://blog.csdn.net/2301_78813969/article/details/136701697

版权

引言

在企业级应用开发中，事务管理是不可或缺的一部分，它确保了数据操作的原子性和一致性。Java作为广泛应用于后端服务开发的语言，提供了丰富的事务处理机制和API。本文将深入探讨Java中的事务类型、原理及其实现方式，并辅以示例代码帮助读者理解和掌握Java事务管理技术。

一、事务管理API

在Java中，事务管理主要通过Java Transaction API (JTA)来实现。JTA提供了一种标准的方式来管理和控制分布式事务，它允许应用程序参与到跨越多个数据库或其他资源的事务处理中。以下是使用JTA进行事务管理的API示例和详细讲解：

1. JTA核心接口与类

javax.transaction.UserTransaction：这是程序员直接操作事务的主要入口点，提供了开始、提交、回滚事务的方法。

import javax.transaction.UserTransaction;
import javax.naming.InitialContext;

public class JtaTransactionExample {
    public void executeTransaction() throws Exception {
        UserTransaction utx = (UserTransaction) new InitialContext().lookup("java:comp/UserTransaction");

        // 开始事务
        utx.begin();

        // 执行业务逻辑，比如调用DAO方法操作数据库...

        // 提交事务
        utx.commit();
    }
}

javax.transaction.TransactionManager:事务管理器用于更底层的事务控制，通常由应用服务器提供，并可通过JNDI查找获得。

import javax.transaction.TransactionManager;
import javax.naming.InitialContext;

public class TransactionManagerExample {
    public void manageTransaction() throws Exception {
        TransactionManager tm = (TransactionManager) new InitialContext().lookup("java:comp/TransactionManager");
        
        tm.begin();
        // 同上，执行业务逻辑...
        tm.commit();
    }
}

2. 使用JTA进行事务控制的基本步骤

开始事务：调用UserTransaction.begin()或TransactionManager.begin()方法开启一个新事务。
执行业务逻辑：在事务范围内执行一系列数据库操作或者其他需要事务支持的操作。
提交事务：如果所有操作都成功，调用commit()方法将事务提交到数据库和其他资源，使得更改持久化并对外可见。
回滚事务：若在业务逻辑执行过程中发生任何错误，可以调用rollback()方法撤销所有事务内的更改，确保数据的一致性。

3. 示例代码（假设在一个Java EE容器环境中）

import javax.ejb.Stateless;
import javax.inject.Inject;
import javax.transaction.UserTransaction;

@Stateless
public class MyTransactionalBean {

    @Inject
    private UserTransaction userTransaction;

    public void performBusinessLogic() {
        try {
            userTransaction.begin();

            // 假设有一个EntityManager或DataSource来进行数据库操作
            //entityManager.persist(entity);
            //dataSource.getConnection().prepareStatement(...).executeUpdate();

            // 如果一切正常
            userTransaction.commit();
        } catch (Exception e) {
            if (userTransaction.getStatus() != Status.STATUS_NO_TRANSACTION) {
                try {
                    userTransaction.rollback();
                } catch (Exception rollbackEx) {
                    System.err.println("Error rolling back transaction: " + rollbackEx.getMessage());
                }
            }
            throw new RuntimeException("Error during business logic execution", e);
        }
    }
}

二、事务属性

在Java中，事务属性通常指的是事务的隔离级别、传播行为等特性。这些属性在编程式事务管理和声明式事务管理中都非常重要，尤其是在Spring框架下使用@Transactional注解进行事务控制时尤为突出。

1. 事务隔离级别

事务隔离级别定义了并发事务之间数据可见性的程度，以防止不同的并发问题，如脏读、不可重复读和幻读。在Java中，可以通过javax.sql.DataSource的setTransactionIsolation(int level)方法设置数据库连接的事务隔离级别。以下为JDBC标准定义的四种隔离级别：

import java.sql.Connection;
import java.sql.SQLException;

public class TransactionIsolationExample {
    public void setTransactionIsolation(Connection conn) throws SQLException {
        // 设置事务隔离级别为READ_COMMITTED（已提交读）
        conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
        
        // 其他隔离级别：
        // TRANSACTION_READ_UNCOMMITTED - 读未提交（最低隔离级别）
        // TRANSACTION_REPEATABLE_READ - 可重复读
        // TRANSACTION_SERIALIZABLE - 序列化（最高隔离级别）
    }
}

在Spring框架中，可以通过@Transactional(isolation = Isolation.READ_COMMITTED)来设置事务的隔离级别：

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class SpringTransactionService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Transactional(isolation = Isolation.READ_COMMITTED)
    public void performTransactionalOperation() {
        // ...
    }
}

2. 事务传播行为

事务传播行为指在一个已经开启事务的方法内部调用另一个带有@Transactional注解的方法时，子方法如何参与到当前事务中的策略。Spring提供了七种事务传播行为：
REQUIRED（默认）：如果当前存在事务，则加入该事务；如果不存在事务，则创建一个新的事务。
SUPPORTS：如果当前存在事务，则加入该事务；如果不存在事务，则以非事务的方式执行。
MANDATORY：必须在一个已存在的事务中运行，否则抛出异常。
REQUIRES_NEW：总是新建一个事务，并将当前事务挂起。
NOT_SUPPORTED：以非事务方式执行，如果当前存在事务则将其挂起。
NEVER：必须在没有事务的环境中执行，如果存在事务则抛出异常。
NESTED：如果当前存在事务，则在嵌套事务内执行；如果当前没有事务，则新建一个事务。

示例：

@Service
public class PropagationExampleService {

    @Transactional(propagation = Propagation.REQUIRED)
    public void requiredMethod() {
        // 在已有事务中执行或开始新的事务
        nestedMethod();
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void nestedMethod() {
        // 总是启动新事务，即使requiredMethod已经在事务中
    }
}

三、事务隔离级别

在Java中，事务隔离级别是通过JDBC API或者Spring框架提供的事务管理机制来设置的。以下分别展示如何在两者中设置事务隔离级别。

1. 使用JDBC API设置事务隔离级别

在JDBC中，可以使用java.sql.Connection对象的setTransactionIsolation(int level)方法来设置事务隔离级别。以下是四种标准的隔离级别及其对应的常量值：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class JDBCTransactionIsolationExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydb";
        String user = "username";
        String password = "password";

        try (Connection conn = DriverManager.getConnection(url, user, password)) {
            // 设置事务隔离级别为READ_COMMITTED（已提交读）
            conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);

            // 其他隔离级别的常量：
            // TRANSACTION_READ_UNCOMMITTED - 读未提交（最低隔离级别）
            // TRANSACTION_REPEATABLE_READ - 可重复读
            // TRANSACTION_SERIALIZABLE - 序列化（最高隔离级别）

            // ... 进行数据库操作 ...

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

2. 使用Spring框架设置事务隔离级别

在Spring框架下，可以通过@Transactional注解的isolation属性来设置事务的隔离级别。这里是一个示例：

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class SpringTransactionalService {

    private final JdbcTemplate jdbcTemplate;

    @Autowired
    public SpringTransactionalService(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    // 设置事务隔离级别为READ_COMMITTED
    @Transactional(isolation = Isolation.READ_COMMITTED)
    public void performTransactionalOperation() {
        // 在这个方法内部执行的所有数据库操作将遵循READ_COMMITTED隔离级别
        jdbcTemplate.update("INSERT INTO table_name ...");
        jdbcTemplate.update("UPDATE another_table ...");
    }
}

事务隔离级别详解：

TRANSACTION_READ_UNCOMMITTED：允许脏读、不可重复读和幻读。这是所有隔离级别中并发性能最好的，但也是数据一致性最弱的。
TRANSACTION_READ_COMMITTED（默认）：只允许不可重复读和幻读，不允许脏读。
TRANSACTION_REPEATABLE_READ：禁止脏读和不可重复读，但无法阻止幻读。
TRANSACTION_SERIALIZABLE：提供了最高的事务隔离级别，完全避免了脏读、不可重复读和幻读问题，但它可能会导致更高的锁竞争和更低的并发性能。

四、事务传播行为

在Java中，特别是在Spring框架下，事务传播行为是通过@Transactional注解的propagation属性来指定的。这个属性决定了当一个方法在一个已存在的事务上下文中被调用时，应该如何管理事务。

以下列举了Spring中定义的七种事务传播行为，并给出相应的代码示例：
1.REQUIRED（默认）：

如果当前存在事务，则加入该事务；如果不存在事务，则创建一个新的事务。

   @Service
   public class TransactionalService {
       @Transactional(propagation = Propagation.REQUIRED)
       public void doSomething() {
           // 业务逻辑...
       }
   }

2.SUPPORTS：

如果当前存在事务，则参与该事务；如果不存在事务，则以非事务的方式执行。

   @Transactional(propagation = Propagation.SUPPORTS)
   public void supportsTransaction() {
       // 业务逻辑...
   }

3.MANDATORY：

必须在一个已存在的事务中运行，否则抛出异常。

   @Transactional(propagation = Propagation.MANDATORY)
   public void mandatoryTransaction() {
       // 业务逻辑...
   }

4.REQUIRES_NEW：

总是新建一个事务，如果当前存在事务，则将当前事务挂起。

   @Transactional(propagation = Propagation.REQUIRES_NEW)
   public void requiresNewTransaction() {
       // 业务逻辑...
   }

5.NOT_SUPPORTED：

不支持事务，总是以非事务方式执行，如果当前存在事务，则挂起当前事务。

   @Transactional(propagation = Propagation.NOT_SUPPORTED)
   public void notSupportedTransaction() {
       // 业务逻辑...
   }

6.NEVER：

必须在没有事务的环境中执行，如果当前存在事务则抛出异常。

   @Transactional(propagation = Propagation.NEVER)
   public void neverTransaction() {
       // 业务逻辑...
   }

7.NESTED：

如果当前存在事务，则在嵌套事务内执行；如果当前没有事务，则新建一个事务（需要数据库支持保存点）。

   @Transactional(propagation = Propagation.NESTED)
   public void nestedTransaction() {
       // 业务逻辑...
   }

五、事务管理策略

在Java中，事务管理策略主要体现在如何控制事务的边界、隔离级别、传播行为以及回滚规则等方面。以下通过Spring框架的@Transactional注解来说明这些策略，并提供代码示例。

1. 控制事务边界

开启和关闭事务：在Spring中，可以通过在Service类或方法上使用@Transactional注解来声明一个方法需要进行事务管理。

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

@Service
public class UserService {

    @Transactional
    public void updateUser(User user) {
        // 执行更新操作...
        // 如果这个方法内部抛出了未捕获的异常，那么整个事务将被自动回滚。
    }
}

2. 隔离级别设置

设置事务隔离级别：可以指定@Transactional注解中的isolation属性来设定事务的隔离级别。

@Service
public class UserService {

    @Transactional(isolation = Isolation.READ_COMMITTED)
    public void performOperation() {
        // 这个方法将在READ_COMMITTED隔离级别下执行事务
    }
}

3. 事务传播行为

定义事务传播行为：通过@Transactional注解的propagation属性可以设置事务的传播行为。

@Service
public class UserService {

    @Transactional(propagation = Propagation.REQUIRED)
    public void requiredTransactionMethod() {
        // ...
        anotherMethod();
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void anotherMethod() {
        // 在requiredTransactionMethod内部调用此方法时，会创建一个新的事务
    }
}

4. 回滚规则

自定义回滚规则：默认情况下，如果@Transactional修饰的方法中抛出了未检查异常（继承自RuntimeException）或者配置了@Transactional(rollbackFor=ExceptionType.class)的异常类型，事务会被自动回滚。

@Service
public class UserService {

    @Transactional(rollbackFor = SomeBusinessException.class)
    public void doSomethingDangerous() {
        // 若这里抛出SomeBusinessException，则事务会回滚
    }
}

5. 只读事务

只读事务优化：对于只读查询，可以标记为只读事务以获得数据库可能提供的优化。

@Service
public class ReportingService {

    @Transactional(readOnly = true)
    public List<User> getReportData() {
        // 这是一个只读事务，数据库可能会忽略锁，提高查询性能
        return userRepository.findAll();
    }
}

六、容器及框架支持

在Java中，事务通常与持久层框架（如JDBC、Hibernate、JPA）和应用容器（如Spring Framework）紧密相关。Spring框架通过AOP（面向切面编程）机制提供了对事务管理的强大支持。以下是一个使用Spring的PlatformTransactionManager以及@Transactional注解进行声明式事务管理的示例：

1. 配置Spring事务管理器

@Configuration
@EnableTransactionManagement
public class AppConfig {

    @Bean
    public DataSource dataSource() {
        // 这里配置数据源，比如DataSourceBuilder.create().build();
        return new DriverManagerDataSource("jdbc:mysql://localhost:3306/mydb", "username", "password");
    }

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

2. 使用@Transactional注解进行事务控制

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {

    private final JdbcTemplate jdbcTemplate;

    @Autowired
    public UserService(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Transactional
    public void transferMoney(String fromAccount, String toAccount, double amount) {
        jdbcTemplate.update("UPDATE account SET balance = balance - ? WHERE id = ?", amount, fromAccount);
        
        // 假设此处抛出异常，则整个事务会回滚
        if (someConditionFails()) {
            throw new RuntimeException("Transfer failed.");
        }
        
        jdbcTemplate.update("UPDATE account SET balance = balance + ? WHERE id = ?", amount, toAccount);
    }

    // 此处的someConditionFails是模拟一个可能抛出异常的条件检查
    private boolean someConditionFails() {
        // ...
    }
}

在上述代码中：

@EnableTransactionManagement注解用于开启Spring的事务管理功能。
DataSourceTransactionManager是一个实现PlatformTransactionManager接口的具体事务管理器，负责基于数据源来管理事务。
@Transactional注解应用于业务逻辑方法上，表明该方法需要在一个事务上下文中执行。当方法内部出现未捕获的运行时异常时，Spring将自动回滚事务。

此外，还可以通过事务属性（如传播行为、隔离级别、超时时间等）来细化事务管理策略：

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED, timeout = 30)
public void anotherMethodWithCustomizedAttributes() {
    // 方法体...
}

七、分布式事务支持

Java的分布式事务支持通常涉及到多个微服务或组件之间的数据一致性问题。确保这些组件之间的数据同步和一致性是非常重要的。在Java中，我们可以使用不同的技术来实现分布式事务，例如使用两阶段提交协议（2PC）、三阶段提交协议（3PC）、JTA/XA事务，或者使用基于补偿事务模式（Saga）的解决方案，或者使用分布式事务框架如Seata等。

以下是一个使用Seata实现分布式事务的简单示例和讲解：

1. 引入Seata依赖
首先，你需要在你的项目中引入Seata的依赖。这可以通过Maven或Gradle来完成。

2. 配置Seata
然后，你需要配置Seata。这包括设置事务模式（AT、TCC、Saga等）、事务组ID、事务超时时间等。

3. 使用@GlobalTransactional注解
在你的服务层的方法上，你可以使用@GlobalTransactional注解来声明这个方法是一个全局事务。当这个方法被调用时，Seata会开始一个全局事务，并确保这个方法中的所有数据库操作都在同一个事务中。
代码示例
假设我们有两个服务：OrderService和StockService。当我们创建一个订单时，我们需要在订单表中插入一条记录，并在库存表中减少相应的库存。

OrderService.java

import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private StockService stockService;

    @GlobalTransactional
    public void createOrder(Order order) {
        // 插入订单记录
        orderMapper.insertOrder(order);
        
        // 减少库存
        stockService.reduceStock(order.getProductId(), order.getProductQuantity());
    }
}

StockService.java

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class StockService {

    @Autowired
    private StockMapper stockMapper;

    public void reduceStock(Long productId, int quantity) {
        stockMapper.reduceStock(productId, quantity);
    }
}

在这个示例中，createOrder方法被标记为@GlobalTransactional，这意味着当这个方法被调用时，Seata会开始一个全局事务。如果在这个方法中的任何操作失败（例如，插入订单记录失败或减少库存失败），那么Seata会回滚这个全局事务，确保数据的一致性。

详细讲解:

两阶段提交（2PC）: Seata默认使用基于两阶段提交的分布式事务解决方案。在第一阶段，事务协调者询问所有的参与者是否可以提交事务；在第二阶段，如果所有的参与者都同意提交，那么事务协调者会告诉所有的参与者提交事务；否则，它会告诉所有的参与者回滚事务。
事务模式: Seata支持多种事务模式，包括AT模式（基于补偿的分布式事务解决方案，适用于大多数场景）、TCC模式（基于Try-Confirm-Cancel的分布式事务解决方案，需要开发者手动编写Confirm和Cancel逻辑）和Saga模式（基于长事务的解决方案，适用于跨多个服务且需要长时间运行的事务）。
事务分组: Seata使用事务组ID来将同一个全局事务中的多个分支事务关联起来。这样，当全局事务提交或回滚时，Seata可以确保所有的分支事务都被正确地处理。
事务超时: 你可以设置事务的超时时间。如果一个全局事务在这个时间内没有完成（例如，由于网络问题或某个参与者长时间没有响应），那么Seata会主动回滚这个全局事务，以防止数据的不一致。

总结

Java事务是Java应用程序在处理数据库操作时保证数据一致性和完整性的关键机制。在Java中，事务通常通过JDBC或更高级的框架如Spring等来实现管理。ACID（Atomicity, Consistency, Isolation, Durability）原则是事务的核心属性，确保了事务执行过程中的原子性、一致性、隔离性和持久性。

小码快撩

关注

27
点赞
踩
23

收藏

觉得还不错? 一键收藏
打赏
2
评论
深入理解与实践Java事务管理技术

Java事务是Java应用程序在处理数据库操作时保证数据一致性和完整性的关键机制。在Java中，事务通常通过JDBC或更高级的框架如Spring等来实现管理。ACID（Atomicity, Consistency, Isolation, Durability）原则是事务的核心属性，确保了事务执行过程中的原子性、一致性、隔离性和持久性。
复制链接

扫一扫