Spring事务是基于Aop,具体而言是通过一个TransactionInterceptor的拦截器来实现。下面整理一下Spring实现事务操作的具体流程，以便于以后复习。
一.注解EnableTransactionManagement
使用EnableTransactionManagement注解可以开启Spring事务，而EnableTransactionManagement源代码如下：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {
boolean proxyTargetClass() default false;
/**
* 默认是使用代理的通知模式
*/
AdviceMode mode() default AdviceMode.PROXY;
int order() default Ordered.LOWEST_PRECEDENCE;
}
阅读上述类的源代码，我们需要注意两点：
- 我们需要去了解TransactionManagementConfigurationSelector.class的功能
- Spring事务默认是使用Proxy代理模式
二. TransactionManagementConfigurationSelector
该类实现了ImportSelector接口，通过覆写selectImports()方法，手动将java类注册到Spring框架的IOC容器中
@Override protected String[] selectImports(AdviceMode adviceMode) { switch (adviceMode) { case PROXY: // 默认就是Proxy模式 return new String[] {AutoProxyRegistrar.class.getName(),ProxyTransactionManagementConfiguration.class.getName()}; case ASPECTJ: return new String[] {determineTransactionAspectClass()}; default: return null; } }
通过上述源代码可知，Spring默认将AutoProxyRegistrar.class和ProxyTransactionManagementConfiguration.class注入到IOC容器。
接下来，应该是看看这两个类到底干了什么事？
三. AutoProxyRegistrar
跟踪源代码可知，Spring会将InfrastructureAdvisorAutoProxyCreator.class注入到IOC容器，然后请看该类类图：
由图知InfrastructureAdvisorAutoProxyCreator.class是一个BeanPostProcessor.class的子类，理论上它可以在Spring初始化bean之前或之后进行功能增强，Sping框架原生选择是之后增强，具体的增强方法是在AbstractAutoProxyCreator#postProcessAfterInitialization()方法。
接下来请看看postProcessAfterInitialization()方法源码：
@Override public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) { if (bean != null) { Object cacheKey = getCacheKey(bean.getClass(), beanName); if (this.earlyProxyReferences.remove(cacheKey) != bean) { return wrapIfNecessary(bean, beanName, cacheKey); } } return bean; }
/** Wrap the given bean if necessary * 对bean进行包装，其实就是创建代理对象 */ protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) { // 省略。。。。 // Create proxy if we have advice. Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null); if (specificInterceptors != DO_NOT_PROXY) { this.advisedBeans.put(cacheKey, Boolean.TRUE); // 创建代理，jdk动态代理或者cglib代理 Object proxy = createProxy( bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean)); this.proxyTypes.put(cacheKey, proxy.getClass()); return proxy; } }
上述代码的作用就是，Spring在bean初始化之后，会判断该bean是否需要创建一个代理对象，如果需要，就会使用jdk动态代理或者cglib创建一个代理类(这一块不是本篇文章分析的重点)。
到此，AutoProxyRegistrar.class类的功能就分析完毕。
四. ProxyTransactionManagementConfiguration
该类主要是在IOC容器中注入事务拦截器TransactionInterceptor.class和Spring的事务注册解析器，具体源码如下：
@Configuration public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration { /** * 事务注册解析器 */ @Bean @Role(BeanDefinition.ROLE_INFRASTRUCTURE) public TransactionAttributeSource transactionAttributeSource() { return new AnnotationTransactionAttributeSource(); } /** * 事务拦截器 */ @Bean @Role(BeanDefinition.ROLE_INFRASTRUCTURE) public TransactionInterceptor transactionInterceptor() { TransactionInterceptor interceptor = new TransactionInterceptor(); interceptor.setTransactionAttributeSource(transactionAttributeSource()); if (this.txManager != null) { interceptor.setTransactionManager(this.txManager); } return interceptor; } }
继续跟踪源码，咱们会发现AnnotationTransactionAttributeSource.class的底层调用了SpringTransactionAnnotationParser.class，由类名就可知道这个类的作用。事实上它也确实是解析@Transactional，具体可以参看该类源码，很简单的。
查看类图可知TransactionInterceptor.class是Advice的一个实现，而且是MethodInterceptor接口的一个实现，这说明它跟Spring Aop中前置、后置通知一样，事实上它就是一个环绕通知(around advice),完全遵守底层的责任链调用模式。
五. 事务调用链
为了便于理解，先创建一个测试demo
- DAO层
@Repository public class UserDao { @Autowired private JdbcTemplate jdbcTemplate; public void addUser() { jdbcTemplate.update("INSERT t_user(userName,age) VALUES ('test',100);"); } }
- Service层
public interface UserService { public void addUser(); }
@Service public class UserServiceImpl implements UserService { @Autowired private UserDao userDao; @Override @Transactional public void addUser() { userDao.addUser(); // int i = 1 / 0; } }
- 配置类
@Configuration @ComponentScan("qinfeng.zheng.spring01.v6") @EnableTransactionManagement // 开启事务 public class SpringConfig { @Bean public DataSource dataSource() { MysqlDataSource dataSource = new MysqlDataSource(); dataSource.setUser("root"); dataSource.setPassword("xxxxxxx"); dataSource.setURL("jdbc:mysql://xxx.xxx.xx.xx:3306/tb_user?useUnicode=true&characterEncoding=UTF-8"); // dataSource.setDatabaseName("tb_user"); return dataSource; } @Bean public JdbcTemplate jdbcTemplate() { return new JdbcTemplate(dataSource()); } @Bean public PlatformTransactionManager txManager() { return new DataSourceTransactionManager(dataSource()); } }
- 启动类
public class App { public static void main(String[] args) { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class); UserService orderService = context.getBean(UserService.class); orderService.addUser(); } }
直接在启动类上的orderService.addUser();这一行代码上戳个断点，然后debug走起来。。。
由上图知orderService其实是一个JdkDynamicAopProxy的代理对象，然后咱们F7，会进入到JdkDynamicAopProxy#invoke()方法。
@Override @Nullable public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // .... // 获取当前方法的拦截器链 List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass); if (chain.isEmpty()) { // 如果拦截链为空 //..... } else { // 创建一个MethodInvocation对象,其实就是对proxy, target, method, args, targetClass, chain这些参数的封装 MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain); // 调用拦截器链 retVal = invocation.proceed(); } //...... return retVal; } //..... }
通过debug可知，chain链中有且只有一个 元素，而且这个元素就是前面注册的TransactionInterceptor.class, 还记得这个类吗？Spring的事务全靠它呢！
继续debug....
通过debug很容易发现invocation对象的真实类型是ReflectiveMethodInvocation.class， 这个类在分析Spring Aop的调用链时超级重要。因为本篇主要讲Spring事务，所以咱们直接进入该类的proceed()方法。
@Override @Nullable public Object proceed() throws Throwable { // 调用真实业务方法,底层也是通过反射 if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) { return invokeJoinpoint(); } Object interceptorOrInterceptionAdvice = his.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex); if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) { }else { // this很重要,这里会递归调用proceed() return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this); } }
因为interceptorOrInterceptionAdvice的真实类型是TransactionInterceptor.class，所以debug进入TransactionInterceptor#invoke()。
public Object invoke(MethodInvocation invocation) throws Throwable { //真实目标类 Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null); //重点分析该方法 return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed); }
@Nullable protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,final InvocationCallback invocation) throws Throwable { if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) { // 开启事务,底层会启用jdbc开启事务, TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification); // 目标方法返回值 Object retVal; try { // This is an around advice: Invoke the next interceptor in the chain. // 这是一个环绕通知: 即将调用拦截链中的下一个拦截器 // This will normally result in a target object being invoked. // 调用目标方法,返回正常结果` retVal = invocation.proceedWithInvocation(); } catch (Throwable ex) { // 如果目标方法抛出异常,这里会回滚事务 completeTransactionAfterThrowing(txInfo, ex); throw ex; } finally { // 清埋事务 cleanupTransactionInfo(txInfo); } // commit事务 commitTransactionAfterReturning(txInfo); return retVal; }else{ //..... } }
当程序运行到invocation.proceedWithInvocation();这句代码时，注释写得很明白，它会去执行链中的下一个拦截器，所以程序又会回到ReflectiveMethodInvocation#proceed()方法。 我们debug跟踪一下。
通过debug很清楚看到了程序的调用步骤。
程序本次进入ReflectiveMethodInvocation#proceed()方法后，会进入if条件，然后执行invokeJoinpoint()方法，该方法的底层就是使用反射机制调用自定义的业务方法，于本例而言就是调用addUser()方法。
调用addUser()方法， 获取方法返回值 ，然后程序又会回到invokeWithinTransaction()方法。
六. 结束
Spring的事务的大体流程就说到这里了，示例结合debug应该还是很清楚的，至于其中的许多细节，还有待研究，后面继续补充
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
