Spring事务管理方式（声明式+编程式）
声明式事务（5种方式）
Spring同时支持编程式事务策略和声明式事务策略，只是大部分时候，我们都推荐采用声明式事务策略。它有十分明显的优势：
1、声明式事务能大大降低开发者的代码书写量，而且声明式事务几乎不影响应用的代码。因此，不论底层事务策略如何变化，应用程序都无需任何改变
2、应用程序代码无需任何事务处理代码，可以更专注于业务逻辑的实现
3、Spring可对任何POJO的方法提供事务管理，而且Spring的声明式事务管理无需容器的支持，可在任何环境下使用（无需要要web容器的支持）
4、Spring可指定事务在遇到特定异常时自动回滚。Spring不仅可在代码中使用setRollbackOnly回滚事务，也可在配置文件中（或者注解中）配置回滚规则
5、*由于Spring采用AOP的方式管理事务，因此，可以在事务回滚动作中插入用户自己的动作，而不仅仅是执行系统默认的回滚（此点非常的强大~~~~）*
Spring声明式事务管理的方式也有多种，下面主要介绍几种情况的使用方式：
- 单独配置每个Bean的代理（使用TransactionProxyFactoryBean）
在Spring1.X中，声明式事务使用TransactionProxyFactoryBean来配置事务代理Bean。正如它的类名所暗示的，它是一个专门为目标Bean生成事务代理的工厂Bean。
既然TransactionProxyFactoryBean产生的是事务代理Bean，可见Spring的声明式事务策略是基于Spring AOP的。
// @since 21.08.2003 它出现的时间非常的早 public class TransactionProxyFactoryBean extends AbstractSingletonProxyFactoryBean implements BeanFactoryAware { // 从内部可以看出来，它最终还是委托给TransactionInterceptor去管理事务的~~~ private final TransactionInterceptor transactionInterceptor = new TransactionInterceptor(); @Nullable private Pointcut pointcut; ... } // 简单的说：它就是去生成的爱理对象的一个抽象实现。单例代理对象 // 它还有一个著名的实现类：`CacheProxyFactoryBean` 和 Cache相关的FactoryBean 不过他是从Spring3.1开始的 public abstract class AbstractSingletonProxyFactoryBean extends ProxyConfig implements FactoryBean<Object>, BeanClassLoaderAware, InitializingBean {...}
示例配置如下（此处不使用XML配置，而使用Config类配置）：
@Bean public TransactionProxyFactoryBean transactionProxyFactoryBean(PlatformTransactionManager transactionManager) { TransactionProxyFactoryBean transactionProxyFactoryBean = new TransactionProxyFactoryBean(); // 设置事务管理器 去管理这个Bean的事务关系 transactionProxyFactoryBean.setTransactionManager(transactionManager); // 设置目标对象 // 这里需要注意：这里设置了目标对象，你的HelloServiceImpl就不允许再交给Spring管理了 否则会有两个Bean，注入会报错的 transactionProxyFactoryBean.setTarget(new HelloServiceImpl()); // 设置事务相关的属性：transactionAttributes Properties transactionAttributes = new Properties(); transactionAttributes.setProperty("*", "PROPAGATION_REQUIRED"); transactionProxyFactoryBean.setTransactionAttributes(transactionAttributes); return transactionProxyFactoryBean; }
测试一把：
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes = {RootConfig.class, JdbcConfig.class}) public class TestSpringBean { @Autowired private HelloService helloService; @Test public void test1() { System.out.println(helloService.getClass()); //class com.sun.proxy.$Proxy24 helloService.hello(); } }
- 所有Bean共享一个代理基类
这其实是第一种方式的一种变体，只需要把需要代理的Bean继承自TransactionProxyFactoryBean，然后自己setTarget()一下。或者在设置一些通用属性了，类似如下：
// 此处transactionBase就是它：TransactionProxyFactoryBean，并且标记为 abstract="true" <bean id="userDao" parent="transactionBase" > <property name="target" ref="userDaoTarget" /> </bean>
- 使用拦截器（AOP方式的直接使用）
// 配置一个事务的拦截器（相当于一个AOP的`环绕通知`） @Bean public TransactionInterceptor transactionInterceptor(PlatformTransactionManager transactionManager) { TransactionInterceptor transactionProxyFactoryBean = new TransactionInterceptor(); // 设置事务管理器 去管理这个Bean的事务关系 transactionProxyFactoryBean.setTransactionManager(transactionManager); // 设置事务相关的属性：transactionAttributes Properties transactionAttributes = new Properties(); transactionAttributes.setProperty("*", "PROPAGATION_REQUIRED"); transactionProxyFactoryBean.setTransactionAttributes(transactionAttributes); return transactionProxyFactoryBean; } // 配置一个自动代理创建器 决定这个事务拦截器要作用于哪些Bean上 @Bean public BeanNameAutoProxyCreator beanNameAutoProxyCreator() { BeanNameAutoProxyCreator proxyCreator = new BeanNameAutoProxyCreator(); proxyCreator.setBeanNames("*ServiceImpl"); // 此处这个BeanName一定要对应上~~~~ proxyCreator.setInterceptorNames("transactionInterceptor"); return proxyCreator; }
- 使用tx标签配置的拦截器
类似于xml的这种方式：
<tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="*" propagation="REQUIRED" /> </tx:attributes> </tx:advice> <aop:config> <aop:pointcut id="interceptorPointCuts" expression="execution(* com.fsx.demo.*.*(..))" /> <aop:advisor advice-ref="txAdvice" pointcut-ref="interceptorPointCuts" /> </aop:config>
- 全注解
@Transactional（当下最常用的一种方式~~~）
该种方式也是今天要讲的一种主要的方式，下面会在详细讲述~
编程式事务（3种方式）
编程式事务使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。
和编程式事务相比，声明式事务唯一不足地方是，它的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别
但是即便有这样的需求，也存在很多变通的方法，比如，可以将需要进行事务管理的代码块独立为方法即可达到通用的效果
方式一：使用TransactionTemplate（推荐）
先配置一个TransactionTemplate这个Bean到容器~~
// 配置一个事务模版，用于编程式事务 // 这里面也可以通过构造函数传入一个TransactionDefinition接口的实例。表示事务的一些属性~~~~ @Bean public TransactionTemplate transactionTemplate(PlatformTransactionManager transactionManager) { TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager); return transactionTemplate; }
然后直接使用：
@Override public Object hello() { return transactionTemplate.execute(transactionStatus -> { // 向数据库插入一条记录 String sql = "insert into user (name,age) values ('fsx',21)"; jdbcTemplate.update(sql); // 做其余的事情 可能抛出异常 System.out.println(1 / 0); return "service hello"; }); }
就这样，相当于里面的逻辑在事务里面执行。可以实现非常精细的控制了~~~~
// 继承自DefaultTransactionDefinition表示会有一个默认的事务属性~~~ public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations, InitializingBean { // 内部真正管理事务的，肯定还是PlatformTransactionManager @Nullable private PlatformTransactionManager transactionManager; // 构造函数 public TransactionTemplate() { } public TransactionTemplate(PlatformTransactionManager transactionManager) { this.transactionManager = transactionManager; } // 自己可以指定一个TransactionDefinition，覆盖默认的行为 public TransactionTemplate(PlatformTransactionManager transactionManager, TransactionDefinition transactionDefinition) { super(transactionDefinition); this.transactionManager = transactionManager; } // 真正给外面调用的，仅仅只有这一个方法而已~~~~用lambda来实现也非常的优雅~ @Override @Nullable public <T> T execute(TransactionCallback<T> action) throws TransactionException { ... } ... }
方式二：使用PlatformTransactionManager
当然我们也可以操作底层的API，直接使用PlatformTransactionManager来自己管理事务~~~
@Autowired private PlatformTransactionManager transactionManager; @Override public Object hello() { // 构造一个准备使用此事务的定义信息~~~ DefaultTransactionDefinition transactionDefinition = new DefaultTransactionDefinition(); transactionDefinition.setReadOnly(false); //隔离级别,-1表示使用数据库默认级别 transactionDefinition.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED); transactionDefinition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED); // 根据此事务属性，拿到一个事务实例 注意此处的入参是一个：TransactionDefinition TransactionStatus transaction = transactionManager.getTransaction(transactionDefinition); try { // =================做你的逻辑start 必须try住，但无需写finally======================= // 向数据库插入一条记录 String sql = "insert into user (name,age) values ('fsx',21)"; jdbcTemplate.update(sql); // 做其余的事情 可能抛出异常 System.out.println(1 / 0); // =================做你的逻辑start======================= // 提交事务 transactionManager.commit(transaction); } catch (Exception e) { // 若发现异常 事务进行回滚 transactionManager.rollback(transaction); throw e; } return "service hello"; }
这样也实现了事务的控制。优点是更精细，缺点是侵入性太强，且编码负责。
