Spring初始化过程到AOP

初始化过程

	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();
			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);
			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);
				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);
				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);
				// Initialize message source for this context.
				initMessageSource();
				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();
				// Initialize other special beans in specific context subclasses.
				onRefresh();
				// Check for listener beans and register them.
				registerListeners();
				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);
				// Last step: publish corresponding event.
				finishRefresh();
			}
            // ...
	}

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()
-> AbstractRefreshableApplicationContext#refreshBeanFactory() get a beanFactory(DefaultListableBeanFactory)
-> loadBeanDefinitions(beanFactory)
-> AbstractXmlApplicationContext#loadBeanDefinitions, XmlBeanDefinitionReader, loadBeanDefinition...(not yet instantiate)

registerBeanPostProcessors(beanFactory)
-> 注册BPP，其中就包含AOP的BPPAbstractAutoProxyCreator，注意BPP是not-lazy-init的

finishBeanFactoryInitialization(beanFactory); 实例化非lazy-init的bean
-> DefaultListableDeanFactory#preInstantiateSingletons() -> getBean(beanName)
-> AbstractBeanFactory#getBean(beanName) -> doGetBean(name, null, null, false) -> getSingleton -> createBean
-> AbstractAutowiredCapableBeanFactory#createBean -> doCreateBean -> populateBean -> initializeBean -> applyBeanPostProcessorsBeforeInitialization -> invokeInitMethods -> applyBeanPostProcessorsAfterInitialization -> getBeanPostProcessors() 然后对每个bean挨个调用bpp的postProcessAfterInitialization方法，对于AOP，在其中就会有判定是否需要包装、是否需要生成代理等操作，最后生成一个代理（这部分就是AOP的代码了）

AOP创建代理

Spring默认会加载AbstractAutoProxyCreator这个Bean（是一个BPP）
AbstractAutoProxyCreator#postProcessAfterInitialization -> wrapIfNecessary

	protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
		if (beanName != null && 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.
		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;
	}

getAdvicesAndAdvisorsForBean方法找到所有的拦截器，调用createProxy方法生成代理。
生成Advisor[]设置到ProxyFactory中，然后调用ProxyFactory#getProxy方法获取代理（JdkDynamicAopProxy和CglibAopProxy）。其中在生成Advisors是一个表复杂的过程，涉及匹配切点、包装生成通知（AspectJPointcutAdvisor.）

ProxyFactor extends ProxyCreatorSupport extends AdvisedSupport

	protected final synchronized AopProxy createAopProxy() {
		if (!this.active) {
			activate();
		}
		return getAopProxyFactory().createAopProxy(this);
	}

ProxyFactory以自身为参数，因为把Advisors设置进去了，生成代理时就可以拿到了。生成AopProxy（CglibAopProxy或者JdkDynamicAopProxy的构造参数需要AdvisedSupport）。
对于不需要包装（拦截）的方法，有一个拦截器是ExposeInvocationInterceptor。
在代理的invoke方法里，会先从AdvisedSupport中获取到拦截器链，最后包装成一个MethodInvocation（ReflectiveMethodInvocation）调用其proceed方法。
关键是proceed这个方法，会递归调用其中每一个interceptor，这里的this就是ReflectiveMethodInvocation，然后在interceptor的invoke方法里，有前置/后置/环绕等逻辑，或者没有逻辑（ExposeInvocationInterceptor是第一个拦截器），参数是MethodInvocation，然后再调用mi的proceed方法，回到ReflectiveMethodInvocation中继续处理，拦截器链调完之后就会反射调用返回。此处有点绕，需要多看几遍代码。

return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);

拦截器接口InvocationInterceptor，前置后置等逻辑都实现了该接口。
AspectJAfterAdvice
MethodBeforeAdviceInterceptor
AspectJAroundAdvice
等等