spring-beanFactory四

前面简单介绍了beanFactory提供的ioc，我们都知道spring使用jdk的动态代理实现了aop，这篇就来看看spring中的aop到底是怎么回事。

前面有提到，在beanFactory中，getBean会走到AbstractAutowireCapableBeanFactory中的doCreateBean，doCreateBean有如下代码段，populateBean主要是xml注入，initializeBean是初始化，产生aop的逻辑就在initializeBean中。

//doCreateBean的主要逻辑
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
    throws BeanCreationException {
    //使用工厂方法、构造器注入、简单实例化等策略实例化bean（不是策略模式，只是通过bean definition来决定使用哪种策略，类似switch）
    //BeanWrapper是bean的包装类，beanWrapper提供了便捷的方法去更新bean的字段、访问bean的方法，用于注入
    BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);//离我们很近
    final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    //MergedBeanDefinitionPostProcessor的void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName)
    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
    // Initialize the bean instance.
    //exposedObject即暴露的bean、原生的bean
    Object exposedObject = bean;
    //先执行InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation，
    //再执行InstantiationAwareBeanPostProcessor的postProcessPropertyValues，最后再进行xml注入。
    //所谓populateBean就是根据该bean在xml的配置信息来填充bean，这些信息已经被解析为BeanDefinition。
    populateBean(beanName, mbd, instanceWrapper);
    //什么情况下bean==null？
    if (exposedObject != null) {
        //初始化bean
        //invokeAwareMethods（回调BeanNameAware、BeanClassLoaderAware、BeanFactoryAware的相关方法）、
        //applyBeanPostProcessorsBeforeInitialization（回调BeanPostProcessor的postProcessBeforeInitialization方法）、
        //invokeInitMethods（回调InitializingBean的afterPropertiesSet，以及init-method）、
        //applyBeanPostProcessorsAfterInitialization（回调BeanPostProcessor的postProcessAfterInitialization方法）
        exposedObject = initializeBean(beanName, exposedObject, mbd);//离我们很近
    }
    // Register bean as disposable.
    registerDisposableBeanIfNecessary(beanName, bean, mbd);
}

beanFactory就如同它的名字一样，只适合ID，测试AOP这里使用ClassPathXmlApplicationContext。

Feature	BeanFactory	ApplicationContext
Bean instantiation/wiring	Yes	Yes
Automatic BeanPostProcessor registration	No	Yes
Automatic BeanFactoryPostProcessor registration	No	Yes
Convenient MessageSource access (for i18n)	No	Yes
ApplicationEvent publication	No	Yes

populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
    exposedObject = initializeBean(beanName, exposedObject, mbd);
}

initializeBean会调用applyBeanPostProcessorsAfterInitialization

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
        throws BeansException {

    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        result = beanProcessor.postProcessAfterInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
}

我们这里只关注和AOP相关的BeanPostProcessor，即org.springframework.aop.framework.autoproxy.InfrastructureAdvisorAutoProxyCreator，InfrastructureAdvisorAutoProxyCreator的postProcessAfterInitialization调用的是AbstractAutoProxyCreator的postProcessAfterInitialization，postProcessAfterInitialization又会调用wrapIfNecessary。

//有删减
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    // 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;
    }
}

//AbstractAutoProxyCreator的createProxy，有删减
protected Object createProxy(
        Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {

    ProxyFactory proxyFactory = new ProxyFactory();
    //Copy configuration from the other config object.
    proxyFactory.copyFrom(this);

    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    for (Advisor advisor : advisors) {
        proxyFactory.addAdvisor(advisor);
    }
    //通过targetSource可以得到动态代理的target
    proxyFactory.setTargetSource(targetSource);
    //getProxy调用了createAopProxy().getProxy(classLoader)，proxyFactory.createAopProxy()创建的是JdkDynamicAopProxy
    return proxyFactory.getProxy(getProxyClassLoader());
}

public Object getProxy(ClassLoader classLoader) {
    Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
    //jdk的动态代理，因为getProxy的调用者为JdkDynamicAopProxy，所以这里的InvocationHandler就为JdkDynamicAopProxy，最终注册的也是代理bean，target被雪藏
    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

//JdkDynamicAopProxy的invoke方法，有删减
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    MethodInvocation invocation;
    Object oldProxy = null;
    boolean setProxyContext = false;

    TargetSource targetSource = this.advised.targetSource;
    Class<?> targetClass = null;
    Object target = null;

    Object retVal;

    // May be null. Get as late as possible to minimize the time we "own" the target,
    // in case it comes from a pool.
    target = targetSource.getTarget();
    if (target != null) {
        targetClass = target.getClass();
    }

    // Get the interception chain for this method.
    //组装拦截链
    List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

    // Check whether we have any advice. If we don't, we can fallback on direct
    // reflective invocation of the target, and avoid creating a MethodInvocation.
    if (chain.isEmpty()) {
        // We can skip creating a MethodInvocation: just invoke the target directly
        // Note that the final invoker must be an InvokerInterceptor so we know it does
        // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
        Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
        //通过反射直接调用target的方法
        retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
    }
    else {
        // We need to create a method invocation...
        invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
        // Proceed to the joinpoint through the interceptor chain.
        //走拦截链
        retVal = invocation.proceed();
    }
    //return this时，返回proxy，而不是target
    // Massage return value if necessary.
    Class<?> returnType = method.getReturnType();
    if (retVal != null && retVal == target &&
            returnType != Object.class && returnType.isInstance(proxy) &&
            !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
        // Special case: it returned "this" and the return type of the method
        // is type-compatible. Note that we can't help if the target sets
        // a reference to itself in another returned object.
        retVal = proxy;
    }

    return retVal;

}

以@Transaction为例来说，XmlBeanFactory在解析xml配置文件时会有专门的NamespaceHandler处理<tx:annotation-driven/>，该NamespaceHandler即TxNamespaceHandler。TxNamespaceHandler会spring注册一个advice，该advice大致会是一个around类型，起到了事务的作用（catch中rollback）。在初始化bean时会遍历bean的方法，检查是否有@Transaction，如果有就对该bean进行动态代理，动态代理中会存该bean的method到adviceChain的映射，执行@Transactional方法时就会从该映射中得到adviceChain。