Spring——事务

最新推荐文章于 2025-08-17 14:36:20 发布

原创最新推荐文章于 2025-08-17 14:36:20 发布 · 231 阅读

0 ·

CC 4.0 BY-SA版权

Spring 专栏收录该内容

4 篇文章

订阅专栏

本文介绍了Spring事务的使用，包括创建相关接口和实现类，配置事务管理器、启用注解等。还阐述了事务的传播行为、隔离级别，如REQUIRED、READ_COMMITTED等，以及设置异常回滚、只读属性、超时等。此外，讲解了使用XML文件配置事务的步骤。

Spring——事务

下面简单的举例子说明，如何使用事务:

创建一个BankDao接口和BankImpl实现类和 BankService 和 BankServiceImpl

BankDao:

public interface BankDao {
    public void cost(int money);
}

BankDaoImpl:

@Repository("bankDao")
public class BankDaoImpl implements BankDao{
    @Override
    public void cost(int money) {
        //执行数据库操作
        System.out.println("cost "+money);
    }
}

BankService:

public interface BankService {
    public void cost(int money);
}

BankServiceImpl:

@Service("bankService")
public class BankServiceImpl implements BankService{
    @Autowired
    private BankDao bankDao;

    @Override
    public void cost(int money) {
        bankDao.cost(money);
    }
}

Main:

public class Main {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        BankService bankService=(BankService) context.getBean("bankService");
        bankService.cost(11);
    }
}

配置:

   <context:component-scan base-package="com.chenx.spring.aop"></context:component-scan>

如此一来基本的配置就算是好了

接着加入事务的相关配置：

首先需要加入事务管理器，jdbc的管理器是DataSourceTransactionManage,Hibernate的管理器是HibernateTransactionManage.....

我采用的是DataSourceTransactionManage，配置属性数据源

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

启用事务注解：

<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

接着配置完成后，向方法中加入@Transactional 注解：

@Service("bankService")
public class BankServiceImpl implements BankService{
    @Autowired
    private BankDao bankDao;

    @Transactional
    @Override
    public void cost(int money) {
        bankDao.cost(money);
    }
}

当Dao层抛出异常后因注解了@Transactional 则不会执行数据库中的操作。

事务的传播行为：

REQUIRED：（默认）：此事务被其他事务调用的时候，他会在现有的事务中运行，当其中一个出错的时候，会导致所有成功的事务都回滚

REQUIRED_NEW: 它表示该方法必须启动一个新事务，并在自己的事务中运行如果有事务就应该挂起它，此配置会导致，即使有一个事务异常，其余正常的事务不会回滚。

如下：

@Service("bankService")
public class BankServiceImpl implements BankService{
    @Autowired
    private BankDao bankDao;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public void cost(int money) {
        bankDao.cost(money);
    }
}

事务的隔离级别：

1、DEFAULT

默认隔离级别，每种数据库支持的事务隔离级别不一样，如果Spring配置事务时将isolation设置为这个值的话，那么将使用底层数据库的默认事务隔离级别。顺便说一句，如果使用的MySQL，可以使用"select @@tx_isolation"来查看默认的事务隔离级别

2、READ_UNCOMMITTED

读未提交，即能够读取到没有被提交的数据，所以很明显这个级别的隔离机制无法解决脏读、不可重复读、幻读中的任何一种，因此很少使用

3、READ_COMMITED

读已提交，即能够读到那些已经提交的数据，自然能够防止脏读，但是无法限制不可重复读和幻读

4、REPEATABLE_READ

重复读取，即在数据读出来之后加锁，类似"select * from XXX for update"，明确数据读取出来就是为了更新用的，所以要加一把锁，防止别人修改它。REPEATABLE_READ的意思也类似，读取了一条数据，这个事务不结束，别的事务就不可以改这条记录，这样就解决了脏读、不可重复读的问题，但是幻读的问题还是无法解决

5、SERLALIZABLE

串行化，最高的事务隔离级别，不管多少事务，挨个运行完一个事务的所有子事务之后才可以执行另外一个事务里面的所有子事务，这样就解决了脏读、不可重复读和幻读的问题了

通过 isolation 属性进行配置：

@Service("bankService")
public class BankServiceImpl implements BankService{
    @Autowired
    private BankDao bankDao;

    @Transactional(propagation = Propagation.REQUIRES_NEW,isolation = Isolation.READ_COMMITTED)
    @Override
    public void cost(int money) {
        bankDao.cost(money);
    }
}

设置特定的异常的回滚，默认情况下是回滚所有的异常，使用 norollbackfor 或 rollbackfor：

@Service("bankService")
public class BankServiceImpl implements BankService{
    @Autowired
    private BankDao bankDao;

    @Transactional(propagation = Propagation.REQUIRES_NEW,isolation = Isolation.READ_COMMITTED
            ,rollbackFor = {RuntimeException.class})
    @Override
    public void cost(int money) {
        bankDao.cost(money);
    }
}

设置事务的只读属性——表示操作只是对数据库的读取操作，这样设置可以使运行更快，从而优化

@Service("bankService")
public class BankServiceImpl implements BankService{
    @Autowired
    private BankDao bankDao;

    @Transactional(propagation = Propagation.REQUIRES_NEW,readOnly = true)
    @Override
    public void cost(int money) {
        bankDao.cost(money);
    }
}

使用timeout，设置事务最多占用的时间，一旦超时事务则回滚，即使没有异常:

@Service("bankService")
public class BankServiceImpl implements BankService{
    @Autowired
    private BankDao bankDao;

    @Transactional(propagation = Propagation.REQUIRES_NEW,timeout = 2)
    @Override
    public void cost(int money) {
        bankDao.cost(money);
    }
}

2.使用XML文件配置事务

1.配置所有的Dao DaoImpl Service ServiceImpl 等bean

2.配置事务管理器DataSourceTransationManage

3.配置事务属性（只读，隔离，回滚...）

4.配置事务的切点（把事务切入点和事务属性关联起来）

aop:advisor 一般用于事务：用于连接属性和切入点的关系

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

    <tx:advice id="interceptor" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*"/>
            <tx:method name="cost" propagation="REQUIRES_NEW"></tx:method>
            <tx:method name="get*" read-only="true"></tx:method>
        </tx:attributes>
    </tx:advice>
  
    <aop:config>
        <aop:pointcut id="cut" expression="execution(public void com.chenx.spring.aop.BankService.cost(int))"/>
        <aop:advisor advice-ref="interceptor" pointcut-ref="cut"></aop:advisor>
    </aop:config>