上一篇文章我们介绍了事务开启注解@EnableTransactionManagement源码解析《Spring-事务源码解析1》 里面提到了2个关键组件,这里我们分析下Spring如何利用这2个组件来给Bean创建代理对象。
本篇文章我们看下当一个类里面包含了@Transactional注解,Spring如何利用上面说的2个组件来实例化Bean,如何让这个Bean带有事务功能。
下面三个部分用来介绍
1、Bean如何创建具有事务功能的代理类(这里就用到上面2个组件)
2、目标方法执行,如何被拦截事务拦截
3、完整的执行流程
一、Bean如何创建具有事务功能的代理类
1、创建目标类的代理对象
创建Bean当然是看Spring非常经典的doCreateBean方法,这里最终就得到目标类的代理对象,这中间就包含了Spring如何利用后置处理器控制"目标类代理对象"创建,如何利用切点匹配要添加通知的方法。因为doCreateBean内容有点多,这里我也就贴我认为比较重要的一部分代码。
//假设我们的业务类AService带有@Transactional注解,下面通过doCreateBean创建AService的代理对象
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
........1、下面一块代码就是通过反射得到AService的实例对象,这个还只是通过反射拿到了普通的实例对象不是代理对象。
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
........
........2、把普通实例对象封装ObjectFactory对象存入三级缓存,在AOP依赖注入和循环依赖会用到,这里我们先忽略。
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
........
........3、通过AService普通实例对象生成AService的代理对象,也利用了前面提到的2个组件,这里的代理对象就包含了事务功能。逻辑都在"初始化"
Object exposedObject = bean;
populateBean(beanName, mbd, instanceWrapper);//属性填充
exposedObject = initializeBean(beanName, exposedObject, mbd);//初始化
........
........4、利用三级缓存解决依赖注入和循环依赖,这里先忽略。
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
}
}
........
return exposedObject;//返回AService的代理对象
}
下面我们看下Bean的初始化逻辑,如何得到代理对象。
AServcie的普通实例对象初始化。
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
Object wrappedBean = bean;//这里Bean还只是AService的普通实例对象
//执行所有后置处理器的Before方法,本次忽略
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
//如果AServcie实现了InitializingBean接口,执行inint方法,本次忽略
invokeInitMethods(beanName, wrappedBean, mbd);
//重点:执行所有后置处理器的After方法,这里会生成AService的代理对象。
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
return wrappedBean;
}
Spring里面包含了很多后置处理器,那么生成AService代理类的后置处理器,也就是我们前面提到的2个组件
1、AutoProxyRegistrar组件会往Spring容器中注册InfrastructureAdvisorAutoProxyCreator后置处理器
2、ProxyTransactionManagementConfiguration组件会往Spring容器中注册切面进去
在执行到InfrastructureAdvisorAutoProxyCreator后置处理器的After方法里面,主要是为通过调用wrapIfNecessary方法来创建AService代理对象。
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
........
return wrapIfNecessary(bean, beanName, cacheKey); //生成AService的代理对象
}
return bean;
}
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
//根据Bean的信息,来获取AService所有的Advisor,Advisor可以近似的把他理解成切面,当然Advisor和切面不是一个东西,为了方便理解就近似把他看做是切面。
//这里拿到的切面,是符合AService的切面,就Spring会有很多事务相关的切面,每个切面有自己定义的切点规则,比如有的切面处理@X注解的,有的切面只处理@Transactional
//这里只返回AService符合切点规则的那个切面。为什么要拿切面,因为Spring在创建代理类的时候,就是要基于切面里面的通知,来对目标方法进行拦截。
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
//利用Advices来生成AService的代理对象。
Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
return proxy;
}
return bean;
}
wrapIfNecessary分为2块内容
1、拿到符合目标类的Advisor或者说符合目标类的切面
2、创建代理对象
1.1 getAdvicesAndAdvisorsForBean是如何获取符合规则的Advisor
//获取切面
@Override
@Nullable
protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);//获取切面
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
}
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
//1、拿到所有事务的切面
List<Advisor> candidateAdvisors = findCandidateAdvisors();
//2、过滤出AService符合切点规则
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
return eligibleAdvisors;
}
上面包含2块内容,第一块是获取所有切面,第二块是过滤出符合规则的切面,下面我们分别看下如何获取所有切面。
//获取所有的Advisor,这里的Advisor就包含了,我们前面提到的组件ProxyTransactionManagementConfiguration,
//ProxyTransactionManagementConfiguration会往Spring容器里面注册3个Bean。 切面、切点、通知。
//其中切面BeanFactoryTransactionAttributeSourceAdvisor, 就是我们这里要拿到的。
public List<Advisor> findAdvisorBeans() {
String[] advisorNames = this.cachedAdvisorBeanNames;
if (advisorNames == null) {
advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Advisor.class, true, false);
this.cachedAdvisorBeanNames = advisorNames;
}
List<Advisor> advisors = new ArrayList<>();
for (String name : advisorNames) {
........
advisors.add(this.beanFactory.getBean(name, Advisor.class));//通过Name获取Advisor对应的Bean,这里就是BeanFactoryTransactionAttributeSourceAdvisor
........
}
return advisors;
}
上面拿到了所有切面,下面开始过滤符合当前目标类的切面
//从Advisor集合中,挑选出beanClass符合的Advisor
protected List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
}
public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
List<Advisor> eligibleAdvisors = new ArrayList<>();//定义符合规则的Advisor集合,同以最终返回。
//引介切面过滤
for (Advisor candidate : candidateAdvisors) {
//如果Advisor是"引介切面",并且符合规则,引介切面是基于类层面判断是否符合规则
if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
eligibleAdvisors.add(candidate);
}
}
//切点切面过滤
boolean hasIntroductions = !eligibleAdvisors.isEmpty();
for (Advisor candidate : candidateAdvisors) {
if (candidate instanceof IntroductionAdvisor) {
continue;
}
//进到这里说明这个Advisor是切点切面,切面切面是基于方法层面判断是否符合规则。
if (canApply(candidate, clazz, hasIntroductions)) {
eligibleAdvisors.add(candidate);
}
}
return eligibleAdvisors;
}
canApply用来判断方法或者类是否匹配
public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
if (advisor instanceof IntroductionAdvisor) {//引介切面类型,通过类来匹配
return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
} else if (advisor instanceof PointcutAdvisor) { //切点切面类型,通过方法判断
PointcutAdvisor pca = (PointcutAdvisor) advisor;
return canApply(pca.getPointcut(), targetClass, hasIntroductions);
} else {
return true;
}
}
//通过方法层面判断,其实就是判断方法是否有@Transactional注解,当然每个切点的实现不一样,判断逻辑也会有差异
public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
MethodMatcher methodMatcher = pc.getMethodMatcher();
if (methodMatcher == MethodMatcher.TRUE) {//判断是否是默认的
return true;
}
//拿到类型
Set<Class<?>> classes = new LinkedHashSet<>();
if (!Proxy.isProxyClass(targetClass)) {
classes.add(ClassUtils.getUserClass(targetClass));
}
classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
//拿到目标类
for (Class<?> clazz : classes) {
//获取所有方法
Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
for (Method method : methods) {
//判断方法是否匹配,这里其实通过切点类判断是否方法是否包含特定注解。比如@Transactional
if (methodMatcher.matches(method, targetClass)) {
return true;
}
}
}
return false;
}
1.1小结
这一段我们讲了如何利用getAdvicesAndAdvisorsForBean拿到目标类的advisor,因为Spring在整个启动过程中会存在很多advisor,不是所有的advisor都能给AService来用,我们需要通过切面中的切点规则来判断是否符合规则。
1.2 拿到符合规则的advisor,生成代理对象
再回到wrapIfNecessary方法的第二块内容生成代理对象。
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
//拿到符合规则的advisor
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
//2、结合advisor,生成AService的代理对象。
Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
return proxy;
}
return bean;
}
protected Object createProxy(Class<?> beanClass, @Nullable String beanName, @Nullable Object[] specificInterceptors, TargetSource targetSource) {
//创建ProxyFactory,用来生成代理对象
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.copyFrom(this);
//拿到切面,添加进去
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
proxyFactory.addAdvisors(advisors);
proxyFactory.setTargetSource(targetSource);
proxyFactory.setFrozen(this.freezeProxy);
...省略部分代理
return proxyFactory.getProxy(getProxyClassLoader());
}
上面最终调用getProxy方法来生成代理对象,那么JDK和Cglib都实现了getProxy方法,这里我们分别看下他们如何创建对象。
1.2.1 JDK代理的getProxy方法
@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
//拿到代理类需要实现的接口
Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
...省略部分代理
//这里的this是JdkDynamicAopProxy
//生成代理对象,代理对象需要实现proxiedInterfaces集合所有接口
//当目标对象被调用的时候,会先进到JdkDynamicAopProxy的invoke方法里面
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}
1.2.2 Cglib代理的getProxy方法
@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
//获取代理类需要继承的父类
Class<?> rootClass = this.advised.getTargetClass();
Class<?> proxySuperClass = rootClass;
if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
proxySuperClass = rootClass.getSuperclass();
Class<?>[] additionalInterfaces = rootClass.getInterfaces();
for (Class<?> additionalInterface : additionalInterfaces) {
this.advised.addInterface(additionalInterface);
}
}
Enhancer enhancer = createEnhancer();
enhancer.setSuperclass(proxySuperClass); //代理类的父类,也就是目标类AServcie
enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised)); //代理类需要实现的接口
enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));
//添加回调方法,这些回调类都实现了MethodInterceptor接口,当AService的方法被调用时,会进到MethodInterceptor里面的intercept方法里面去
Callback[] callbacks = getCallbacks(rootClass);
Class<?>[] types = new Class<?>[callbacks.length];
enhancer.setCallbackFilter(new ProxyCallbackFilter(this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
。。。。。。省略部分代码
return createProxyClassAndInstance(enhancer, callbacks);
}
getCallbacks会拿到很多MethodInterceptor的实现类,作为回调添加到代理类里面去,当AService有方法被调用时,就会进被MethodInterceptor的intercept方法拦截,在intercept里面调用切面里面的通知方法。这里MethodInterceptor的实现类就包含DynamicAdvisedInterceptor。
1.2小结
通过JDK和Cglib创建代理类,并添加拦截方法,在AService方法被执行时,被invoke方法或者intercept方法拦截。
三、目标方法执行,如何被拦截事务拦截
上面我们介绍了,如何创建代理对象,并且在创建代理对象时拦截目标方法,这里我们看下当目标方法被执行,在拦截里面做了什么操作。
当目标方法被调用时,会被JdkDynamicAopProxy的invoke方法拦截,或者是MethodInterceptor的intercept方法拦截,在invoke和intercept里面会通过切面拿到通知,在挨个的执行通知最后在执行目标方法
1、Jdk的invoke
@Override
@Nullable
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//获取符合目标方法的拦截器MethodInterceptor集合
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
if (chain.isEmpty()) {
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);//如果拦截器集合为空,就直接调用目标方法
} else {
//生成拦截器链
MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
retVal = invocation.proceed();
}
return retVal;
}
2、Cglib的intercept方法
@Override
@Nullable
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
target = targetSource.getTarget();
Class<?> targetClass = (target != null ? target.getClass() : null);
//1、获取符合目标方法的拦截器MethodInterceptor集合。这里是拿切里的通知,通知是MethodInterceptor类型
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
Object retVal;
if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
retVal = methodProxy.invoke(target, argsToUse);//如果拦截器集合为空,就直接调用目标方法
} else {
//2、生成拦截器链,使用的是责任链设计模式。在挨个调用拦截器。最后调用目标方法
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
}
retVal = processReturnType(proxy, target, method, retVal);
return retVal;
}
关于获取拦截器集合和调用拦截器链,可以看到我的这篇文章《代理生成拦截器和调用拦截器》
3、触发事务拦截器
然后执行拦截器链中的最开始的拦截器,后面一次遍历,但是此时的拦截器就只有一个就是TransactionInterceptor事务方法拦截器
进到TransactionInterceptor就会执行TransactionInterceptor的invoke方法,下面看下invoke的流程
1、先拿到事务管理器的事务类型:PROPAGATION_REQUIRED,ISOLATION_DEFAULT;
2、在拿到事务的管理器也就是DataSourceTransactionManager
@Override
public Object invoke(final MethodInvocation invocation) throws Throwable {
//目标类
Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
//执行切面方法和目标方法
return invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback() {
@Override
public Object proceedWithInvocation() throws Throwable {
return invocation.proceed();
}
});
}
protected Object invokeWithinTransaction(Method method, Class<?> targetClass, final InvocationCallback invocation) throws Throwable {
//1、事务隔离级别
final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
//2、事务管理器DataSourceTransactionManager
final PlatformTransactionManager tm = determineTransactionManager(txAttr);
//生成事务txInfo,里面包含本次事务状态,隔离级别,事务处理器,当本次事务执行完后需要关闭本次事务
TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
try {
//执行进入下一个链,此时只有一个也就是目标方法
retVal = invocation.proceedWithInvocation();
}
catch (Throwable ex) {
//更改txInfo里面的状态
completeTransactionAfterThrowing(txInfo, ex);
throw ex;
}
finally {
cleanupTransactionInfo(txInfo);
}
commitTransactionAfterReturning(txInfo);//根据状态是否commit
return retVal;
}
总结
1、前面我们在Bean的实例化时,用到了第一个组件InfrastructureAdvisorAutoProxyCreator,用来触发wrapIfNecessary方法。
2、在wrapIfNecessary方法里面,我们利用了第二个组件ProxyTransactionManagementConfiguration生成的切面BeanFactoryTransactionAttributeSourceAdvisor,通过BeanFactoryTransactionAttributeSourceAdvisor的切点AnnotationTransactionAttributeSource,来判断AService是否符合切点规则,也就是解读AService类的方法是否包含@Transactional注解。
五、疑问
1、带有@Transaction注解的Bean实例化的时候,怎么如果判断该Bean带有@Transaction方法
1、InfrastructureAdvisorAutoProxyCreator#postProcessAfterInitialization
—>2、BeanFactoryTransactionAttributeSourceAdvisor
—>3、AnnotationTransactionAttributeSource
—>4、SpringTransactionAnnotationParser判断@Transaction
最终通过SpringTransactionAnnotationParser来判断Bean的方法是否带有@Transaction注解
拓展:
InfrastructureAdvisorAutoProxyCreator里面有个advisedBeans属性,在Bean的创建过程会判断Bean里面 是否是带有事务注解@Transaction的方法,如果有就会被加到advisedBeans里面去。
private final Map<Object, Boolean> advisedBeans = new ConcurrentHashMap<Object, Boolean>(256);
注意:
1、BeanFactoryTransactionAttributeSourceAdvisor事务增强器在advisedBeans是false的形式存在
2、transactionInterceptor也是false
2、带有@Transaction注解的代理Bean在哪个流程被创建
在执行BeanPostProcess处理器链的时候,由InfrastructureAdvisorAutoProxyCreator#postProcessAfterInitialization方法执行创建,该方法会调用wrapIfNecessary方法完成代理创建
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
.......
//这里是拿到BeanFactoryTransactionAttributeSourceAdvisor也就是“事务增强器”
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);//key就是带有@Transaction的BeanName
Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
return proxy;//返回代理对象
}
return bean;
}
3、如何创建@Transaction注解的Bean
默认是使用JDK动态代理
1、先创建ProxyFactory对象,设置属性
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTargetSource(目标对象LLServcieImpl);
proxyFactory.setInterfaces(目标接口LLServcie);
proxyFactory.addAdvisor(事务增强器BeanFactoryTransactionAttributeSourceAdvisor);
proxyFactory.getProxy(getProxyClassLoader())//调用下面的代码
//2、生成动态代理对象
proxiedInterfaces=AopProxyUtils.completeProxiedInterfaces(事务增强器, true);
//设置代理对象要实现接口和InvocationHandler对象
Proxy.newProxyInstance(classLoader, proxiedInterfaces, JdkDynamicAopProxy类);
其中proxiedInterfaces包含接口
0 = {Class@3511} “interface cn.tedu.sample2.util.LLServcie”
1 = {Class@3676} “interface org.springframework.aop.SpringProxy”
2 = {Class@5780} “interface org.springframework.aop.framework.Advised”
3 = {Class@3897} “interface org.springframework.core.DecoratingProxy”
4、InfrastructureAdvisorAutoProxyCreator类的作用
1、postProcessBeforeInstantiation方法主要是针对所有要创建的Bean,判断存到advisedBeans里面是false还是true
2、postProcessAfterInitialization方法,处理带有@Transcation的Bean,创建代理Bean
六、总结
1、先通过@EnableTransactionManagement引入TransactionManagementConfigurationSelector
2、通过TransactionManagementConfigurationSelector,导入AutoProxyRegistrar,ProxyTransactionManagementConfiguration
3、AutoProxyRegistrar会向容器中注册InfrastructureAdvisorAutoProxyCreator
4、ProxyTransactionManagementConfiguration会向容器定义三个Bean:事务增强器、@Transaction注解解析器、事务方法拦截器
5、执行Bean的后置处理器时,通过InfrastructureAdvisorAutoProxyCreator的postProcessAfterInitialization方法创建代理对象
6、创建代理对象时,通过事务增强器BeanFactoryTransactionAttributeSourceAdvisor来得到代理类要实现的接口SpringProxy、Advised、DecoratingProxy,最终生成代理对象
7、当请求进来时,先进入JdkDynamicAopProxy的invoke方法
8、invoke里面会调用TransactionInterceptor的invoke方法,里面会调用invokeWithinTransaction方法
9、invokeWithinTransaction里面会在调用目标方法前开启事务,catch失败设置状态,然后finally根据状态来确认是否commit
![](https://i-blog.csdnimg.cn/blog_migrate/62fa7cfbf05b63ae44c597c8a7ad1be9.png)