基于注解的声明式事务的使用方法
使用方法
1. 添加相关jar包或依赖——数据源、数据库驱动、mysql或spring-jdbc等，这里以spring-jdbc为例；
2. 数据库连接参数，一般单独写在properties或yaml配置文件中；
3. 编写数据库访问层组件(dao)和业务逻辑层组件(service)，且在service层需要事务管理的方法上加@Transactional注解；
4. 在容器中注册数据源、数据库操作模板、事务管理器，以及步骤3中的组件；
5. 在容器中开启基于事务的注解，即在容器配置类上加@EnableTransactionManagement注解。
下面是一个使用spring-jdbc访问数据库的事务demo
pom文件
<!--spring数据库操作模板--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.1.16.RELEASE</version> </dependency> <!--数据源，由于只是测试事务的demo，用的c3p0--> <dependency> <groupId>com.mchange</groupId> <artifactId>c3p0</artifactId> <version>0.9.5.4</version> </dependency> <!--数据库驱动--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.15</version> </dependency>
数据库配置文件
jdbc.url=jdbc:mysql://127.0.0.1:3306/test
jdbc.username=root
jdbc.password=123456
jdbc.driverClass=com.mysql.jdbc.Driver
容器配置类
/** * 容器配置类 * @EnableTransactionalManagement注解的意义是开启基于注解的事务，即使方法上的@Transactional注解生效
*/ @Configuration @ComponentScan(basePackages = {"cn.monolog.service", "cn.monolog.dao"}) @PropertySource(value = "classpath:/datasource.properties") @EnableTransactionManagement public class TxBeanConfig { //从配置文件中注入属性 @Value(value = "${jdbc.username}") private String username; @Value(value = "${jdbc.password}") private String password; @Value(value = "${jdbc.driverClass}") private String driverClass; @Value(value = "${jdbc.url}") private String url; //注册数据源 @Bean(name = "dataSource") public DataSource dataSource() throws PropertyVetoException { //创建数据源实例 ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource(); //属性注入 comboPooledDataSource.setUser(this.username); comboPooledDataSource.setPassword(this.password); comboPooledDataSource.setDriverClass(this.driverClass); comboPooledDataSource.setJdbcUrl(this.url); //返回 return comboPooledDataSource; } //注册spring的数据库操作模板 @Bean(name = "jdbcTemplate") public JdbcTemplate jdbcTemplate() throws PropertyVetoException { //从容器中获取数据源 // --注：spring对配置类(即加了@Configuration的类)有特殊处理， // 当多次调用注册方法时，并不是每次都会创建新bean，而是会从容器中获取bean DataSource dataSource = this.dataSource(); //创建模板 JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource); //返回模板 return jdbcTemplate; } //注册事务管理器 @Bean(name = "transactionManager") public PlatformTransactionManager transactionManager() throws PropertyVetoException { //从容器中获取数据源 DataSource dataSource = this.dataSource(); //创建事务管理器实例 DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager(dataSource); //返回 return dataSourceTransactionManager; } }
数据库访问层组件
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.stereotype.Repository; /** * 数据库访问层组件 * 用于测试事务 */ @Repository public class VariationDao { //从容器中自动注入spring数据库操作模板 @Autowired @Qualifier("jdbcTemplate") private JdbcTemplate jdbcTemplate; /** * 创建一条数据 */ public void create(String staffId, Integer alloted) { //编写sql语句 String sql = "insert into c_variation_config (staff_id, alloted) values (?, ?)"; //执行sql语句 this.jdbcTemplate.update(sql, staffId, alloted); } }
业务逻辑层组件
import cn.monolog.dao.VariationDao; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; /** * 业务逻辑层组件 * 用于测试事务 */ @Service public class VariationService { //从容器中自动注入dao层组件 @Autowired @Qualifier("variationDao") private VariationDao variationDao; /** * 创建一条数据 */ @Transactional(rollback =Exception.class) public void create(String staffId, Integer alloted) { //执行 this.variationDao.create(staffId, alloted); //手动制造异常，由于加了事务，上一条语句产生的数据库更新会被回滚 int i = 10 / 0; } }
注意事项
1. 在上述demo注册事务管理器时，需要获取容器中的另一个组件——数据源，这种从一个注册方法中需要获取另一个组件的情况，有两种处理方案
① 在参数列表中接收
@Configuration @PropertySource(value = "classpath:/datasource.properties") @EnableTransactionManagement public class TxBeanConfig { //从配置文件中注入属性 @Value(value = "${jdbc.username}") private String username; @Value(value = "${jdbc.password}") private String password; @Value(value = "${jdbc.driverClass}") private String driverClass; @Value(value = "${jdbc.url}") private String url; //注册数据源 @Bean(name = "dataSource") public DataSource dataSource() throws PropertyVetoException { //创建数据源实例 ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource(); //属性注入 comboPooledDataSource.setUser(this.username); comboPooledDataSource.setPassword(this.password); comboPooledDataSource.setDriverClass(this.driverClass); comboPooledDataSource.setJdbcUrl(this.url); //返回 return comboPooledDataSource; } /** * 注册事务管理器 * @param dataSource 在参数列表中接收容器中的另一个组件 * @return * @throws PropertyVetoException */ @Bean(name = "transactionManager") public PlatformTransactionManager transactionManager(DataSource dataSource) throws PropertyVetoException { //创建事务管理器实例 DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager(dataSource); //返回 return dataSourceTransactionManager; } }
② 在方法体中调用另一个注册方法
@Configuration @ComponentScan(basePackages = {"cn.monolog.service", "cn.monolog.dao"}) @PropertySource(value = "classpath:/datasource.properties") @EnableTransactionManagement public class TxBeanConfig { //从配置文件中注入属性 @Value(value = "${jdbc.username}") private String username; @Value(value = "${jdbc.password}") private String password; @Value(value = "${jdbc.driverClass}") private String driverClass; @Value(value = "${jdbc.url}") private String url; //注册数据源 @Bean(name = "dataSource") public DataSource dataSource() throws PropertyVetoException { //创建数据源实例 ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource(); //属性注入 comboPooledDataSource.setUser(this.username); comboPooledDataSource.setPassword(this.password); comboPooledDataSource.setDriverClass(this.driverClass); comboPooledDataSource.setJdbcUrl(this.url); //返回 return comboPooledDataSource; } @Bean(name = "transactionManager") public PlatformTransactionManager transactionManager() throws PropertyVetoException { //获取数据源 DataSource dataSource = this.dataSource(); //创建事务管理器实例 DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager(dataSource); //返回 return dataSourceTransactionManager; } }
对于这种方式，我们可能会产生一种疑问：this.dataSource方法中会new一个数据源实例，那么在注册事务管理器的同时，会不会又new了一个数据源实例，与单例模式违背？
答案是不会。因为spring对于容器配置类(即加了@Configuration)的注册方法有特殊处理，多次调用并不会反复new实例，如果容器中已经存在实例，再次调用会从容器中直接取出。
2. 如果service方法中加了try/catch语句，在捕获异常之后，之前的数据库更新操作并不会回滚，例如
@Transactional(rollbackFor = Exception.class) public void create(String staffId, Integer alloted) { try { //执行--不回滚！ this.variationDao.create(staffId, alloted); //手动制造异常 int i = 10 / 0; } catch (Exception e) { //捕获异常后，数据库的更新操作并不会回滚 e.printStackTrace(); } }
原因可能跟下面这段spring源码有关，但是暂时我没找到直接原因
public abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean { /** * Handle a throwable, completing the transaction. * We may commit or roll back, depending on the configuration. * @param txInfo information about the current transaction * @param ex throwable encountered */ protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) { if (txInfo != null && txInfo.getTransactionStatus() != null) { if (logger.isTraceEnabled()) { logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "] after exception: " + ex); } if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) { try { txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus()); } catch (TransactionSystemException ex2) { logger.error("Application exception overridden by rollback exception", ex); ex2.initApplicationException(ex); throw ex2; } catch (RuntimeException | Error ex2) { logger.error("Application exception overridden by rollback exception", ex); throw ex2; } } else { // We don't roll back on this exception. // Will still roll back if TransactionStatus.isRollbackOnly() is true. try { txInfo.getTransactionManager().commit(txInfo.getTransactionStatus()); } catch (TransactionSystemException ex2) { logger.error("Application exception overridden by commit exception", ex); ex2.initApplicationException(ex); throw ex2; } catch (RuntimeException | Error ex2) { logger.error("Application exception overridden by commit exception", ex); throw ex2; } } } } }
粉色粗体语句上面的注释，意思是在遇到这种异常时不回滚，但是如果TransactionStatus.isRollbackOnly==true，仍然会回滚；
继续跟进源码，TransactionStatus是一个接口，isRollbackOnly方法在它的实现类中找到了：
public abstract class AbstractTransactionStatus implements TransactionStatus { private boolean rollbackOnly = false; @Override public void setRollbackOnly() { this.rollbackOnly = true; } @Override public boolean isRollbackOnly() { return (isLocalRollbackOnly() || isGlobalRollbackOnly()); } /** * Determine the rollback-only flag via checking this TransactionStatus. * <p>Will only return "true" if the application called {@code setRollbackOnly} * on this TransactionStatus object. */ public boolean isLocalRollbackOnly() { return this.rollbackOnly; } }
从上面截取的源码可以看出，rollbackOnly的默认值是false，但是这个TransactionStatus的实现类也提供了修改它的方法——setRollbackOnly。
至此，我们得出一个结论，如果在service方法中使用了try/catch字句，只要在捕获异常的同时，把这个TransactionStatus.rollbackOnly设为ture，就可以实现回滚了，demo代码如下
/** * 创建一条数据 */ @Transactional(rollbackFor = Exception.class) public void create(String staffId, Integer alloted) { try { //执行 this.variationDao.create(staffId, alloted); //手动制造异常 int i = 10 / 0; } catch (Exception e) { //捕获异常后，将Transaction.status设置为true，实现回滚 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); e.printStackTrace(); } }
3. 事务与切面的执行顺序问题
在https://www.cnblogs.com/dubhlinn/p/10735015.html一文中，通过分析事务源码，得出结论：事务也是springAOP的一种应用。如果容器中存在多个切面，就涉及到执行顺序问题，如果对事务和某些切面的执行顺序先后有要求，需要让切面实现Ordered接口(或加@Order注解)手动规定顺序，并且在事务的@EnableTransactional注解中设置order属性，让事务的order数字大于上述切面即可。项目中一个典型的案例——数据源切换。如果项目中使用了多数据源，而且利用springAOP在service层做数据源切换，如果service层的方法加了事务，这时就要考虑事务和切面的执行顺序问题了。因为事务也是一种切面，且事务管理器会加载固定的数据源，如果事务先执行，数据源就已经加载了，后面的切面无法再切换数据源。
/** * 用于切换数据源的切面，应用于service层 * 执行顺序为1，在事务之前，这样加载事务时，会读取切换后的数据源 * created by YinHF on 2019-03-14 */ @Aspect @Component @Order(value = 1) public class DataSourceAOP { //使用test1库的接口 private static final String TEST1 = "execution(* cn.monolog.biz.service.impl.test1.*(..))"; //使用test2库的接口 private static final String TEST2 = "execution(* cn.monolog.biz.service.impl.test2.*(..))"; //使用test3库的接口 private static final String TEST3 = "execution(* cn.monolog.biz.service.impl.test3.*(..))"; /** * 切换数据源 → test1库 */ @Before(TEST1) public void switchToApp() { MultipleDataSource.setDataSourceKey(MultipleDataSource.TEST_1); } /** * 切换数据源 → test2库 */ @Before(TEST2) public void switchToConsole() { MultipleDataSource.setDataSourceKey(MultipleDataSource.TEST_2); }/** * 切换数据源 → test3库 */ @Before(TEST3) public void switchToDing() { MultipleDataSource.setDataSourceKey(MultipleDataSource.TEST_3); } }
/** * 容器配置类 */ @Configuration @EnableTransactionManagement(order = 2) public class TxBeanConfig { }
