7.1 时机点分析
7.2 代理对象创建流程
7.3 Spring声明式事务控制
- 7.3.1 @EnableTransactionManagement

7.1 时机点分析

public void test() {
    ApplicationContext context = AnnotationConfigApplicationContext(SpringConfig.class);
    TestBean bean = context.getBean(TestBean.class);
    bean.tech();
}

我们发现在 getBean 之前，TestBean对象已经产⽣（即在第⼀⾏初始化代码中完成），⽽且该对象
是⼀个代理对象（Cglib代理对象），我们断定，容器初始化过程中⽬标Bean已经完成了代理，返回了代
理对象。

7.2 代理对象创建流程

AbstractAutowireCapableBeanFactory#initializeBean ```java /**

初始化Bean
包括Bean后置处理器初始化
Bean的⼀些初始化⽅法的执⾏init-method

Bean的实现的声明周期相关接⼝的属性注⼊ */ protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) { // 执⾏所有的AwareMethods if (System.getSecurityManager() != null) {

  AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
      invokeAwareMethods(beanName, bean);
      return null;
  }, getAccessControlContext());

}else {

  invokeAwareMethods(beanName, bean);

} Object wrappedBean = bean;

if (mbd == null || !mbd.isSynthetic()) {

  // 执⾏所有的BeanPostProcessor#postProcessBeforeInitialization 初始化之前
  // 的处理器⽅法
  wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean,
  beanName);

} try {

  // 这⾥就开始执⾏afterPropertiesSet（实现了InitializingBean接⼝）⽅法和
  initMethod
  invokeInitMethods(beanName, wrappedBean, mbd);

} catch (Throwable ex) { throw new BeanCreationException(

  (mbd != null ? mbd.getResourceDescription() : null),
  beanName, "Invocation of init method failed", ex);

}

if (mbd == null || !mbd.isSynthetic()) {

  // 整个Bean初始化完成，执⾏后置处理器⽅法
  wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean,
  beanName);

} return wrappedBean; } ```

AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization

@Override
public Object applyBeanPostProcessorsAfterInitialization(Object
existingBean, String beanName) throws BeansException {
 Object result = existingBean;
 // 循环执⾏后置处理器
 for (BeanPostProcessor processor : getBeanPostProcessors()) {
     Object current = processor.postProcessAfterInitialization(result,
     beanName);
     if (current == null) {
     return result;
 }
 result = current;
 }
 return result;
}

上一步找到名为proxyTargetClass的这个BeanPostprocessor，然后看他执行的postProcessAfterInitialization方法。

创建代理对象的后置处理器AbstractAutoProxyCreator#postProcessAfterInitialization

@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String
beanName) {
 if (bean != null) {
     // 检查下该类是否已经暴露过了（可能已经创建了，⽐如A依赖B时，创建A时候，就会先
     // 去创建B。
     // 当真正需要创建B时，就没必要再代理⼀次已经代理过的对象）,避免重复创建
     Object cacheKey = getCacheKey(bean.getClass(), beanName);
     if (this.earlyProxyReferences.remove(cacheKey) != bean) {
         return wrapIfNecessary(bean, beanName, cacheKey);
     }
 }
 return bean;
}

AbstractAutoProxyCreator#wrapIfNecessary

protected Object wrapIfNecessary(Object bean, String beanName, Object
cacheKey) {
 // targetSourcedBeans包含，说明前⾯创建过
 if (StringUtils.hasLength(beanName) &&
     this.targetSourcedBeans.contains(beanName)) {
     return bean;
 }
 if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
     return bean;
 }
 if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(),
 beanName)) {
     this.advisedBeans.put(cacheKey, Boolean.FALSE);
     return bean;
 }
 // Create proxy if we have advice.
 // 得到所有候选Advisor，对Advisors和bean的⽅法双层遍历匹配，最终得到⼀个
 // List<Advisor>，即specificInterceptors
 Object[] specificInterceptors =
 getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
 if (specificInterceptors != DO_NOT_PROXY) {
     this.advisedBeans.put(cacheKey, Boolean.TRUE);
     // 重点，创建代理对象
     Object proxy = createProxy(
     bean.getClass(), beanName, specificInterceptors, new
     SingletonTargetSource(bean));
     this.proxyTypes.put(cacheKey, proxy.getClass());
     return proxy;
 }
 this.advisedBeans.put(cacheKey, Boolean.FALSE);
 return bean;
}

AbstractAutoProxyCreator#createProxy ```java /**

Create an AOP proxy for the given bean.
为指定 bean 创建代理对象 */ protected Object createProxy(Class<?> beanClass, @Nullable String beanName, @Nullable Object[] specificInterceptors, TargetSource targetSource) { if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
```
  AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory)
  this.beanFactory, beanName, beanClass);
```
} // 创建代理的⼯作交给ProxyFactory ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.copyFrom(this); // 根据⼀些情况判断是否要设置proxyTargetClass=true if (!proxyFactory.isProxyTargetClass()) {
```
  if (shouldProxyTargetClass(beanClass, beanName)) {
      proxyFactory.setProxyTargetClass(true);
  }else {
      evaluateProxyInterfaces(beanClass, proxyFactory);
  }
```
} // 把指定和通⽤拦截对象合并, 并都适配成Advisor Advisor[] advisors = buildAdvisors(beanName, specificInterceptors); proxyFactory.addAdvisors(advisors); // 设置参数 proxyFactory.setTargetSource(targetSource); customizeProxyFactory(proxyFactory); proxyFactory.setFrozen(this.freezeProxy); if (advisorsPreFiltered()) {
```
  proxyFactory.setPreFiltered(true);
```
} // 上⾯准备做完就开始创建代理 return proxyFactory.getProxy(getProxyClassLoader()); } ```

getProxy

public class ProxyFactory extends ProxyCreatorSupport {
 public Object getProxy(ClassLoader classLoader) {
     // ⽤ProxyFactory创建AopProxy, 然后⽤AopProxy创建Proxy, 所以这⾥重要的是看获取的
     // AopProxy
     // 对象是什么,
     // 然后进去看怎么创建动态代理, 提供了两种：jdk proxy, cglib
     return createAopProxy().getProxy(classLoader);
 }
}
public class ProxyCreatorSupport extends AdvisedSupport {
 private AopProxyFactory aopProxyFactory;
 public ProxyCreatorSupport() {
     this.aopProxyFactory = new DefaultAopProxyFactory();
 }
 protected final synchronized AopProxy createAopProxy() {
     if (!this.active) {
         activate();
     }
     //先获取创建AopProxy的⼯⼚, 再由此创建AopProxy
     return getAopProxyFactory().createAopProxy(this);
 }
 public AopProxyFactory getAopProxyFactory() {
     return this.aopProxyFactory;
 }
}

流程就是⽤AopProxyFactory创建AopProxy, 再⽤AopProxy创建代理对象，这⾥的AopProxyFactory默认是DefaultAopProxyFactory，看他的createAopProxy⽅法

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
 @Override
 public AopProxy createAopProxy(AdvisedSupport config) throws
 AopConfigException {
     if (config.isOptimize() || config.isProxyTargetClass() ||
     hasNoUserSuppliedProxyInterfaces(config)) {
         Class<?> targetClass = config.getTargetClass();
         if (targetClass == null) {
             throw new AopConfigException("TargetSource cannot determine target
             class: "
             + "Either an interface or a target is required for proxy
             creation.");
             if (targetClass.isInterface()) {
                 return new JdkDynamicAopProxy(config);
             }
         return new ObjenesisCglibAopProxy(config);
         } else {
             return new JdkDynamicAopProxy(config);
         }
     }
 /**
 * Determine whether the supplied {@link AdvisedSupport} has only the
 * {@link org.springframework.aop.SpringProxy} interface specified (or no
 * proxy interfaces specified at all).
 */
 private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
     Class<?>[] interfaces = config.getProxiedInterfaces();
     return (interfaces.length == 0 || (interfaces.length == 1 &&
     SpringProxy.class.equals(interfaces[0])));
 }
}
}

这⾥决定创建代理对象是⽤JDK Proxy，还是⽤ Cglib 了，最简单的从使⽤⽅⾯使⽤来说：设置proxyTargetClass=true强制使⽤Cglib 代理，什么参数都不设并且对象类实现了接⼝则默认⽤JDK 代理，如果没有实现接⼝则也必须⽤Cglib

@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
if (logger.isTraceEnabled()) {
    logger.trace("Creating CGLIB proxy: " + this.advised.getTargetSource());
}
try {
    Class<?> rootClass = this.advised.getTargetClass();
    Assert.state(rootClass != null, "Target class must be available for
        creating a CGLIB proxy");
    Class<?> proxySuperClass = rootClass;
    if (ClassUtils.isCglibProxyClass(rootClass)) {
        proxySuperClass = rootClass.getSuperclass();
        Class<?>[] additionalInterfaces = rootClass.getInterfaces();
        for (Class<?> additionalInterface : additionalInterfaces) {
            this.advised.addInterface(additionalInterface);
        }
    }
    // Validate the class, writing log messages as necessary.
    validateClassIfNecessary(proxySuperClass, classLoader);
    // 配置 Cglib 增强
    Enhancer enhancer = createEnhancer();
    if (classLoader != null) {
        enhancer.setClassLoader(classLoader);
        if (classLoader instanceof SmartClassLoader &&
            ((SmartClassLoader)
            classLoader).isClassReloadable(proxySuperClass)) {
                enhancer.setUseCache(false);
        }
    }
    enhancer.setSuperclass(proxySuperClass);
    enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
    enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
    enhancer.setStrategy(new
        ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));
    Callback[] callbacks = getCallbacks(rootClass);
    Class<?>[] types = new Class<?>[callbacks.length];
    for (int x = 0; x < types.length; x++) {
        types[x] = callbacks[x].getClass();
    }
    // fixedInterceptorMap only populated at this point, after getCallbacks
    // call above
    enhancer.setCallbackFilter(new ProxyCallbackFilter(
    this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap,
    this.fixedInterceptorOffset));
    enhancer.setCallbackTypes(types);
    // ⽣成代理类，并且创建⼀个代理类的实例
    return createProxyClassAndInstance(enhancer, callbacks);
} catch (CodeGenerationException | IllegalArgumentException ex) {
    throw new AopConfigException("Could not generate CGLIB subclass of " +
    this.advised.getTargetClass() +
        ": Common causes of this problem include using a final class or a
        non-visible class",ex);
} catch (Throwable ex) {
// TargetSource.getTarget() failed
throw new AopConfigException("Unexpected AOP exception", ex);
}
}

总结：AOP代理对象就是在容器初始化时，创建了Bean，Bean创建时的一个BeanPostProcessor的时机进行AOP代理对象的创建。

7.3 Spring声明式事务控制
主要看几个注解：@EnableTransactionManagement @Transactional

7.3.1 @EnableTransactionManagement

@EnableTransactionManagement 注解使⽤ @Import 标签引⼊了TransactionManagementConﬁgurationSelector类，这个类⼜向容器中导⼊了两个重要的组件

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {

这个类⼜向容器中导⼊了两个重要的组件：AutoProxyRegistrar和ProxyTransactionManagementConfiguration ```java public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector { @Override protected String[] selectImports(AdviceMode adviceMode) {

 switch (adviceMode) {
     case PROXY:
         return new String[] {AutoProxyRegistrar.class.getName(),
                 ProxyTransactionManagementConfiguration.class.getName()};
     case ASPECTJ:
         return new String[] {determineTransactionAspectClass()};
     default:
         return null;
 }

}

<a name="o5bb9"></a>
## 7.3.2 加载事务控制组件
1. **AutoProxyRegistrar **类的 registerBeanDeﬁnitions ⽅法中⼜注册了⼀个组件AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
```java
@Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        boolean candidateFound = false;
        Set<String> annTypes = importingClassMetadata.getAnnotationTypes();
        for (String annType : annTypes) {
            AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annType);
            if (candidate == null) {
                continue;
            }
            Object mode = candidate.get("mode");
            Object proxyTargetClass = candidate.get("proxyTargetClass");
            if (mode != null && proxyTargetClass != null && AdviceMode.class ==     mode.getClass() && Boolean.class == proxyTargetClass.getClass()) {
                candidateFound = true;
                if (mode == AdviceMode.PROXY) {
                    AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
                    if ((Boolean) proxyTargetClass) {
                        AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
                        return;
                    }
                }
            }
        }
}

进⼊ AopConﬁgUtils.registerAutoProxyCreatorIfNecessary ⽅法，发现最终，注册了⼀个叫做 InfrastructureAdvisorAutoProxyCreator 的 Bean，⽽这个类是AbstractAutoProxyCreator 的⼦类，实现了 SmartInstantiationAwareBeanPostProcessor 接⼝

@Nullable
 public static BeanDefinition registerAutoProxyCreatorIfNecessary(
         BeanDefinitionRegistry registry, @Nullable Object source) {
     return                                                                                         registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class,                 registry, source);
 }

它实现了SmartInstantiationAwareBeanPostProcessor，说明这是⼀个后置处理器，⽽且跟spring AOP 开启@EnableAspectJAutoProxy 时注册的 AnnotationAwareAspectJProxyCreator实现的是同⼀个接⼝，所以说，声明式事务是 springAOP 思想的⼀种应⽤

ProxyTransactionManagementConﬁguration 组件：ProxyTransactionManagementConﬁguration是⼀个容器配置类，注册了⼀个组件transactionAdvisor，称为事务增强器，然后在这个事务增强器中⼜注⼊了两个属性：transactionAttributeSource，即属性解析器transactionAttributeSource 和事务拦截器transactionInterceptor

@Configuration
public class ProxyTransactionManagementConfiguration extends
AbstractTransactionManagementConfiguration {
 @Bean(name =
 TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
 @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor()
 {
     // 事务增强器
     BeanFactoryTransactionAttributeSourceAdvisor advisor = new
     BeanFactoryTransactionAttributeSourceAdvisor();
     // 向事务增强器中注⼊ 属性解析器 transactionAttributeSource
     advisor.setTransactionAttributeSource(transactionAttributeSource());
     // 向事务增强器中注⼊ 事务拦截器 transactionInterceptor
     advisor.setAdvice(transactionInterceptor());
     if (this.enableTx != null) {
     advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
     }
     return advisor;
 }
 @Bean
 @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 // 属性解析器 transactionAttributeSource
 public TransactionAttributeSource transactionAttributeSource() {
     return new AnnotationTransactionAttributeSource();
 }
 @Bean
 @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
     // 事务拦截器 transactionInterceptor
     public TransactionInterceptor transactionInterceptor() {
     TransactionInterceptor interceptor = new TransactionInterceptor();
     interceptor.setTransactionAttributeSource(transactionAttributeSource());
     if (this.txManager != null) {
     interceptor.setTransactionManager(this.txManager);
     }
     return interceptor;
 }
}

属性解析器的作⽤之⼀就是⽤来解析@Transaction注解，各种属性会有对应的解析
上述组件如何关联起来的？

事务拦截器实现了MethodInterceptor接⼝，追溯⼀下上⾯提到的InfrastructureAdvisorAutoProxyCreator后置处理器，它会在代理对象执⾏⽬标⽅法的时候获取其拦截器链，⽽拦截器链就是这个TransactionInterceptor，这就把这两个组件联系起来；
构造⽅法传⼊PlatformTransactionManager(事务管理器)、TransactionAttributeSource(属性解析器)，但是追溯⼀下上⾯贴的ProxyTransactionManagementConﬁguration的源码，在注册事务拦截器的时候并没有调⽤这个带参构造⽅法，⽽是调⽤的⽆参构造⽅法，然后再调⽤set⽅法注⼊这两个属性，效果⼀样。

解析过程： ```java @EnableTransactionManagement 注解 1)通过@import引⼊了TransactionManagementConfigurationSelector类它的selectImports⽅法导⼊了另外两个类：AutoProxyRegistrar和 ProxyTransactionManagementConfiguration

2）AutoProxyRegistrar类分析⽅法registerBeanDefinitions中，引⼊了其他类，通过 AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry)引⼊ InfrastructureAdvisorAutoProxyCreator，它继承了AbstractAutoProxyCreator，是⼀个后置处理器类

3）ProxyTransactionManagementConfiguration 是⼀个添加了@Configuration注解的配置类（注册bean）注册事务增强器（注⼊属性解析器、事务拦截器）属性解析器：AnnotationTransactionAttributeSource，内部持有了⼀个解析器集合 Set annotationParsers; 具体使⽤的是SpringTransactionAnnotationParser解析器，⽤来解析@Transactional的事务属性事务拦截器：TransactionInterceptor实现了MethodInterceptor接⼝，该通⽤拦截会在产⽣代理对象之前和aop增强合并，最终⼀起影响到代理对象TransactionInterceptor的invoke⽅法中invokeWithinTransaction会触发原有业务逻辑调⽤（增强事务） ```

Java 框架

7. Spring AOP源码分析

7.1 时机点分析

7.2 代理对象创建流程

7.3 Spring声明式事务控制

7.3.1 @EnableTransactionManagement