Spring手动开启事务提交事务

  • Spring框架提供了多种方法来手动开启事务。在使用Spring进行事务管理时,常见的方法有两种:

    1. 基于注解的事务管理
      通过使用@Transactional注解,可以将方法标记为需要进行事务管理的方法。在这种方式下,Spring框架会根据方法的调用情况自动开启和提交事务。对于需要手动开启事务的情况,可以在类上标注@Transactional注解,并在方法内调用TransactionStatus对象的begin方法来手动开启事务,最后通过TransactionStatus对象的commit或rollback方法来提交或回滚事务。

    例如:

    @Service
    @Transactional
    public class UserService {
    
        @Autowired
        private UserDAO userDAO;
    
        public void createUser(User user) {
            // 手动开启事务
            TransactionStatus transactionStatus = TransactionAspectSupport.currentTransactionStatus();
            transactionStatus.setRollbackOnly();
    
            try {
                // 事务操作
                userDAO.createUser(user);
                // 事务提交
                transactionStatus.setRollbackOnly(false);
            } catch (Exception e) {
                // 事务回滚
                transactionStatus.setRollbackOnly(true);
            }
        }
    }
    
    1. 编程式事务管理
      通过使用TransactionTemplate对象来手动控制事务的开启、提交和回滚。TransactionTemplate是Spring框架提供的一个用于管理事务的工具类,可以在方法内部创建TransactionTemplate对象,并使用其execute方法执行需要进行事务管理的代码块。

    例如:

    @Service
    public class UserService {
    
        @Autowired
        private UserDAO userDAO;
    
        @Autowired
        private PlatformTransactionManager transactionManager;
    
        public void createUser(User user) {
            // 获取事务定义
            DefaultTransactionDefinition def = new DefaultTransactionDefinition();
            // 设置事务隔离级别
            def.setIsolationLevel(TransactionDefinition.ISOLATION_DEFAULT);
    
            // 设置事务传播行为
            def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
            
            // 获取事务对象
            TransactionStatus transactionStatus = transactionManager.getTransaction(def);
            
            try {
                // 事务操作
                userDAO.createUser(user);
                // 事务提交
                transactionManager.commit(transactionStatus);
            } catch (Exception e) {
                // 事务回滚
                transactionManager.rollback(transactionStatus);
            }
        }
    }
    

    以上两种方法都可以实现手动开启事务的功能,具体选择哪种方法取决于项目的需求和开发团队的偏好。

  • 在Spring中,我们可以使用@Transactional注解来声明事务。通过在方法或类上添加该注解,Spring会为我们自动管理事务的开启、提交和回滚。但是,有时候我们需要手动开启事务,以便更细粒度地控制事务的边界。下面是在Spring中手动开启事务的几种方式:

    1. 使用TransactionTemplate
      TransactionTemplate是Spring提供的一个工具类,它简化了事务管理的过程。我们可以通过实例化TransactionTemplate对象,并调用execute方法来执行需要进行事务管理的逻辑代码块。在execute方法的回调函数中,可以使用TransactionStatus对象来手动开启和提交事务。

    下面是使用TransactionTemplate手动开启事务的示例代码:

    @Autowired
    private TransactionTemplate transactionTemplate;
    
    public void performTransaction() {
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                // 执行需要进行事务管理的逻辑代码
            }
        });
    }
    
    1. 使用PlatformTransactionManager
      PlatformTransactionManager是Spring用于管理事务的接口。我们可以通过依赖注入的方式获取PlatformTransactionManager对象,并调用其getTransaction方法来手动开启事务。

    下面是使用PlatformTransactionManager手动开启事务的示例代码:

    @Autowired
    private PlatformTransactionManager transactionManager;
    
    public void performTransaction() {
        TransactionDefinition definition = new DefaultTransactionDefinition();
        TransactionStatus status = transactionManager.getTransaction(definition);
        
        try {
            // 执行需要进行事务管理的逻辑代码
            
            transactionManager.commit(status);
        } catch(Exception e) {
            transactionManager.rollback(status);
        }
    }
    
    1. 使用TransactionInterceptor
      TransactionInterceptor是Spring AOP中的一个拦截器,它可以对方法进行拦截,并在方法执行前后进行事务管理。我们可以通过配置TransactionInterceptor来手动开启事务。

    下面是使用TransactionInterceptor手动开启事务的示例代码:

    @Autowired
    private TransactionInterceptor transactionInterceptor;
    
    public void performTransaction() {
        Method method = ReflectionUtils.findMethod(getClass(), "methodName", parameterTypes);
        TransactionAspectSupport.currentTransactionStatus().isTransactionActive();
        transactionInterceptor.invoke(new MethodInvocationProceedingJoinPoint(method, args) {
            // 实现proceed方法并在其中执行需要进行事务管理的逻辑代码
        });
    }
    
    1. 使用AOP切面
      在Spring中,我们也可以通过定义AOP切面来手动开启事务。通过在切面的方法中将事务的开启逻辑放在@Before通知中实现。

    下面是使用AOP切面手动开启事务的示例代码:

    @Aspect
    @Component
    public class TransactionAspect {
        @Autowired
        private PlatformTransactionManager transactionManager;
    
        @Before("execution(* com.example.service.*.*(..))")
        public void beginTransaction(JoinPoint joinPoint) {
            TransactionDefinition definition = new DefaultTransactionDefinition();
            TransactionStatus status = transactionManager.getTransaction(definition);
            
            // 保存TransactionStatus对象到ThreadLocal中,方便其他地方获取并进行事务管理
        }
    }
    
    1. 使用编程式事务管理
      在一些特殊的场景下,我们可能需要使用编程式事务管理。通过调用DataSource的getConnection方法获取数据库连接,并手动设置事务的隔离级别、提交或回滚事务来实现。

    下面是使用编程式事务管理手动开启事务的示例代码:

    @Autowired
    private DataSource dataSource;
    
    public void performTransaction() throws SQLException {
        Connection connection = dataSource.getConnection();
        connection.setAutoCommit(false);
        
        try {
            // 执行需要进行事务管理的逻辑代码
            
            connection.commit();
        } catch (SQLException e) {
            connection.rollback();
        } finally {
            connection.close();
        }
    }
    

    在Spring中,事务是通过TransactionTemplate或者注解的方式来管理的。你可以手动开启事务来确保一系列操作的原子性和一致性。

    下面是手动开启事务的方法和操作流程:

    1. 配置事务管理器
      首先,你需要配置一个事务管理器。在Spring中,常用的事务管理器是DataSourceTransactionManager或JtaTransactionManager。这个配置放在Spring的配置文件中,以XML配置为例:
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    
    1. 创建TransactionTemplate对象
      通过TransactionTemplate可以简化使用事务的代码,它提供了一系列操作事务的模板方法。你可以在需要的地方创建一个TransactionTemplate对象:
    @Autowired
    private TransactionTemplate transactionTemplate;
    
    1. 使用TransactionTemplate进行事务操作
      在需要进行事务操作的方法中,使用TransactionTemplate的execute方法来执行事务的逻辑代码。例如,你的业务逻辑代码如下:
    public void doTransactionLogic() {
        // 在事务中执行的业务逻辑代码
    }
    

    将其改写为使用TransactionTemplate来开启事务:

    public void doTransactionLogic() {
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                // 在事务中执行的业务逻辑代码
            }
        });
    }
    

    需要注意的是,TransactionCallbackWithoutResult是一个抽象类,其中的doInTransactionWithoutResult方法是一个抽象方法,你需要在其中实现你的业务逻辑代码。

    1. 配置事务注解
      除了使用TransactionTemplate,你还可以使用注解的方式来开启事务。首先,需要在Spring的配置文件中启用事务注解:
    <tx:annotation-driven transaction-manager="transactionManager" />
    

    然后,在需要进行事务操作的方法上添加@Transactional注解:

    @Transactional
    public void doTransactionLogic() {
        // 在事务中执行的业务逻辑代码
    }
    

    通过以上的方式,你就能手动开启事务并进行事务的操作了。无论是使用TransactionTemplate还是注解的方式,都可以实现事务的管理和控制。

  • 17
    点赞
  • 12
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Spring中,我们可以通过编程的方式(即手动)来开启事务。具体步骤如下: 1. 在Spring配置文件中开启事务管理器: ``` <!-- 配置事务管理器 --> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"/> </bean> ``` 2. 在需要开启事务的方法上添加@Transactional注解: ``` @Service public class UserServiceImpl implements UserService { @Autowired private UserDao userDao; @Transactional public void transferMoney(int fromUserId, int toUserId, double money) { User fromUser = userDao.getUserById(fromUserId); User toUser = userDao.getUserById(toUserId); fromUser.setBalance(fromUser.getBalance() - money); toUser.setBalance(toUser.getBalance() + money); userDao.updateUser(fromUser); userDao.updateUser(toUser); } } ``` 在上面的例子中,我们在transferMoney方法上添加了@Transactional注解,这样Spring就会自动开启事务,并在方法执行完毕后自动提交或回滚事务。 需要注意的是,如果我们在一个类中调用了另一个类中被@Transactional注解的方法,那么事务并不会自动传播。因此,需要在调用方的方法上也添加@Transactional注解,并设置propagation属性为REQUIRED。例如: ``` @Service public class OrderServiceImpl implements OrderService { @Autowired private UserService userService; @Transactional(propagation = Propagation.REQUIRED) public void placeOrder(int userId, double amount) { // 生成订单,并扣除用户账户余额 userService.transferMoney(userId, 1, amount); // ... } } ``` 在上面的例子中,我们在placeOrder方法上也添加了@Transactional注解,并设置propagation属性为REQUIRED,这样事务就能够正确传播。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值