从@EnableAspectJAutoProxy分析Spring AOP原理

目录

AOP流程： 

@EnableAspectJAutoProxy

AnnotationAwareAspectJAutoProxyCreator：

AnnotationAwareAspectJAutoProxyCreator的注册流程：

AnnotationAwareAspectJAutoProxyCreator调用时机：

Spring创建AOP代理：

目标方法执行：

getInterceptorsAndDynamicInterceptionAdvice方法获取拦截器链：

直接执行目标方法：

封装拦截器和目标bean等信息并执行目标方法：

总结：

---

AOP流程： 

一、 创建和注册AnnotationAwareAspectJAutoProxyCreator

1. 传入配置类， 创建IOC容器
2. 注册配置类， 调用refresh() 刷新容器
3. registerBeanPostProcessors(beanFactory) ； 注册bean的后置处理器，拦截bean的创建
   1. 先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor
   2. 给容器中加其他的BeanPostProcessor
   3. 优先给容器注册实现了ProrityOrdered接口的BeanPostProcessor
   4. 再注册实现了ordered接口的BeanPostProcessor
   5. 注册没有实现优先级接口的BeanPostProcessor
   6. 创建internalAutoProxyCreator的BeanPostProcessor： AnnotationAwareAspectJAutoProxyCreator。 初始化bean时， 有如下几个操作需要注意：
      1. invokeAwareMethods() : 处理Aware接口的方法回调
      2. applyBeanPostProcessorsBeforeInitialization() ： 应用后置处理器的postProcessBeforeInitialization()
      3. invokeInitMethod() ; 执行自定义的初始化方法
      4. applyBeanPostProcessorsAfterInitialization() ;执行后置处理器的applyBeanPostProcessorsAfterInitialization() 方法
   7. 把BeanPostProcessor注册到BeanFactory中: beanFactory.addBeanPostProcessor(postProcessor)

二、完成BeanFactory的初始化工作： finishBeanFactoryInitialization(beanFactory)，创建剩下的单实例bean。 

1. 遍历获取容器中所有的bean， 依次创建对象： getBean（beanName）： getBean --> doGetBean（） ---> getSingleton()
2. createBean : 创建bean。 AnnotationAwareAspectJAutoProxyCreator 在所有bean创建前会有一个拦截， InstantiationAwareBeanPostProcessor， 会调用postProcessorBeforeInstantiation() 方法
   1. 先从缓存中获取当前bean， 如果能获取到， 则直接使用， 否则创建bean， 并将新创建的bean缓存起来
   2. createBean() : AnnotationAwareAspectJAutoProxyCreator 会在任何bean创建前先尝试返回bean实例。注意： BeanPostProcessor是在bean创建完成初始化前后调用的， InstantiationAwareBeanPostProcessor是在bean实例化之前先尝试用后置处理器返回对象。

三、AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】的作用：

这里要注意： AnnotationAwareAspectJAutoProxyCreator 是InstantiationAwareBeanPostProcessor 类型的后置处理器， 它调用的方法是： postProcessorsBeforeInstantiation（）、postProcessorsAfterInstantiation（）

1. 每个bean创建之前， 调用postProcessorsBeforeInstantiation（）。 这里关系到MathCalculator 和 LogAspect的创建
   1. 判断当前bean是否在adviseBeans中（这里保存了所有的增强bean）
   2. 判断当前bean是否是基础类型的Advice、Pointcut、 Advisor、 AopInfrastructureBean， 或者是否是切面@Aspect
   3. 是否需要跳过
      1. 获取候选的增强器（切面里的通知方法）， 每一个封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor ： 用于判断每个增强器是否是AspectJPointcutAdvisor类型 
2. 创建对象  postProcessAfterInitialization； return wrapIfNecessary(bean,  beanName , cacheKey ) ; 需要的话包装bean
   1. 获取当前bean的所有增强器（通知方法）： Object[] specificInterceptors
      1. 找到候选的所有增强器（哪些通知方法是需要切入当前bean方法的）
      2. 获取到能在bean中使用的增强器
      3. 给增强器排序
   2. 保存当前bean在adviseBeans中
   3. 如果当前bean需要增强， 创建当前bean的代理对象
      1. 获取所有增强器
      2. 保存到ProxyFactory中
      3. 创建代理对象： spring自动决定使用jdk动态代理还是cglib动态带
   4. 返回当前组件中使用cglib增强的代理对象到容器中
   5. 以后容器中获取到的bean实例， 就是这个组件的代理对象。 执行目标方法时，代理对象就会执行通知方法的流程
3. 目标方法的执行： 容器中保存了组件的代理对象， 该对象里面保存了增强器、目标对象等详细信息。
   1. 拦截目标方法的执行： CglibAopProxy.intercept();
   2. 根据 ProxyFactory对象获取将要执行的目标方法拦截器链 ： List<Object> chain
      1. List<Object> interceptorList 保存了所有拦截器， 共5个： 一个默认的ExposeInvocationInterceptor 和 4个增强器
      2. 遍历所有增强器， 将其转为Interceptor ； registry.getInterceptors（advisor）
      3. 将增强器转为List<MethodInterceptor> : 如果是MethodInterceptor， 直接加入到集合中 ； 如果不是， 使用AdvisorAdapter将增强器转为MethodInterceptor； 转换完成，返回MethodInterceptor数组
   3. 如果没有拦截器链， 直接执行目标方法
   4. 如果有拦截器链， 把需要执行的目标对象、目标方法、拦截器链等信息传入创建一个CglibMethodInvocation对象。 并调用 Object retVal = mi.proceed();
   5. 拦截器链的触发过程
      1. 如果没有拦截器执行目标方法，或者拦截器的索引和拦截器数组一样大（到了最后一个拦截器）， 执行目标方法
      2. 链式获取内一个拦截器， 拦截器执行invoke方法， 每一个拦截器等待下一个拦截器执行完成，返回以后再来执行； 拦截器链的机制， 保证通知方法与目标方法的执行顺讯。

基于注解的方式实现AOP需要在配置类中添加注解@EnableAspectJAutoProxy。我们就先从这个注解看一下Spring实现AOP的过程：

@EnableAspectJAutoProxy

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class) //引入AspectJAutoProxyRegister.class对象
public @interface EnableAspectJAutoProxy {

	//true——使用CGLIB基于类创建代理；false——使用java接口创建代理
	boolean proxyTargetClass() default false;

	//是否通过aop框架暴露该代理对象，aopContext能够访问.
	boolean exposeProxy() default false;
}

可以看出@EnableAspectJAutoProxy引入了AspectJAutoProxyRegister.class对象 ，AspectJAutoProxyRegister给容器中注册一个AnnotationAwareAspectJAutoProxyCreator：

AspectJAutoProxyRegistrar ：

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar { 

    @Override
    public void registerBeanDefinitions(
            AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);  //自定义注册bean，进入到AopConfigUtils类中
        AnnotationAttributes enableAspectJAutoProxy =
                AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class); //获取@EnableAspectJAutoProxy注解的属性信息
        if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
            AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
        }
        if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
            AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
        }
   }
}

AopConfigUtils：

	public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
		return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
	}

	public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
         //注册AnnotationAwareAspectJAutoProxyCreator
		return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source); 
	}

    //注册AnnotationAwareAspectJAutoProxyCreator
	private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) { //如果已经包含目标bean
			BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
			if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
				int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
				int requiredPriority = findPriorityForClass(cls);
				if (currentPriority < requiredPriority) {
					apcDefinition.setBeanClassName(cls.getName());
				}
			}
			return null;
		}
        //注册AnnotationAwareAspectJAutoProxyCreator，cls = AnnotationAwareAspectJAutoProxyCreator
		RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
		beanDefinition.setSource(source);
		beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
		beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        //将beanDefinition注册进registry中,注册名为 AUTO_PROXY_CREATOR_BEAN_NAME
        //AUTO_PROXY_CREATOR_BEAN_NAME = internalAutoProxyCreator
		registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
		return beanDefinition;
	}

AnnotationAwareAspectJAutoProxyCreator：

AnnotationAwareAspectJAutoProxyCreator 的层次结构：

这里主要关注后置处理器和自动装备BeanFactory相关的方法：SmartInstantiationAwareBeanPostProcessor(后置处理器), BeanFactoryAware(自动装配BeanFactory).

AnnotationAwareAspectJAutoProxyCreator的注册流程：

1、创建IOC容器，传入配置类：new AnnotationConfigApplicationContext(ConfigOfAOP.class)

	public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		this();//调用无参构造创建对象
		register(annotatedClasses); //注册配置类
		refresh();  //刷新容器，初始化容器创建需要的bean
	}

2、调用refresh()方法，刷新容器

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);

				// 注册后置处理器，用于拦截bean的创建
				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();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

3、refresh()方法调用了一个方法 registerBeanPostProcessors(beanFactory)，注册后置处理器，用于拦截bean的创建。也是在这个方法中完成了AnnotationAwareAspectJAutoProxyCreator的注册。该方法的主要逻辑在PostProcessorRegistrationDelegate类中的registerBeanPostProcessors方法中：

	public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
//获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

// 注册BeanPostProcessorChecker,当bean在BeanPostProcessor实例化过程中被创建时
//即当一个bean没有资格被所有BeanPostProcessor处理时，它记录一条信息消息。
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

// BeanPostProcessors 根据优先级进行分离，实现PriorityOrdered接口、实现Ordered接口、未实现优先级接口
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
		List<String> orderedPostProcessorNames = new ArrayList<String>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);//内部beanpostprocessor
				}
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		//先注册实现PriorityOrdered接口的 BeanPostProcessors 
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		//再注册实现Ordered接口的 BeanPostProcessors
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) { 
				internalPostProcessors.add(pp); 
			}
		}
		sortPostProcessors(orderedPostProcessors, beanFactory); //按照优先级排序
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);  //注册

		//这里注册所有常规的beanpostprocessor
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// 最后，重新注册所有内部beanpostprocessor。
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		// Re-register post-processor for detecting inner beans as ApplicationListeners,
		// moving it to the end of the processor chain (for picking up proxies etc).
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

registerBeanPostProcessors中注册BeanPostProcessor的顺序是：

1. 注册实现了PriorityOrdered接口的BeanPostProcessor 
2. 注册实现了Ordered接口的BeanPostProcessor 
3. 注册常规的BeanPostProcessor ，也就是没有实现优先级接口的BeanPostProcessor
4. 注册Spring内部BeanPostProcessor

4、registerBeanPostProcessors方法中注册了所有的BeanPostProcessor，所以AnnotationAwareAspectJAutoProxyCreator也在这里注册完成。而从AnnotationAwareAspectJAutoProxyCreator类的层次接口可以看出，该类实现了Ordered接口。所以它是在注册实现Ordered接口的BeanPostProcessor是完成注册：

BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class)；

这里调用的是AbstractBeanFactory的getBean方法，但是它实际的业务逻辑在AbstractAutowireCapableBeanFactory的doGetBean方法中实现：

	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
			throws BeanCreationException {

		//实例化bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args); //创建bean实例
		}
		final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
		Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
		mbd.resolvedTargetType = beanType;

		// 允许post-processors修改合并的bean定义。
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isDebugEnabled()) {
				logger.debug("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, new ObjectFactory<Object>() {
				@Override
				public Object getObject() throws BeansException {
					return getEarlyBeanReference(beanName, mbd, bean);
				}
			});
		}

		//初始化bean实例
		Object exposedObject = bean;
		try {
			populateBean(beanName, mbd, instanceWrapper);  //给bean的各种属性赋值
			if (exposedObject != null) {
                //初始化bean
				exposedObject = initializeBean(beanName, exposedObject, mbd);
			}
		}
		catch (Throwable ex) {
			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
				throw (BeanCreationException) ex;
			}
			else {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
			}
		}

		if (earlySingletonExposure) {
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
					for (String dependentBean : dependentBeans) {
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							actualDependentBeans.add(dependentBean);
						}
					}
					if (!actualDependentBeans.isEmpty()) {
						throw new BeanCurrentlyInCreationException(beanName,
								"Bean with name '" + beanName + "' has been injected into other beans [" +
								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
								"] in its raw version as part of a circular reference, but has eventually been " +
								"wrapped. This means that said other beans do not use the final version of the " +
								"bean. This is often the result of over-eager type matching - consider using " +
								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}

		// Register bean as disposable.
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

doGetBean中的逻辑看上去很复杂，但实际上他只做了三件事：

1. 创建bean ：createBeanInstance(beanName, mbd, args)
2. 给bean中的属性赋值：populateBean(beanName, mbd, instanceWrapper)
3. 初始化bean：initializeBean(beanName, exposedObject, mbd)

初始化bean时，initializeBean方法会调用BeanPostProcessor和BeanFactory以及Aware接口的相关方法。这也是BeanPostProcessor如何发挥初始化bean的原理。

5、AbstractAutowireCapableBeanFactory的initializeBean方法：

	protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged(new PrivilegedAction<Object>() {
				@Override
				public Object run() {
					invokeAwareMethods(beanName, bean);
					return null;
				}
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);   //处理Aware接口的方法回调
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
            // 应用后置处理器的postProcessBeforeInitialization方法
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
			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()) {
            // 执行后置处理器的postProcessAfterInitialization方法
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}
		return wrappedBean;
	}

  可以看出initializeBean方法主要做了四件事：

1. 处理Aware接口的方法回调：invokeAwareMethods(beanName, bean);  
2.  应用后置处理器的postProcessBeforeInitialization方法：   wrappedBean=applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
3. 执行自定义的初始化方法：invokeInitMethods(beanName, wrappedBean, mbd);  
4.  执行后置处理器的postProcessAfterInitialization方法：   wrappedBean=applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

initializeBean方法执行成功，AnnotationAwareAspectJAutoProxyCreator注册和初始化成功。

6、这时再回到第3步中，BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class)执行成功，目标bean成功注册后，将注册完成的beanPostProcessor，排序后注册到BeanFactory中

        sortPostProcessors(orderedPostProcessors, beanFactory); //按照优先级排序
        registerBeanPostProcessors(beanFactory, orderedPostProcessors);  //注册

registerBeanPostProcessors：

	private static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {

		for (BeanPostProcessor postProcessor : postProcessors) {
			beanFactory.addBeanPostProcessor(postProcessor);
		}
	}

AnnotationAwareAspectJAutoProxyCreator调用时机：

上一节第2步中refresh()方法中，调用registerBeanPostProcessors(beanFactory)方法，注册完BeanPostProcessor后，还调用了方法finishBeanFactoryInitialization(beanFactory) ，完成BeanFactory初始化工作，并创建剩下的单实例bean。finishBeanFactoryInitialization(beanFactory)的执行过程：

	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// 初始化此上下文的转换服务。
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}
		//若之前没有任何bean后处理器注册，则注册一个默认的嵌入式值解析器:主要用于在注释属性值中解析
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
				@Override
				public String resolveStringValue(String strVal) {
					return getEnvironment().resolvePlaceholders(strVal);
				}
			});
		}
		//尽早初始化LoadTimeWeaverAware bean，以便尽早注册它们的转换器。
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}
		// 停止使用临时类加载器进行类型匹配。
		beanFactory.setTempClassLoader(null);

		// 允许缓存所有bean定义元数据，不期望有进一步的更改。
		beanFactory.freezeConfiguration();

		// 实例化所有剩余的(非懒加载初始化)单例bean。
		beanFactory.preInstantiateSingletons();
	}

1、调用 beanFactory.preInstantiateSingletons()：遍历获取容器中所有的Bean，实例化所有剩余的(非懒加载初始化)单例bean。 该方法是DefaultListableBeanFactory类中的方法：

	public void preInstantiateSingletons() throws BeansException {
		if (this.logger.isDebugEnabled()) {
			this.logger.debug("Pre-instantiating singletons in " + this);
		}

		// 迭代一个副本以允许init方法，而init方法反过来注册新的bean定义。 
		List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);

		// 触发所有非惰性单例bean的初始
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { //非抽象、单例、非懒加载
				if (isFactoryBean(beanName)) { //如果是FactoryBean类型
					final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
							@Override
							public Boolean run() {
								return ((SmartFactoryBean<?>) factory).isEagerInit();
							}
						}, getAccessControlContext());
					}else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean<?>) factory).isEagerInit());
					}
					if (isEagerInit) {
						getBean(beanName);
					}
				}else {//不是FactoryBean类型
					getBean(beanName);
				}
			}
		}
		// 为所有适用的bean触发初始化后回调…
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged(new PrivilegedAction<Object>() {
						@Override
						public Object run() {
							smartSingleton.afterSingletonsInstantiated();
							return null;
						}
					}, getAccessControlContext());
				}else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

2、preInstantiateSingletons调用getBean方法，获取bean实例，执行过程getBean->doGetBean()->getSingleton()->createBean()

先从缓存中获取当前bean，如果能获取到，直接使用，否则创建bean。只要bean被创建就会被缓存起来。这里的调用了流程与上一节的第4步中相同。这里要说一下createBean中的  resolveBeforeInstantiation(beanName, mbdToUse)方法： 让beanpostprocessor有机会返回代理而不是目标bean实例

		try {
			// 让beanpostprocessor有机会返回代理而不是目标bean实例。
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			if (bean != null) {
				return bean;
			}
		}

resolveBeforeInstantiation：

	protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
		Object bean = null;
		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
			// 确保此时bean类已经被解析。
			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				Class<?> targetType = determineTargetType(beanName, mbd);
				if (targetType != null) {
//拿到所有后置处理器，如果是InstantiationAwareBeanPostProcessor，就执行postProcessBeforeInstantiation
					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
					if (bean != null) {
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
	}

主要看一下resolveBeforeInstantiation方法中的applyBeanPostProcessorsBeforeInstantiation 和 applyBeanPostProcessorsAfterInitialization方法，注意两个方法的后缀不同Instantiation(实例化)  和 Initialization(初始化)

applyBeanPostProcessorsBeforeInstantiation ：

	protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) { //遍历所有BeanPostProcessor
			if (bp instanceof InstantiationAwareBeanPostProcessor) { //如果是InstantiationAwareBeanPostProcessor类型
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                //执行postProcessBeforeInstantiation方法
				Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
				if (result != null) {
					return result;
				}
			}
		}
		return null;
	}

postProcessBeforeInstantiation方法是InstantiationAwareBeanPostProcessor接口中定义的方法，applyBeanPostProcessorsAfterInitialization方法会调用BeanPostProcessor接口中postProcessAfterInitialization方法。  而且InstantiationAwareBeanPostProcessor是在创建Bean实例之前先尝试用后置处理器返回对象的；BeanPostProcessor是在Bean对象创建完成初始化前后调用的。从AnnotationAwareAspectJAutoProxyCreator类的层次结构可以看出，该类实现了InstantiationAwareBeanPostProcessor接口，它会在所有bean实例创建前进行拦截，这也是AOP代理的关键所在。

Spring创建AOP代理：

AnnotationAwareAspectJAutoProxyCreator实现了InstantiationAwareBeanPostProcessor接口，所以每次创建bean实例前都会调用AnnotationAwareAspectJAutoProxyCreator类的postProcessBeforeInstantiation()方法。下面就看一下该方法都做了什么。

1、postProcessBeforeInstantiation()是在AbstractAutoProxyCreator类中实现的：

	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		Object cacheKey = getCacheKey(beanClass, beanName);
        
		if (beanName == null || !this.targetSourcedBeans.contains(beanName)) {
            //判断当前bean是否在advisedBeans中（advisedBeans保存了所有需要增强的bean）
			if (this.advisedBeans.containsKey(cacheKey)) {
				return null;
			}
            //判断当前bean是否基础类型Advice、Pointcut、Advisor、AopInfrastructureBean，或是否切面（@Aspect）
            //是否需要跳过
			if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
				this.advisedBeans.put(cacheKey, Boolean.FALSE);
				return null;
			}
		}

		//如果我们有一个自定义TargetSource，请在这里创建代理。
		if (beanName != null) {
			TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
			if (targetSource != null) {
				this.targetSourcedBeans.add(beanName);
				Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
				Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
				this.proxyTypes.put(cacheKey, proxy.getClass());
				return proxy;
			}
		}

		return null;
	}

postProcessBeforeInstantiation方法主要对当前类进行一些判断：

1. 判断当前bean是否在advisedBeans（增强bean的集合）中----增强bean是指切入点表达式包含的类。
2. 判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean，或者是否是切面（@Aspect）
3. 是否需要跳过----获取候选的增强器（切面里面的通知方法）【List<Advisor> candidateAdvisors】，如果增强器是 AspectJPointcutAdvisor 类型的，则返回true（封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor类型）

判断完成后会创建切入点对象，也就是创建增强bean，bean创建完成后会调用applyBeanPostProcessorsAfterInitialization方法，继而调用后置处理器的postProcessAfterInitialization方法：

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

		Object result = existingBean;
		for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            //调用后置处理器的postProcessAfterInitialization方法
			result = beanProcessor.postProcessAfterInitialization(result, beanName);
			if (result == null) {
				return result;
			}
		}
		return result;
	}

postProcessAfterInitialization：

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		if (bean != null) {
			Object cacheKey = getCacheKey(bean.getClass(), beanName);
			if (!this.earlyProxyReferences.contains(cacheKey)) {
				return wrapIfNecessary(bean, beanName, cacheKey);//包装如果需要的情况下
			}
		}
		return bean;
	}

postProcessAfterInitialization主要有调用了wrapIfNecessary(bean, beanName, cacheKey)方法：包装bean，这里会获取bean的增强器，并且生成动态代理。下面看一下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;
		}

	    // 如果我们有建议，创建代理。
            //获取当前bean的所有增强器
		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
		if (specificInterceptors != DO_NOT_PROXY) {
			this.advisedBeans.put(cacheKey, Boolean.TRUE); //将当前bean放入advisedBeans中
                //创建增强bean的代理对象
			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;
	}

wrapIfNecessary方法中主要是获取当前bean的增强器调用getAdvicesAndAdvisorsForBean方法和创建增强后的bean的代理对象调用createProxy方法，下面看看这两个方法：

getAdvicesAndAdvisorsForBean方法：

	@Override
	protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
		List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName); //获取bean可用的增强器
		if (advisors.isEmpty()) {
			return DO_NOT_PROXY;
		}
		return advisors.toArray();
	}

getAdvicesAndAdvisorsForBean方法调用findEligibleAdvisors方法获取bean的增强器：

	protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
		List<Advisor> candidateAdvisors = findCandidateAdvisors();//获取所有可用的增强器
                //获取当前bean可用的增强器
		List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
		extendAdvisors(eligibleAdvisors);
		if (!eligibleAdvisors.isEmpty()) {
			eligibleAdvisors = sortAdvisors(eligibleAdvisors); //对增强器进行排序
		}
		return eligibleAdvisors;
	}

createProxy方法：

	protected Object createProxy(
			Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {

		if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
			AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
		}

		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.copyFrom(this);

		if (!proxyFactory.isProxyTargetClass()) {
			if (shouldProxyTargetClass(beanClass, beanName)) {
				proxyFactory.setProxyTargetClass(true);
			}
			else {
				evaluateProxyInterfaces(beanClass, proxyFactory);
			}
		}
            //获取当前bean的所有增强器
		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()); //创建代理对象
	}

Spring是利用ProxyFactory代理工厂创建代理对象：

ProxyFactory创建代理对象：

	public Object getProxy(ClassLoader classLoader) {
		return createAopProxy().getProxy(classLoader);
	}

createAopProxy：

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

getAopProxyFactory：

	public AopProxyFactory getAopProxyFactory() {
		return this.aopProxyFactory;
	}

createAopProxy：

	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() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config); //创建JDK动态代理（基于接口）
			}
			return new ObjenesisCglibAopProxy(config); //创建CGLIB的动态代理（基于类）
		}
		else {
			return new JdkDynamicAopProxy(config);
		}
	}

到这里AOP创建代理完成。容器可以创建两种动态代理对象：JDK动态代理对象和CGLIB动态代理对象，并最终返回创建完成的代理对象。以后容器中获取到的bean就是这个组件的动态代理bean，执行目标方法的时候，代理对象就会执行通知方法的流程；

下面来看一下代理对象如何执行增强方法和目标方法。

目标方法执行：

容器中创建了目标bean的代理对象，以后从Spring中获取的bean实例都是该代理对象。对象中包含的信息如下：MathCalculator是自己创建的类，也是一个切入点类

可以看出MathCalculator的代理对象中保存了增强器、目标对象等详细信息。

mathCalculator.div(1, 1)  目标方法执行时，会先进入CglibAopProxy类的intercept方法：

		public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
			Object oldProxy = null;
			boolean setProxyContext = false;
			Class<?> targetClass = null;
			Object target = null;
			try {
				if (this.advised.exposeProxy) { 
					oldProxy = AopContext.setCurrentProxy(proxy);
					setProxyContext = true;
				} 
				target = getTarget(); //目标对象，也就是切入点对象
				if (target != null) 
					targetClass = target.getClass();				
                                //根据targetClass(ProxyFactory)获取目标方法method的拦截器链
				List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
				Object retVal;
				// 如果拦截器链为空
				if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
					// 直接执行目标方法
					Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
					retVal = methodProxy.invoke(target, argsToUse);
				} else { //连接器链不为空
					//将目标方法、拦截器链、等信息封装到CglibMethodInvocation对象中，并执行
					retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
				}
				retVal = processReturnType(proxy, target, method, retVal);
				return retVal;
			}finally {
				if (target != null) 
					releaseTarget(target);
				if (setProxyContext) 
					AopContext.setCurrentProxy(oldProxy);// 恢复旧的代理。
			}
		}

intercept方法主要执行逻辑：

1. 获取拦截器链 List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
2. 如果拦截器链为空，直接执行目标方法
3. 如果拦截器链不为空，把需要执行的目标对象，目标方法，拦截器链等信息封装到一个 CglibMethodInvocation 对象，并调用该CglibMethodInvocation对象的proceed()方法，执行增强器方法和目标方法。

下面分别来看一下这三步的执行逻辑：

getInterceptorsAndDynamicInterceptionAdvice方法获取拦截器链：

	public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class<?> targetClass) {
		MethodCacheKey cacheKey = new MethodCacheKey(method); //缓存目标方法
		List<Object> cached = this.methodCache.get(cacheKey); //获取缓存中目标方法的拦截器链
		if (cached == null) {//缓存中没有获取到拦截器链
			cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
					this, method, targetClass); //获取目标方法的拦截器链
			this.methodCache.put(cacheKey, cached);
		}
		return cached;
	}

DefaultAdvisorChainFactory类中的getInterceptorsAndDynamicInterceptionAdvice()方法：

	public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
			Advised config, Method method, Class<?> targetClass) {

		// 创建一个空集合，用于存放增强器，长度为5
		List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);
		Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
		boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);
		AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();

		for (Advisor advisor : config.getAdvisors()) { //遍历所有增强器
			if (advisor instanceof PointcutAdvisor) { //如果是切入点增强器
				PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
				if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
					MethodInterceptor[] interceptors = registry.getInterceptors(advisor);       //将增强器装换成MethodInterceptor
					MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
					if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {
						if (mm.isRuntime()) { 
							for (MethodInterceptor interceptor : interceptors) {
								interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
							}
						}
						else {
							interceptorList.addAll(Arrays.asList(interceptors));//添加到连接器链中
						}
					}
				}
			}
			else if (advisor instanceof IntroductionAdvisor) {
				IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
				if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
					Interceptor[] interceptors = registry.getInterceptors(advisor);//将增强器装换成MethodInterceptor
					interceptorList.addAll(Arrays.asList(interceptors));
				}
			}
			else {
				Interceptor[] interceptors = registry.getInterceptors(advisor);//将增强器装换成MethodInterceptor
				interceptorList.addAll(Arrays.asList(interceptors));
			}
		}

		return interceptorList;
	}

getInterceptorsAndDynamicInterceptionAdvice方法最终返回 List<Object>  interceptorList，interceptorList中封装了所有的拦截器链。向集合中添加拦截器之前都会有一步操作：Interceptor[] interceptors = registry.getInterceptors(advisor)，将拦截器转换成Interceptor类型。

registry.getInterceptors(advisor)：

	public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
		List<MethodInterceptor> interceptors = new ArrayList<MethodInterceptor>(3);
		Advice advice = advisor.getAdvice();
		if (advice instanceof MethodInterceptor) { //如果advice增强器是MethodIntercept类型
			interceptors.add((MethodInterceptor) advice);
		}
		for (AdvisorAdapter adapter : this.adapters) { //遍历适配器
			if (adapter.supportsAdvice(advice)) { //适配器类型与增强器类型匹配
				interceptors.add(adapter.getInterceptor(advisor)); //将增强器装换成MethodIntercept类型
			}
		}
		if (interceptors.isEmpty()) {
			throw new UnknownAdviceTypeException(advisor.getAdvice());
		}
		return interceptors.toArray(new MethodInterceptor[interceptors.size()]);
	}

看一下this.adapters里面的值：

MethodBeforeAdviceAdapter、AfterReturningAdviceAdapter、ThrowsAdviceAdapter分别对象前置通知、后置通知、异常通知。

拦截器连创建完成后返回，然后开始判断拦截器链是否为空：为空则直接执行目标方法，不为空值封装拦截器和目标bean等信息。

直接执行目标方法：

if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
    // 直接执行目标方法
	Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
	retVal = methodProxy.invoke(target, argsToUse);
}

直接执行目标方法的逻辑比较简单，利用反射执行目标方法。

封装拦截器和目标bean等信息并执行目标方法：

retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();

这个过程分为两步：

1. 将proxy(代理对象)、target(目标bean)、method(目标方法)、args(目标方法的参数)、targetClass(目标bean的类型)、chain(拦截器链)、methodProxy(用于调用原始方法）封装进CglibMethodInvocation对象中。
2. 执行proceed方法，执行增强器方法和目标方法

proceed()方法：

	public Object proceed() throws Throwable {
		//this.currentInterceptorIndex初始值为-1，用于记录拦截器的索引
		if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
			return invokeJoinpoint(); //执行目标方法
		}
                  //从拦截器链中获取拦截器
		Object interceptorOrInterceptionAdvice =
				this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
                //如果获取的拦截器是动态匹配方法拦截器类型
		if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
			InterceptorAndDynamicMethodMatcher dm =
					(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
			if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
				return dm.interceptor.invoke(this);
			}else { // 动态匹配失败。跳过这个拦截器并调用链中的下一个。
				return proceed(); //递归调用
			}
		}else {
			// 调用拦截器:切入点将在构造这个对象之前被静态地计算。
			return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
		}
	}

下面是拦截器链中的拦截器数据：

调用的第一个invoke(this)方法是ExposeInvocationInterceptor的invoke(this)方法：

	public Object invoke(MethodInvocation mi) throws Throwable {
		MethodInvocation oldInvocation = invocation.get();
		invocation.set(mi);
		try {
			return mi.proceed(); //继续调用proceed()方法
		}finally {
			invocation.set(oldInvocation);
		}
	}

从上面的代码中可以看出proceed方法的执行逻辑：

1. 判断拦截器下标和拦截器链中拦截器数量的关系，如果已经获取一个拦截器，执行目标方法并返回。
2. 如果拦截器链中还有元素没有获取，则获取下一个拦截器
3. 如果获取的拦截器不是动态匹配方法的拦截器类型，则调用该拦截器的invoke方法。

而拦截器的invoke方法中的参数this是指当前CglibMethodInvocation对象，所以执行拦截器时又回到proceed()方法。拦截器链中有五个拦截器，依次看一下这五个拦截器中的invoke方法：

ExposeInvocationInterceptor的invoke方法：

	public Object invoke(MethodInvocation mi) throws Throwable {
		MethodInvocation oldInvocation = invocation.get();
		invocation.set(mi);
		try {
			return mi.proceed(); //继续调用proceed()方法
		}finally {
			invocation.set(oldInvocation);
		}
	}

AspectJAfterThrowingAdvice的invoke方法：

	public Object invoke(MethodInvocation mi) throws Throwable {
		try {
			return mi.proceed();
		}catch (Throwable ex) {
			if (shouldInvokeOnThrowing(ex)) {
				invokeAdviceMethod(getJoinPointMatch(), null, ex);
			}
			throw ex;
		}
	}

AfterReturningAdviceInterceptor的invoke方法：

	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		Object retVal = mi.proceed();
		this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
		return retVal;
	}

AspectJAfterAdvice的invoke方法：

	public Object invoke(MethodInvocation mi) throws Throwable {
		try {
			return mi.proceed();
		}finally {
			invokeAdviceMethod(getJoinPointMatch(), null, null);
		}
	}

MethodBeforeAdviceInterceptor的invoke方法有所不同：

	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() );//执行拦截器方法
		return mi.proceed(); //调用proceed方法
	}

从上面的代码中可以看出，这五个拦截器的invoke方法执行流程：

                             

总结：

 1）、  @EnableAspectJAutoProxy 开启AOP功能
 2）、  @EnableAspectJAutoProxy 会给容器中注册一个组件 AnnotationAwareAspectJAutoProxyCreator
 3）、  AnnotationAwareAspectJAutoProxyCreator是一个InstantiationAwareBeanPostProcessor类型后置处理器；
 4）、  容器的创建流程：
         1）、registerBeanPostProcessors（）注册后置处理器；创建AnnotationAwareAspectJAutoProxyCreator对象
         2）、finishBeanFactoryInitialization（）初始化剩下的单实例bean
                   1）、创建业务逻辑组件和切面组件
                   2）、AnnotationAwareAspectJAutoProxyCreator拦截组件的创建过程
                   3）、组件创建完之后，判断组件是否需要增强
                            是：切面的通知方法，包装成增强器（Advisor）;给业务逻辑组件创建一个代理对象（cglib）；
5）、执行目标方法：
          1）、代理对象执行目标方法
          2）、CglibAopProxy.intercept()；
                      1）、得到目标方法的拦截器链（增强器包装成拦截器MethodInterceptor）
                      2）、利用拦截器的链式机制，依次进入每一个拦截器进行执行；
                     3）、效果：
                              正常执行：前置通知-》目标方法-》后置通知-》返回通知
                              出现异常：前置通知-》目标方法-》后置通知-》异常通知