Spring框架中@Transactional注解原理深度解析

于 2025-08-02 09:51:30 发布
阅读量1.3k 收藏 28
点赞数 35
CC 4.0 BY-SA版权
分类专栏： Spring 文章标签： spring 数据库 java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2501_92540271/article/details/149854431

1. 事务管理的基本概念

1.1 什么是事务？

事务是数据库操作中一个基本概念，它指的是一组作为单个逻辑工作单元执行的数据库操作。这些操作要么全部成功提交，要么全部失败回滚，保证数据库状态的一致性。在Spring框架中，事务管理使得开发者可以在不直接操作底层数据库事务API的情况下，通过声明式的方式管理事务，大大简化了事务处理的复杂性。

1.2 ACID特性

事务的ACID特性是保证数据一致性的关键，具体包括：

原子性(Atomicity)：事务中的所有操作要么全部完成，要么全部不完成。如果事务中的某一个操作失败，整个事务都会回滚，所有已执行的操作都会被撤销。

一致性(Consistency)：事务必须使数据库从一个一致性状态转移到另一个一致性状态。也就是说，数据库的完整性约束必须在事务执行前后都保持不变。

隔离性(Isolation)：事务的执行不应被其他事务干扰。每个事务都应该在独立的上下文中运行，避免并发访问导致的数据不一致问题。

持久性(Durability)：一旦事务提交成功，其对数据库的修改将永久生效，即使系统发生故障（如断电、崩溃）也不会丢失。

1.3 事务管理的必要性

在实际应用中，事务管理尤为重要。例如，在银行转账场景中，如果从A账户扣款后，系统崩溃导致无法向B账户存入款项，就会造成资金损失。事务管理确保了这类操作的原子性，要么全部成功，要么全部失败。

传统事务管理需要开发者手动控制事务的开始、提交和回滚，代码冗余且容易出错。而Spring框架通过声明式事务管理，将事务控制与业务逻辑解耦，提高了代码的可读性和可维护性。

2. @Transactional注解的核心原理

2.1 声明式事务管理

声明式事务管理是一种非侵入式的事务管理方式，开发者只需在方法或类上添加注解，无需在代码中显式调用事务API。Spring通过AOP（面向切面编程）技术实现声明式事务管理，使得事务逻辑可以横切多个业务方法。

2.2 AOP与动态代理

**AOP（面向切面编程）**是Spring事务管理的核心技术。它允许开发者将横切关注点（如事务管理、日志记录等）与业务逻辑分离。

Spring通过动态代理机制实现AOP。当Spring容器启动时，会对带有@Transactional注解的Bean创建代理对象。代理对象有两种实现方式：

  1. JDK动态代理：需要目标类实现接口，代理对象实现与目标类相同的接口，并在方法调用前后添加事务逻辑 。
  2. CGLIB代理：生成目标类的子类，不需要目标类实现接口，适用于没有接口的类 。
2.3 事务拦截器

Spring事务管理的核心是事务拦截器。当方法被代理对象调用时，事务拦截器会在方法执行前后插入事务控制逻辑。

具体来说，Spring会为带有@Transactional注解的方法创建一个事务拦截器链。当方法被调用时，事务拦截器首先检查是否需要开启事务，然后执行方法，最后根据方法执行结果决定提交还是回滚事务。

2.4 事务管理器

PlatformTransactionManager是Spring事务管理的核心接口，它定义了事务管理的基本操作：获取事务状态、提交事务和回滚事务。

Spring提供了多种事务管理器实现，如DataSourceTransactionManager（用于JDBC）、HibernateTransactionManager（用于Hibernate）等。这些事务管理器负责与具体数据库或ORM框架交互，管理事务的生命周期。

2.5 事务上下文

TransactionSynchronizationManager是Spring用于管理事务上下文的关键类。它使用ThreadLocal机制将事务信息与线程绑定，确保在同一个线程中的数据库操作共享同一个事务上下文 。

当事务开始时，TransactionSynchronizationManager会将数据库连接（Connection）等资源与当前线程绑定。这些资源会在事务结束时被正确释放或重置 。

3. 源码解析：Spring AOP、动态代理与事务拦截器

3.1 动态代理生成机制

Spring的动态代理生成机制主要由InfrastructureAdvisorAutoProxyCreator类负责。该类会扫描所有Bean，为需要事务管理的Bean创建代理对象。

代理对象的创建条件包括：

  • 目标类需要被Spring管理（即是Spring Bean）
  • 目标类或方法上添加了@Transactional注解
  • 目标方法是public的（非public方法不会被代理） 
3.2 事务拦截器的源码分析

TransactionInterceptor是Spring事务管理的核心拦截器，它实现了MethodInterceptor接口，负责处理事务的开启、提交和回滚。

3.2.1 invoke方法

TransactionInterceptor的invoke方法是事务处理的入口点：

public Object invoke(MethodInvocation invocation) throws Throwable {
    // 获取目标类
    Class<?> targetClass = (invocation.getThis() != null ?
            AopUtils.getTargetClass(invocation.getThis()) : null);

    // 调用invokeWithinTransaction方法处理事务
    return invokeWithinTransaction(invocation.getMethod(), targetClass,
            invocation::proceed);
}
3.2.2 invokeWithinTransaction方法

invokeWithinTransaction是事务处理的核心方法，它负责解析事务注解、获取事务管理器、创建事务状态、执行方法并提交或回滚事务。

// TransactionAspectSupport
protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
        final InvocationCallback invocation) throws Throwable {
    // 1. 解析事务注解属性
    TransactionAttributeSource tas = getTransactionAttributeSource();
    final TransactionAttribute txAttr = (tas != null ? tas.TRANSACTIONAttribute(method, targetClass) : null);
    final PlatformTransactionManager tm = determineTransactionManager(txAttr);
    final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

    if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
        // 标准事务控制流程
        TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
        Object retVal = null;
        try {
            // 2. 执行目标方法
            retVal = invocation.proceedWithInvocation();
        } catch (Throwable ex) {
            // 3. 异常处理，决定是否回滚
            completeTransactionAfterThrowing(txInfo, ex);
            throw ex;
        } finally {
            // 4. 清理事务信息
            cleanupTransactionInfo(txInfo);
        }

        // 5. 提交事务
        if (retVal != null && txAttr != null) {
            TransactionStatus status = txInfo.getTransactionStatus();
            if (retVal instanceof Future<?> future && future.isDone()) {
                try {
                    future.get();
                } catch (ExecutionException ex) {
                    Throwable cause = ex.getCause();
                    Assert.state(cause != null, "Cause must not be null");
                    txInfo.setRollbackOnlyIfNecessary(cause, txAttr);
                }
            }
            txInfo.setRollbackOnlyIfNecessary(null, txAttr);
        }

        return retVal;
}
3.2.3 事务创建流程

createTransactionIfNecessary方法根据事务属性（如传播行为、隔离级别）创建或加入事务：

private TransactionInfo createTransactionIfNecessary(
        PlatformTransactionManager tm, TransactionAttribute txAttr,
        String joinpointIdentification) {
    // 获取事务定义
    TransactionDefinition definition = txAttr光环();
    // 获取事务状态
    boolean newTransaction = false;
    boolean existingTransaction = false;
    // 检查当前线程是否存在事务
    if (tm != null) {
        // 获取当前事务状态
        TransactionStatus status = tm事务状态(definition);
        // 根据传播行为决定是否创建新事务
        if (status.isNewTransaction()) {
            newTransaction = true;
        }
        existingTransaction = (status事务状态 != null);
    }

    // 创建TransactionInfo对象，包含事务状态和是否需要回滚等信息
    return createTransactionInfo(tm, txAttr, joinpointIdentification,
            newTransaction, existingTransaction);
}
3.3 事务管理器的源码分析
3.3.1 PlatformTransactionManager接口
public interface PlatformTransactionManager {
    // 获取事务状态
    TransactionStatus getTransaction(TransactionDefinition definition)
            throws TransactionException;

    // 提交事务
    void commit(TransactionStatus status) throws TransactionException;

    // 回滚事务
    void rollback(TransactionStatus status) throws TransactionException;
}
3.3.2 DataSourceTransactionManager类

DataSourceTransactionManager是Spring针对JDBC数据源的具体事务管理器实现：

// 事务开始方法
protected void doBegin(Object transaction, TransactionDefinition definition) {
    DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
    Connection con = null;
    try {
        // 获取数据库连接
        if (!txObject.hasConnectionHolder() ||
                txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
            Connection newCon = obtainDataSource().getConnection();
            // 关闭自动提交
            newCon.setAutoCommit(false);
            txObject.setConnection Holder(new ConnectionHolder(newCon));
        }
        // 设置事务属性
        txObject.setTransactionDefinition(definition);
        // 设置超时时间
        if (definition.getTimeout() > 0) {
            txObject Connection Holder().set忍耐时间(definition.getTimeout() * 1000);
        }
    } catch (SQLException ex) {
        // 处理异常
        throw convert例外(ex);
    }
}
3.3.3 事务提交与回滚
// 事务提交
protected void doCommit繁盛度繁盛度) {
    Connection connection = txObject.getConnection Holder(). Connection();
    try {
        // 提交数据库连接
        connection.commit();
    } catch (SQLException ex) {
        // 处理异常
        throw convert例外(ex);
    }
}

// 事务回滚
protected void doRollback繁盛度繁盛度) {
    Connection connection = txObject.getConnection Holder(). Connection();
    try {
        // 回滚数据库连接
        connection.rollback();
    } catch (SQLException ex) {
        // 处理异常
        throw convert例外(ex);
    }
}

4. 事务传播行为详解：胡传

4.1 什么是事务传播行为？

事务传播行为定义了当一个事务方法被另一个事务方法调用时，事务如何在这些方法间传播 。Spring提供了七种传播行为类型，适用于不同的业务场景。

4.2 七种事务传播行为详解
4.2.1传播行为枚举类
public enum传播行为 {
    DEFAULT, // 使用数据库默认级别
    REQUIRED, // 默认行为，如果没有事务则新建，如果有则加入
    READ_UNCOMMITTED, // 允许脏读
    READ_COMMITTED, // 允许读已提交数据
    REPEATABLE_READ, // 允许重复读
    SERIALIZABLE, // 串行化
    NESTED // 嵌套事务
}
4.2.2传播行为类型详解
传播行为类型外部不存在事务外部存在事务使用场景
REQUIRED（默认）开启新事务加入当前事务大多数业务操作，如增删改查
SUPPORTS以非事务方式执行加入当前事务只读操作，如查询
MANDATORY抛出异常加入当前事务必须在一个事务中执行的操作
REQUIRES_NEW开启新事务挂起当前事务，开启新事务需要独立事务的操作，如发送邮件或记录日志
NOT_SUPPORTED以非事务方式执行挂起当前事务不支持事务的操作
NEVER以非事务方式执行抛出异常绝对不支持事务的操作
NESTED开启新事务嵌套在当前事务中需要部分提交或回滚的操作
4.3传播行为示例代码
4.3.1传播行为：REQUIRED
@Service
public class AccountService {
    @Autowired
    private AccountDAO accountDAO;

    @Transactional
    public void transfer(String fromAccount, String toAccount, Double amount) {
        // 从账户扣款
        accountDAO减少余额(fromAccount, amount);
        // 向账户存入
        accountDAO增加余额(toAccount, amount);
    }
}
4.3.2传播行为：REQUIRES_NEW
@Service
public class OrderService {
    @Autowired
    private AccountService accountService;

    @Transactional(propagation =传播行为.REQUIRES_NEW)
    public void createOrder(Order order) {
        // 创建订单
        orderDAO保存(order);
        // 调用转账方法
        accountService.transfer(order.getFromAccount(),
                order.getToAccount(), order.getAmount());
    }
}
4.3.3传播行为：NESTED
@Service
public class PaymentService {
    @Autowired
    private OrderService orderService;

    @Transactional(propagation =传播行为.NESTED)
    public void processPayment(String order_id) {
        // 获取订单
        Order order = orderDAO根据ID查询(order_id);
        // 检查订单状态
        if (order.isInvalid()) {
            // 回滚嵌套事务
            throw new InvalidOrderException("订单无效，无法支付");
        }

        // 调用创建订单方法
        orderService.createOrder(order);
        // 记录支付日志
        paymentLogDAO保存(new PaymentLog(order_id, "支付成功"));
    }
}

5. 事务隔离级别详解：Isolation

5.1 什么是事务隔离级别？

事务隔离级别定义了一个事务在执行过程中如何与其他并发事务进行交互 。不同的隔离级别提供了不同程度的并发控制，但也带来了不同的性能开销。

5.2 Spring支持的隔离级别

Spring通过Isolation枚举类定义了五种隔离级别：

public enum Isolation {
    DEFAULT, // 使用数据库默认级别
    READ_UNCOMMITTED, // 允许脏读
    READ_COMMITTED, // 允许读已提交数据
    REPEATABLE_READ, // 允许重复读
    SERIALIZABLE // 串行化
}
5.3 隔离级别与数据库锁机制

不同的隔离级别通过不同的锁机制实现：

5.3.1隔离级别：READ_UNCOMMITTED
@Transactional(isolation = Isolation.READ_UNCOMMITTED)
public List<User>查询所有用户() {
    return userDAO所有();
}

此隔离级别允许一个事务读取另一个事务未提交的数据（脏读）。在数据库中，这通常通过不加锁或仅使用共享锁（S锁）实现。

5.3.2隔离级别：READ_COMMITTED
@Transactional(isolation = Isolation.READ_COMMITTED)
public List<User>查询已提交用户() {
    return userDAO所有();
}

此隔离级别允许一个事务读取另一个事务已提交的数据，但不允许读取未提交的数据。在数据库中，这通常通过使用行锁（X锁）实现，避免脏读。

5.3.3隔离级别：REPEATABLE_READ
@Transactional(isolation = Isolation.REPEATABLE_READ)
public List<User>查询可重复读() {
    return userDAO所有();
}

此隔离级别保证了一个事务不会修改已经由另一个事务读取但未提交的数据。在数据库中，这通常通过使用间隙锁（Gap Lock）和行锁实现，避免脏读和不可重复读。

5.3.4隔离级别：SERIALIZABLE
@Transactional(isolation = Isolation.SERIALIZABLE)
public List<User>查询串行化() {
    return userDAO所有();
}

此隔离级别保证事务串行执行，避免所有并发问题，但性能开销最大。在数据库中，这通常通过使用排他锁（X锁）实现，确保事务之间的完全隔离。

5.4 隔离级别与数据库锁的关联

Spring的事务隔离级别最终会转换为数据库的隔离级别。例如，当设置isolation = Isolation.READ_COMMITTED时，Spring会通过Connection对象的setTransactionIsolation方法设置JDBC连接的隔离级别：

// 事务管理器设置隔离级别
protected void prepareTransactionalConnection(Connection con, TransactionDefinition definition) throws SQLException {
    // 获取隔离级别
    int isolationLevel = definition.getIsolationLevel();
    // 如果不是默认级别
    if (isolationLevel != TransactionDefinition ISOLATION_DEFAULT) {
        // 获取当前隔离级别
        int currentIsolation = con事务隔离级别;
        // 如果当前隔离级别与定义的不同
        if (currentIsolation != isolationLevel) {
            // 设置新的隔离级别
            con.setTransactionIsolation(isolationLevel);
        }
    }
}

6. 事务回滚规则与异常处理

6.1 默认回滚规则

Spring默认的回滚规则是：当方法抛出RuntimeException及其子类或Error时，事务会自动回滚；而当方法抛出Checked Exception时，事务不会回滚 。

6.2 自定义回滚规则
6.2.1回滚特定异常
@Service
public class PaymentService {
    @Transactional(rollbackFor = Exception.class)
    public void processPayment(Payment payment) throws Exception {
        // 业务逻辑
        if (paymentAmount < 0) {
            throw new Exception("金额不能为负数");
        }
    }
}
6.2.2不回滚特定异常
@Service
public class OrderService {
    @Transactional(noRollbackFor = {IllegalArgumentException.class,宇航员.class})
    public void createOrder(Order order) {
        // 业务逻辑
        if (orderAmount <= 0) {
            throw new IllegalArgumentException("订单金额必须大于零");
        }
    }
}
6.3 异常处理最佳实践
  1. 明确抛出异常：确保事务方法在发生错误时抛出异常，以便Spring能够触发事务回滚。
  2. 避免吞异常：不要捕获异常而不抛出，这会导致事务提交。
  3. 使用 Checked Exception：如果希望 Checked Exception也能触发回滚，需要在@Transactional注解中指定rollbackFor属性。
  4. 处理特定异常：根据业务需求，可以指定哪些异常触发回滚，哪些不触发。

7. @Transactional的配置与优化

7.1 基本配置
7.1.1单方法配置
@Service
public class UserService {
    @Transactional
    public void createUser(User user) {
        // 业务逻辑
    }
}
7.1.2类级别配置
@Service
@Transactional
public class UserService {
    public void createUser(User user) {
        // 业务逻辑
    }

    public void updateUser(User user) {
        // 业务逻辑
    }
}
7.2 高级配置
7.2.1指定事务管理器
@Service
public class UserService {
    @Transactional(value = "userTransactionManager")
    public void createUser(User user) {
        // 业务逻辑
    }
}
7.2.2设置事务超时
@Service
public class PaymentService {
    @Transactional(timeout = 30) // 超时30秒
    public void processPayment(Payment payment) {
        // 业务逻辑
        // 如果30秒内未完成，事务会自动回滚
    }
}
7.2.3只读事务
@Service
public class ReportService {
    @Transactional(readOnly = true)
    public List<Report> generateReport() {
        // 业务逻辑
        // 只读事务可以提高性能
    }
}
7.3 事务配置的最佳实践
  1. 只在Service层使用：事务控制应集中在Service层，避免在DAO层或Controller层使用。
  2. 避免过度使用：只对需要保证原子性的操作添加事务注解，不必要的事务会增加性能开销。
  3. 合理设置超时：根据业务需求设置合理的超时时间，避免长时间锁占用。
  4. 使用只读事务：对于只读操作，设置readOnly = true可以提高性能。
  5. 避免私有方法：@Transactional注解应使用在public方法上，否则事务不会生效。
  6. 避免内部调用：同一个类中的方法调用会绕过事务代理，导致事务失效。

8. 常见问题与解决方案

8.1 事务不生效
8.1.1问题现象
@Service
public class DemoUserService {
    //... ...

    public DemoUser doGet() {
        try {
            doInsert(1);
        } catch (Exception ex) {
            System.out.println("insert error: " + ex.toString());
        }
        return demoUserMapper.get(1);
    }

    @Transactional
    public int doInsert(int id) {
        DemoUser user = new DemoUser(id, "zs", 18, new BigDecimal("8888.88"),
                "shenzhen,cn", new Timestamp(System.currentTimeMillis()),
                new Timestamp(System.currentTimeMillis()));
        int result = demoUserMapper.insert(user);
        throw new RuntimeException("mock insert ex");  //模拟抛错
        return result;
    }
}

调用demoUserService.doGet()后，最终打印出了ID为1的那条记录，事务并没有回滚。

8.1.2根本原因

事务没有执行，因为在BEAN方法内部直接调用了另一个公开的事务方法，是原生的方法之间调用，并非是被代理后的BEAN方法，所以Spring的AOP事务切面没有被触发。

8.1.3解决方案
  1. 使用代理对象调用：通过注入的代理对象而非this调用事务方法。
  2. 使用TransactionTemplate：在方法内部手动管理事务。
@Service
public class DemoUserService {
    @Autowired
    private DemoUserService self;  //注入代理对象

    public DemoUser doGet() {
        try {
            self.doInsert(1);  //通过代理对象调用
        } catch (Exception ex) {
            System.out.println("insert error: " + ex.toString());
        }
        return demoUserMapper.get(1);
    }

    @Transactional
    public int doInsert(int id) {
        //业务逻辑
        return demoUserMapper.insert(user);
    }
}
8.2 事务传播导致的死锁
8.2.1问题场景
@Service
public class TransferService {
    @Autowired
    private AccountDAO accountDAO;

    @Transactional
    public void transfer(String fromAccount, String toAccount, Double amount) {
        // 从账户扣款
        accountDAO减少余额(fromAccount, amount);
        // 向账户存入
        accountDAO增加余额(toAccount, amount);
    }
}

当多个线程并发执行transfer方法时，可能因为锁顺序不一致导致死锁。

8.2.2解决方案
  1. 调整锁顺序：确保所有事务以相同的顺序获取锁。
  2. 设置合理超时：在@Transactional注解中设置timeout属性，避免长时间等待。
  3. 使用较低隔离级别：如READ_COMMITTED，减少锁竞争。
@Service
public class TransferService {
    @Autowired
    private AccountDAO accountDAO;

    @Transactional(timeout = 30, isolation = Isolation.READ_COMMITTED)
    public void transfer(String fromAccount, String toAccount, Double amount) {
        // 按固定顺序获取锁
        Account from = accountDAO根据ID查询(fromAccount);
        Account to = accountDAO根据ID查询(toAccount);

        // 从账户扣款
        accountDAO减少余额(from, amount);
        // 向账户存入
        accountDAO增加余额(to, amount);
    }
}
8.3 异步方法中的事务问题
8.3.1问题现象
@Service
public class PaymentService {
    @Autowired
    private AccountService accountService;

    @Transactional
    public void processPayment(String account_id, Double amount) {
        // 扣款
        accountService减少余额(account_id, amount);
        // 异步发送通知
        threadPool.execute(() -> {
            accountService.updateBalanceLog(amount, "支付成功");
        });
    }
}

在异步线程中调用accountService.updateBalanceLog方法时，事务可能已经提交，导致无法获取到最新的数据，或者事务上下文无法传递到异步线程。

8.3.2解决方案
  1. 使用TransactionTemplate：在异步方法内部手动开启事务 。
@Service
public class PaymentService {
    @Autowired
    private PlatformTransactionManager transactionManager;

    @Transactional
    public void processPayment(String account_id, Double amount) {
        // 扣款
        accountService减少余额(account_id, amount);

        // 异步发送通知
        threadPool.execute(() -> {
            // 手动开启事务
            TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
            transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
            transactionTemplate.execute(status -> {
                accountService.updateBalanceLog(amount, "支付成功");
                return null;
            });
        });
    }
}
  1. 使用@Async与@Transactional结合：在异步方法上添加@Transactional注解，确保每个异步任务都有自己的事务上下文 。
@Service
public class PaymentService {
    @Autowired
    private AccountService accountService;

    @Async
    @Transactional
    public void asyncUpdateBalanceLog(String account_id, Double amount) {
        accountService.updateBalanceLog(amount, "支付成功");
    }

    @Transactional
    public void processPayment(String account_id, Double amount) {
        // 扣款
        accountService减少余额(account_id, amount);
        // 异步更新日志
        asyncUpdateBalanceLog(account_id, amount);
    }
}

9. 实际开发中的最佳实践

9.1 事务边界设计

事务边界是指事务应该覆盖哪些操作。设计事务边界时应遵循以下原则：

  1. 粗粒度与细粒度平衡：事务既不能太粗（导致长时间锁占用），也不能太细（导致频繁的事务提交和回滚）。
  2. 业务一致性优先：事务边界应确保业务操作的一致性，而不是简单的技术操作。
  3. 避免跨服务事务：在分布式系统中，避免跨服务的事务，使用消息队列或分布式事务框架（如Seata） 。
9.2 事务与性能优化
9.2.1合理设置超时
@Service
public class OrderService {
    @Transactional(timeout = 30) // 30秒超时
    public void createOrder(Order order) {
        // 业务逻辑
        // 如果30秒内未完成，事务会自动回滚
    }
}
9.2.2使用只读事务
@Service
public class ReportService {
    @Transactional(readOnly = true)
    public List<Report> generateReport() {
        // 业务逻辑
        // 只读事务可以减少锁竞争
    }
}
9.2.3避免长时间持有事务
@Service
public class PaymentService {
    @Transactional
    public void processPayment(Payment payment) {
        // 业务逻辑
        // 尽快提交或回滚事务
    }
}
Spring @Transactional注解原理深度分析
ma451152002的专栏
06-17 182
Transactional注解是Spring事务管理的核心注解，定义在spring-tx@Inherited// 事务管理器限定符// 事务标签// 事务传播行为// 事务隔离级别// 事务超时时间// 只读事务标识// 回滚异常类型Class<?// 不回滚异常类型Class<?/*** 根据事务定义获取事务状态*//*** 提交事务*//*** 回滚事务*/@Component。
深入理解 @Transactional 注解与 Spring 事务机制
diligent_man_z的博客
01-21 1081
在企业级应用开发中，数据的一致性和完整性至关重要，事务管理则是保障这一目标的关键技术。Spring 框架提供的 @Transactional 注解为开发者带来了便捷的声明式事务管理方式，极大地简化了事务处理的复杂性。本文将深入剖析 @Transactional 注解的使用细节、Spring 事务传播规则，并结合实际案例与源码分析，助力开发者全面掌握这一核心技术。
Springboot之@Transactional事务注解原理详解
肆頭的博客
09-02 6446
文章目录注册事务切面逻辑根据切面逻辑生成代理类总结 @Transactional注解的逻辑是通过动态代理来实现的，而生成这个动态代理类分成了两步： 1、向spring容器注册事务相关的切面逻辑 2、根据切面逻辑生成动态代理 下面围绕这两点来看下Springboot里的实现原理 注册事务切面逻辑 切面逻辑里有三个概念： Pointcut：负责告诉spring容器哪个类需要增强 Advise：具体的切面逻辑，这里就是根据异常进行commit或者回滚的相关逻辑 Advisor：封装了Advise和Pointcut
Spring @Transactional工作原理详解
08-28
主要介绍了Spring @Transactional工作原理详解，具有一定借鉴价值，需要的朋友可以参考下。
你必须懂！也可以懂的@Transactional原理！
Java_DaFei的博客
06-01 3471
1.前言 系统应用开发过程中通常需要使用事务来保证业务数据的一致性，实现方式如：开启事务、执行数据库写操作、提交或者回滚事务，这种标准实现方式适用于少量一致性业务，如果存在大量需要保证数据一致性的业务，不仅会让开发人员重复编码，还会给系统造成冗余代码。基于这些问题，伟大的Spring框架为我们提供了@Transactional注解，那么它是如何使用一个注解就解决了我们的烦恼呢？我们该如何着手进行分析呢？ SpringBoot集成的功能往往要从一个xxxAutoConfiguration开始说起 2.自动配置
@transactional注解原理
Airtiesy的博客
06-14 957
注解通过Spring的AOP机制，结合JDBC事务，为开发者提供了一种方便、灵活的事务管理方式，帮助开发者更好地管理数据的一致性和可靠性。
Spring之@Transactional注解原理
908070997的博客
04-16 1254
一般情况下我们在处理具体的业务都是在Service层来进行处理操作，此时如果在Service类上添加@Transactional注解的话，那么Service曾的每一个业务方法调用的时候都会打开一个事务。 —————————————————————————————————————————————————— 注意点： Spring默认情况下会对(RuntimeException)及其子类...
Spring注解原理深度解析：从入门到精通
最新发布
ljw714的专栏
06-07 839
本文深入解析Spring注解原理，涵盖从基础概念到底层实现的全方位内容。主要内容包括：1) Spring注解发展历程及其优势，展示了从XML到纯注解配置的演进；2) Java注解基础，详细解析元注解和反射机制的应用；3) Spring核心注解如@Component及其派生注解的用法；4) 注解处理器机制和扫描过程；5) 自定义注解开发方法。文章通过代码示例辅助说明，帮助开发者深入理解注解驱动开发的核心技术，掌握Spring框架中注解的底层实现原理和最佳实践。
精通@Transactional：Spring事务处理深度解析
"本文主要探讨了Spring框架中的事务管理，特别是@Transactional注解的使用和理解。作者通过背景介绍引出了Spring事务的传播行为，并详细解释了各种不同的传播级别，包括PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_...
Spring源码深度解析与注解驱动开发1
08-08
Spring框架是Java开发中的核心组件，尤其在企业级应用中广泛使用。本节主要探讨Spring的源码解析以及注解驱动的开发方式，帮助开发者深入理解Spring的工作机制，提高开发效率。 一、Spring注解驱动开发 1. 容器：...
Spring事务@Transactional注解原理
热门推荐
jike11231的博客
07-03 1万+
一、思维导图 Spring 事务管理分为编程式和声明式两种。编程式事务指的是通过编码方式实现事务；声明式事务基于 AOP，将具体的逻辑与事务处理解耦。 声明式事务有两种方式，一种是在配置文件（XML）中做相关的事务规则声明，另一种是基于 @Transactional 注解的方式。 默认配置下 Spring 只会回滚运行时、未检查异常（继承自 RuntimeException 的异常）或者 Error。 @Transactional 注解只能应用到 public 方法才有效。 1.1 声明式事务管理实现
@Transactional 实现原理
tiankong_12345的博客
09-01 3043
目录 1、简介 2、自定义注解 2.1 定义 2.2 测试 2.3 总结 3、手写事务注解 3.1 maven依赖 3.2配置spring.xml文件 3.3自定义事务注解 (通过反射解析方法上的注解，如果有这个注解就执行事务逻辑) 3.4封装编程式事务 3.5通过AOP封装事务工具类, 基于环绕通知和异常通知来触发事务 3.6 dao 层 3.7 service...
spring事务特性分析
Jeffrey's 专栏
11-20 2684
spring事务特性 spring所有的事务管理策略类都继承自org.springframework.transaction.PlatformTransactionManager接口 public interface PlatformTransactionManager {     TransactionStatus getTransaction(TransactionDefini
@Transactional原理分析
cxbtdd的博客
11-05 425
Spring事务管理的核心原理是基于动态代理和AOP拦截实现的。当使用@Transactional注解时，Spring会在Bean初始化阶段创建代理对象（JDK或CGLIB），并在方法调用时通过TransactionInterceptor进行事务控制。事务管理器控制事务的开启、提交/回滚，并通过ThreadLocal实现资源同步。常见失效场景包括：私有方法调用、自调用、异常处理不当等。该机制通过AOP实现，对业务代码低侵入，使开发者能专注业务逻辑开发。
@Transactional注解详解
m0_52825447的博客
05-26 1240
事务（Transaction）是数据库管理系统执行过程中的一个逻辑单位，由一个有限的数据库操作序列构成。这些操作要么全部执行，要么全部不执行，是一个不可分割的工作单位。事务的主要目的是简化失败恢复并保持数据的完整性。原子性（Atomicity）：事务作为一个整体被执行，包含在其中的对数据库的操作要么全部被执行，要么全部不执行。一致性（Consistency）：事务必须使数据库从一个一致性状态变换到另一个一致性状态。也就是说，一个事务执行之前和执行之后都必须处于一致性状态。
Spring事务注解@Transactional原理解析
Leon_Jinhai_Sun的博客
04-22 597
使用@Transactional有一些需要注意的地方: Spring默认情况下会对(RuntimeException)及其子类来进行回滚,在遇见Exception及其子类的时候则不会进行回滚操作 @Transactional注解应该只被应用到public方法上,这是由Spring AOP的本质决定的 @Transactional注解要生效的话,需配置@EnableTransactionManagement,不过如果是使用SpringBoot的话,就可以不需要了: @SpringBootApplica
@Transactional注解的原理
MarmotCoder
12-04 404
# 网络连接 监听 8080端口 $ nc -l 8080 # 网络连接 172.22.177.89 8080端口 $ nc 172.22.177.89 8080 然后两个服务就可以互相通信了
Transactional注解原理解析
Lisam Blog
01-02 4273
什么是@Transactional? @Transactional是Spring这种用于处理事务的注解，基于拦截器进行commit或rollback 使用例子 下面举一个加了@Transactional注解的方法addUser()，并且调用了另一个隔离级别为NESTED的addUser2()方法 @Service public class UserService { // .. 省略其他 @Transactional public void addUser() {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

探索java

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值