【spring 注解驱动开发】Spring AOP原理

尚学堂spring 注解驱动开发学习笔记之 - AOP原理

AOP原理：

　　1、AOP原理-AOP功能实现
　　2、AOP原理-@EnableAspectJAutoProxy
　　3、AOP原理-AnnotationAwareAspectJAutoProxyCreator分析
　　4、AOP原理-注册AnnotationAwareAspectJAutoProxyCreator
　　5、AOP原理-AnnotationAwareAspectJAutoProxyCreator执行时机
　　6、AOP原理-创建AOP代理
　　7、AOP原理-获取拦截器链-MethodInterceptor
　　8、AOP原理-链式调用通知方法
　　9、AOP-原理总结

1、AOP原理-AOP功能实现

1.1 aop动态代码实现步骤如下：

/**

 * AOP：【动态代理】

 * 		指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式；

 *

 * 1、导入aop模块；Spring AOP：(spring-aspects)

 * 2、定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常，xxx）

 * 3、定义一个日志切面类（LogAspects）：切面类里面的方法需要动态感知MathCalculator.div运行到哪里然后执行；

 * 		通知方法：

 * 			前置通知(@Before)：logStart：在目标方法(div)运行之前运行

 * 			后置通知(@After)：logEnd：在目标方法(div)运行结束之后运行（无论方法正常结束还是异常结束）

 * 			返回通知(@AfterReturning)：logReturn：在目标方法(div)正常返回之后运行

 * 			异常通知(@AfterThrowing)：logException：在目标方法(div)出现异常以后运行

 * 			环绕通知(@Around)：动态代理，手动推进目标方法运行（joinPoint.procced()）

 * 4、给切面类的目标方法标注何时何地运行（通知注解）；

 * 5、将切面类和业务逻辑类（目标方法所在类）都加入到容器中;

 * 6、必须告诉Spring哪个类是切面类(给切面类上加一个注解：@Aspect)

 * [7]、给配置类中加 @EnableAspectJAutoProxy 【开启基于注解的aop模式】

 * 		在Spring中很多的 @EnableXXX;

 *

 * 三步：

 * 	1）、将业务逻辑组件和切面类都加入到容器中；并告诉Spring哪个是切面类（@Aspect）

 * 	2）、在切面类上的每一个通知方法上标注通知注解，告诉Spring何时何地运行（切入点表达式）

 *      3）、开启基于注解的aop模式；@EnableAspectJAutoProxy

1.2 代码实现

业务逻辑类：

package com.atguigu.aop;

public class MathCalculator {

	public int div(int i,int j){

		System.out.println("MathCalculator...div...");

		return i/j;

	}

}

切面类：

package com.atguigu.aop;

import java.util.Arrays;

import org.aspectj.lang.JoinPoint;

import org.aspectj.lang.annotation.After;

import org.aspectj.lang.annotation.AfterReturning;

import org.aspectj.lang.annotation.AfterThrowing;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

import org.aspectj.lang.annotation.Pointcut;

/**

 * 切面类

 * @author lfy

 *

 * @Aspect： 告诉Spring当前类是一个切面类

 *

 */

@Aspect

public class LogAspects {

	//抽取公共的切入点表达式

	//1、本类引用

	//2、其他的切面引用

	@Pointcut("execution(public int com.atguigu.aop.MathCalculator.*(..))")

	public void pointCut(){};

	//@Before在目标方法之前切入；切入点表达式（指定在哪个方法切入）

	@Before("pointCut()")

	public void logStart(JoinPoint joinPoint){

		Object[] args = joinPoint.getArgs();

		System.out.println(""+joinPoint.getSignature().getName()+"运行。。。@Before:参数列表是：{"+Arrays.asList(args)+"}");

	}

	@After("com.atguigu.aop.LogAspects.pointCut()")

	public void logEnd(JoinPoint joinPoint){

		System.out.println(""+joinPoint.getSignature().getName()+"结束。。。@After");

	}

	//JoinPoint一定要出现在参数表的第一位

	@AfterReturning(value="pointCut()",returning="result")

	public void logReturn(JoinPoint joinPoint,Object result){

		System.out.println(""+joinPoint.getSignature().getName()+"正常返回。。。@AfterReturning:运行结果：{"+result+"}");

	}

	@AfterThrowing(value="pointCut()",throwing="exception")

	public void logException(JoinPoint joinPoint,Exception exception){

		System.out.println(""+joinPoint.getSignature().getName()+"异常。。。异常信息：{"+exception+"}");

	}

}

配置文件：

使用@EnableAspectJAutoProxy注解开启aop功能。

@EnableAspectJAutoProxy

@Configuration

public class MainConfigOfAOP {

	//业务逻辑类加入容器中

	@Bean

	public MathCalculator calculator(){

		return new MathCalculator();

	}

	//切面类加入到容器中

	@Bean

	public LogAspects logAspects(){

		return new LogAspects();

	}

}

单元测度类：

package com.atguigu.test;

import org.junit.Test;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.atguigu.aop.MathCalculator;

import com.atguigu.bean.Boss;

import com.atguigu.bean.Car;

import com.atguigu.bean.Color;

import com.atguigu.bean.Red;

import com.atguigu.config.MainConfigOfAOP;

import com.atguigu.config.MainConifgOfAutowired;

import com.atguigu.dao.BookDao;

import com.atguigu.service.BookService;

public class IOCTest_AOP {

	@Test

	public void test01(){

		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);

		//1、不要自己创建对象

//		MathCalculator mathCalculator = new MathCalculator();

//		mathCalculator.div(1, 1);

		MathCalculator mathCalculator = applicationContext.getBean(MathCalculator.class);

		mathCalculator.div(1, 0);

		applicationContext.close();

	}

}

2、AOP原理-@EnableAspectJAutoProxy

说明：

　　@EnableAspectJAutoProxy 注解的最终作用是开启aop功能。直接作用的利用@Import注解导入AspectJAutoProxyRegistrar类。而AspectJAutoProxyRegistrar类实现了ImportBeanDefinitionRegistrar接口，ImportBeanDefinitionRegistrar接口的作用是通过使用@Import注解引入该接口的实现类获取注册bean的能力。最终注入了AnnotationAwareAspectJAutoProxyCreator类。

 * 1、@EnableAspectJAutoProxy是什么？

 * 		@Import(AspectJAutoProxyRegistrar.class)：给容器中导入AspectJAutoProxyRegistrar

 * 			利用AspectJAutoProxyRegistrar自定义给容器中注册bean；BeanDefinetion

 * 			internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator[注解装配切面自动代理创建器]

 *

 * 		给容器中注册一个AnnotationAwareAspectJAutoProxyCreator；

执行流程如下：

EnableAspectJAutoProxy类 --> @Import(AspectJAutoProxyRegistrar.class)
AspectJAutoProxyRegistrar类 --> registerBeanDefinitions()方法 --> AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);方法；
AopConfigUtils类 --> registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) --> registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
AopConfigUtils类 --> registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);

EnableAspectJAutoProxy注解源码如下：

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Import(AspectJAutoProxyRegistrar.class)

public @interface EnableAspectJAutoProxy {

	/**

	 * Indicate whether subclass-based (CGLIB) proxies are to be created as opposed

	 * to standard Java interface-based proxies. The default is {@code false}.

	 */

	boolean proxyTargetClass() default false;

	/**

	 * Indicate that the proxy should be exposed by the AOP framework as a {@code ThreadLocal}

	 * for retrieval via the {@link org.springframework.aop.framework.AopContext} class.

	 * Off by default, i.e. no guarantees that {@code AopContext} access will work.

	 * @since 4.3.1

	 */

	boolean exposeProxy() default false;

}

AspectJAutoProxyRegistrar类注册bean的方法

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

	/**

	 * Register, escalate, and configure the AspectJ auto proxy creator based on the value

	 * of the @{@link EnableAspectJAutoProxy#proxyTargetClass()} attribute on the importing

	 * {@code @Configuration} class.

	 */

	@Override

	public void registerBeanDefinitions(

			AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

		AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

		AnnotationAttributes enableAspectJAutoProxy =

				AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);

		if (enableAspectJAutoProxy != null) {

			if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {

				AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);

			}

			if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {

				AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);

			}

		}

	}

}

AopConfigUtils类的registerOrEscalateApcAsRequired()方法

@Nullable

	private static BeanDefinition registerOrEscalateApcAsRequired(

			Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {

		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");

		if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {

			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;

		}

		RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);

		beanDefinition.setSource(source);

		beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);

		beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

		registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);

		return beanDefinition;

	}

3、AOP原理-AnnotationAwareAspectJAutoProxyCreator分析

AnnotationAwareAspectJAutoProxyCreator类的继承树，最主要关注后置处理器（在bean初始化完成前后做事情）、自动装配BeanFactoryimplements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware

* 2、 AnnotationAwareAspectJAutoProxyCreator：

 * 		AnnotationAwareAspectJAutoProxyCreator

 * 			->AspectJAwareAdvisorAutoProxyCreator

 * 				->AbstractAdvisorAutoProxyCreator

 * 					->AbstractAutoProxyCreator

 * 							implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware

 * 						关注后置处理器（在bean初始化完成前后做事情）、自动装配BeanFactory

经分析，需要关注的方法如下：

 * AbstractAutoProxyCreator.setBeanFactory()

 * AbstractAutoProxyCreator.有后置处理器的逻辑；

 * AbstractAdvisorAutoProxyCreator.setBeanFactory()-> initBeanFactory()

 * AnnotationAwareAspectJAutoProxyCreator.initBeanFactory()

4、AOP原理-注册AnnotationAwareAspectJAutoProxyCreator

测试类：

public class IOCTest_AOP {

	@Test

	public void test01(){

		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);

		//1、不要自己创建对象

//		MathCalculator mathCalculator = new MathCalculator();

//		mathCalculator.div(1, 1);

		MathCalculator mathCalculator = applicationContext.getBean(MathCalculator.class);

		mathCalculator.div(1, 0);

		applicationContext.close();

	}

}

以下分析的代码执行流程是基于以上测试类单元测试方法test01()的执行过程

 * 代码执行流程：

 * 		1）、传入配置类，创建ioc容器；

 * 			执行： new AnnotationConfigApplicationContext(MainConfigOfAOP.class);

 * 		2）、注册配置类，调用refresh()刷新容器；

 * 			执行：AnnotationConfigApplicationContext(Class<?>... componentClasses)-->refresh()

 * 		3）、registerBeanPostProcessors(beanFactory);注册bean的后置处理器来方便拦截bean的创建；

 * 				执行：AbstractApplicationContext类

 * 						-->refresh()

 * 						-->registerBeanPostProcessors(beanFactory)

 * 						-->PostProcessorRegistrationDelegate类的registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext)

 * 			1）、先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor

 * 			2）、给容器中加别的BeanPostProcessor

 * 			3）、优先注册实现了PriorityOrdered接口的BeanPostProcessor；

 * 			4）、再给容器中注册实现了Ordered接口的BeanPostProcessor；

 * 			5）、注册没实现优先级接口的BeanPostProcessor；

 * 			6）、注册BeanPostProcessor，实际上就是创建BeanPostProcessor对象，保存在容器中；

 * 				创建internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】

 * 					执行：PostProcessorRegistrationDelegate类的registerBeanPostProcessors()方法中的以下这一行代码会创建BeanPostProcessor对象

 * 						BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);

 * 				1）、创建Bean的实例

 * 				2）、populateBean；给bean的各种属性赋值

 * 				3）、initializeBean：初始化bean；

 * 						1）、invokeAwareMethods()：处理Aware接口的方法回调

 * 						2）、applyBeanPostProcessorsBeforeInitialization()：应用后置处理器的postProcessBeforeInitialization（）

 * 						3）、invokeInitMethods()；执行自定义的初始化方法

 * 						4）、applyBeanPostProcessorsAfterInitialization()；执行后置处理器的postProcessAfterInitialization（）；

 * 				4）、BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功；--> aspectJAdvisorsBuilder

 * 			7）、把BeanPostProcessor注册到BeanFactory中；

 * 				beanFactory.addBeanPostProcessor(postProcessor);

 * =======以上是创建和注册AnnotationAwareAspectJAutoProxyCreator的过程========

5、AOP原理-AnnotationAwareAspectJAutoProxyCreator执行时机

 *

 * 			AnnotationAwareAspectJAutoProxyCreator => InstantiationAwareBeanPostProcessor

 * 		4）、finishBeanFactoryInitialization(beanFactory);完成BeanFactory初始化工作；创建剩下的单实例bean

 * 				执行：AbstractApplicationContext类

 * 						--> refresh();

 * 						--> finishBeanFactoryInitialization(beanFactory);

 * 						--> beanFactory.preInstantiateSingletons();

 * 						--> getBean(beanName);

 * 						--> doGetBean(name, null, null, false);

 * 						--> getSingleton(beanName, ());

 * 						--> createBean(beanName, mbd, args);

 * 			1）、遍历获取容器中所有的Bean，依次创建对象getBean(beanName);

 * 			2）、创建bean

 * 				【AnnotationAwareAspectJAutoProxyCreator在所有bean创建之前会有一个拦截，InstantiationAwareBeanPostProcessor，会调用postProcessBeforeInstantiation()】

 * 				1）、先获取BeanPostProcessors类的bean,如果获取到对应的bean则返回当前bean，否则再执行下边的createBean()方法。

 * 					先从缓存中获取当前bean，如果能获取到，说明bean是之前被创建过的，直接使用，否则再创建；

 * 					只要创建好的Bean都会被缓存起来

 * 					执行：AbstractAutowireCapableBeanFactory类

 * 							--> createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

 * 							--> resolveBeforeInstantiation(beanName, mbdToUse);

 * 							--> applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName);

 * 							--> AbstractAutoProxyCreator类的 --> postProcessBeforeInstantiation(Class<?> beanClass, String beanName)方法。

 * 				2）、createBean（）;创建bean；

 * 					AnnotationAwareAspectJAutoProxyCreator 会在任何bean创建之前先尝试返回bean的实例

 * 					【BeanPostProcessor是在Bean对象创建完成初始化前后调用的】

 * 					【InstantiationAwareBeanPostProcessor是在创建Bean实例之前先尝试用后置处理器返回对象的】

 * 					1）、resolveBeforeInstantiation(beanName, mbdToUse);解析BeforeInstantiation

 * 						希望后置处理器在此能返回一个代理对象；如果能返回代理对象就使用，如果不能就继续

 * 						1）、后置处理器先尝试返回对象；

 * 							bean = applyBeanPostProcessorsBeforeInstantiation（）：

 * 								拿到所有后置处理器，如果是InstantiationAwareBeanPostProcessor;

 * 								就执行postProcessBeforeInstantiation

 * 							if (bean != null) {

								bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);

							}

 *

 * 					2）、doCreateBean(beanName, mbdToUse, args);真正的去创建一个bean实例；和3.6流程一样；

部分关键代码如下：

AbstractAutowireCapableBeanFactory类的createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)方法

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

			throws BeanCreationException {

		if (logger.isTraceEnabled()) {

			logger.trace("Creating instance of bean '" + beanName + "'");

		}

		RootBeanDefinition mbdToUse = mbd;

		// Make sure bean class is actually resolved at this point, and

		// clone the bean definition in case of a dynamically resolved Class

		// which cannot be stored in the shared merged bean definition.

		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);

		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {

			mbdToUse = new RootBeanDefinition(mbd);

			mbdToUse.setBeanClass(resolvedClass);

		}

		// Prepare method overrides.

		try {

			mbdToUse.prepareMethodOverrides();

		}

		catch (BeanDefinitionValidationException ex) {

			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),

					beanName, "Validation of method overrides failed", ex);

		}

		try {

			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.

			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);

			if (bean != null) {

				return bean;

			}

		}

		catch (Throwable ex) {

			throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,

					"BeanPostProcessor before instantiation of bean failed", ex);

		}

		try {

			Object beanInstance = doCreateBean(beanName, mbdToUse, args);

			if (logger.isTraceEnabled()) {

				logger.trace("Finished creating instance of bean '" + beanName + "'");

			}

			return beanInstance;

		}

		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {

			// A previously detected exception with proper bean creation context already,

			// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.

			throw ex;

		}

		catch (Throwable ex) {

			throw new BeanCreationException(

					mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);

		}

	}

AbstractAutowireCapableBeanFactory类resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd)方法applyBeanPostProcessorsBeforeInstantiation方法

@Nullable

	protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {

		Object bean = null;

		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {

			// Make sure bean class is actually resolved at this point.

			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {

				Class<?> targetType = determineTargetType(beanName, mbd);

				if (targetType != null) {

					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);

					if (bean != null) {

						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);

					}

				}

			}

			mbd.beforeInstantiationResolved = (bean != null);

		}

		return bean;

	}

@Nullable

	protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {

		for (BeanPostProcessor bp : getBeanPostProcessors()) {

			if (bp instanceof InstantiationAwareBeanPostProcessor) {

				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;

				Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);

				if (result != null) {

					return result;

				}

			}

		}

		return null;

	}

最终实现方法：

　　AbstractAutoProxyCreator类的 --> postProcessBeforeInstantiation(Class<?> beanClass, String beanName)方法。

@Override

	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {

		Object cacheKey = getCacheKey(beanClass, beanName);

		if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {

			if (this.advisedBeans.containsKey(cacheKey)) {

				return null;

			}

			if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {

				this.advisedBeans.put(cacheKey, Boolean.FALSE);

				return null;

			}

		}

		// Create proxy here if we have a custom TargetSource.

		// Suppresses unnecessary default instantiation of the target bean:

		// The TargetSource will handle target instances in a custom fashion.

		TargetSource targetSource = getCustomTargetSource(beanClass, beanName);

		if (targetSource != null) {

			if (StringUtils.hasLength(beanName)) {

				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;

	}

6、AOP原理-创建AOP代理

说明：

　　增强器，aop的相应增强器通过@Before、@After、@AfterReturning、@AfterThrowing等注解标识；
　　运行时，哪些类需要生成切面代理对象，通过@Pointcut注解去匹配；
　　确定以上两点信息后，spring通过代理要厂最终生成代码对象。

 * AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】	的作用：

 * 1）、每一个bean创建之前，调用postProcessBeforeInstantiation()；

 * 		关心MathCalculator和LogAspect的创建

 * 		1）、判断当前bean是否在advisedBeans[增强器bean](保存了所有需要增强bean)中

 * 		2）、判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean，

 * 			或者是否是切面（@Aspect）

 * 		3）、是否需要跳过

 * 			1）、获取候选的增强器（切面里面的通知方法）【List<Advisor> candidateAdvisors】

 * 				每一个封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor；

 * 				判断每一个增强器是否是 AspectJPointcutAdvisor 类型的；返回true

 * 			2）、永远返回false

 *

 * 2）、创建对象时，调用postProcessAfterInitialization；

 * 			执行：AbstractAutoProxyCreator类

 * 					--> postProcessAfterInitialization(@Nullable Object bean, String beanName);

 * 					--> wrapIfNecessary(bean, beanName, cacheKey);//包装如果需要的情况下

 * 		1）、获取当前bean的所有增强器（通知方法）  Object[]  specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);

 * 			1、找到候选的所有的增强器（找哪些通知方法是需要切入当前bean方法的）

 * 			2、获取到能在bean使用的增强器。

 * 			3、给增强器排序

 * 		2）、保存当前bean在advisedBeans中；

 * 		3）、如果当前bean需要增强，创建当前bean的代理对象；

 * 			1）、获取所有增强器（通知方法）

 * 			2）、保存到proxyFactory

 * 			3）、创建代理对象：Spring自动决定

 * 				JdkDynamicAopProxy(config);jdk动态代理；

 * 				ObjenesisCglibAopProxy(config);cglib的动态代理；

 * 		4）、给容器中返回当前组件使用cglib增强了的代理对象；

 * 		5）、以后容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程；

核心代码：

/**

	 * Wrap the given bean if necessary, i.e. if it is eligible for being proxied.

	 * @param bean the raw bean instance

	 * @param beanName the name of the bean

	 * @param cacheKey the cache key for metadata access

	 * @return a proxy wrapping the bean, or the raw bean instance as-is

	 */

	protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {

		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.

		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;

	}

创建代码对象：

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 = new ProxyFactory();

		proxyFactory.copyFrom(this);

		if (!proxyFactory.isProxyTargetClass()) {

			if (shouldProxyTargetClass(beanClass, beanName)) {

				proxyFactory.setProxyTargetClass(true);

			}

			else {

				evaluateProxyInterfaces(beanClass, proxyFactory);

			}

		}

		Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);  1.获取增加器

		proxyFactory.addAdvisors(advisors);

		proxyFactory.setTargetSource(targetSource);                          2.目标对象

		customizeProxyFactory(proxyFactory);                                 3.代码工厂

		proxyFactory.setFrozen(this.freezeProxy);

		if (advisorsPreFiltered()) {

			proxyFactory.setPreFiltered(true);

		}

		return proxyFactory.getProxy(getProxyClassLoader());　　　　          4.通过代码工厂获取代理对象

	}

动态代码获取代理对象

　　1.有接口或者父类的，使用jdk动态代理获取对象

　　2.否则，使用cglib动态代理获取代理对象。

@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() || Proxy.isProxyClass(targetClass)) {

				return new JdkDynamicAopProxy(config);

			}

			return new ObjenesisCglibAopProxy(config);

		}

		else {

			return new JdkDynamicAopProxy(config);

		}

	}

7、AOP原理-获取拦截器链-MethodInterceptor

7和8写到一块

8、AOP原理-链式调用通知方法

　　实际上就是cglib动态代理的执行流程：

 * 	3）、目标方法执行	；

 * 		容器中保存了组件的代理对象（cglib增强后的对象），这个对象里面保存了详细信息（比如增强器，目标对象，xxx）；

 * 		1）、CglibAopProxy.intercept();拦截目标方法的执行

 * 		2）、根据ProxyFactory对象获取将要执行的目标方法拦截器链；

 * 			List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

 * 			1）、List<Object> interceptorList保存所有拦截器 5

 * 				一个默认的ExposeInvocationInterceptor 和 4个增强器；

 * 			2）、遍历所有的增强器，将其转为Interceptor；

 * 				registry.getInterceptors(advisor);

 * 			3）、将增强器转为List<MethodInterceptor>；

 * 				如果是MethodInterceptor，直接加入到集合中

 * 				如果不是，使用AdvisorAdapter将增强器转为MethodInterceptor；

 * 				转换完成返回MethodInterceptor数组；

 *

 * 		3）、如果没有拦截器链，直接执行目标方法;

 * 			拦截器链（每一个通知方法又被包装为方法拦截器，利用MethodInterceptor机制）

 * 		4）、如果有拦截器链，把需要执行的目标对象，目标方法，

 * 			拦截器链等信息传入创建一个 CglibMethodInvocation 对象，

 * 			并调用 Object retVal =  mi.proceed();

 * 		5）、拦截器链的触发过程;

 * 			1)、如果没有拦截器执行执行目标方法，或者拦截器的索引和拦截器数组-1大小一样（指定到了最后一个拦截器）执行目标方法；

 * 			2)、链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行；

 * 				拦截器链的机制，保证通知方法与目标方法的执行顺序；

　核心代码：

CglibAopProxy类的内部类的DynamicAdvisedInterceptor的intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy)方法。

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

			Object oldProxy = null;

			boolean setProxyContext = false;

			Object target = null;

			TargetSource targetSource = this.advised.getTargetSource();

			try {

				if (this.advised.exposeProxy) {

					// Make invocation available if necessary.

					oldProxy = AopContext.setCurrentProxy(proxy);

					setProxyContext = true;

				}

				// Get as late as possible to minimize the time we "own" the target, in case it comes from a pool...

				target = targetSource.getTarget();

				Class<?> targetClass = (target != null ? target.getClass() : null);

				List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

				Object retVal;

				// Check whether we only have one InvokerInterceptor: that is,

				// no real advice, but just reflective invocation of the target.

				if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {

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

					retVal = methodProxy.invoke(target, argsToUse);

				}

				else {

					// We need to create a method invocation...

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

				}

				retVal = processReturnType(proxy, target, method, retVal);

				return retVal;

			}

			finally {

				if (target != null && !targetSource.isStatic()) {

					targetSource.releaseTarget(target);

				}

				if (setProxyContext) {

					// Restore old proxy.

					AopContext.setCurrentProxy(oldProxy);

				}

			}

		}

9、AOP-原理总结

原理解析的整体流程：

 * AOP原理：【看给容器中注册了什么组件，这个组件什么时候工作，这个组件的功能是什么？】

 * 		@EnableAspectJAutoProxy；

 * 1、@EnableAspectJAutoProxy是什么？

 * 		@Import(AspectJAutoProxyRegistrar.class)：给容器中导入AspectJAutoProxyRegistrar

 * 			利用AspectJAutoProxyRegistrar自定义给容器中注册bean；BeanDefinetion

 * 			internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator[注解装配切面自动代理创建器]

 *

 * 		给容器中注册一个AnnotationAwareAspectJAutoProxyCreator；

 *

 * 2、 AnnotationAwareAspectJAutoProxyCreator：

 * 		AnnotationAwareAspectJAutoProxyCreator

 * 			->AspectJAwareAdvisorAutoProxyCreator

 * 				->AbstractAdvisorAutoProxyCreator

 * 					->AbstractAutoProxyCreator

 * 							implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware

 * 						关注后置处理器（在bean初始化完成前后做事情）、自动装配BeanFactory

 *

 * AbstractAutoProxyCreator.setBeanFactory()

 * AbstractAutoProxyCreator.有后置处理器的逻辑；

 * AbstractAdvisorAutoProxyCreator.setBeanFactory()-> initBeanFactory()

 * AnnotationAwareAspectJAutoProxyCreator.initBeanFactory()

 *

 *

 * 代码执行流程：

 * 		1）、传入配置类，创建ioc容器；

 * 			执行： new AnnotationConfigApplicationContext(MainConfigOfAOP.class);

 * 		2）、注册配置类，调用refresh()刷新容器；

 * 			执行：AnnotationConfigApplicationContext(Class<?>... componentClasses)-->refresh()

 * 		3）、registerBeanPostProcessors(beanFactory);注册bean的后置处理器来方便拦截bean的创建；

 * 				执行：AbstractApplicationContext类

 * 						-->refresh()

 * 						-->registerBeanPostProcessors(beanFactory)

 * 						-->PostProcessorRegistrationDelegate类的registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext)

 * 			1）、先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor

 * 			2）、给容器中加别的BeanPostProcessor

 * 			3）、优先注册实现了PriorityOrdered接口的BeanPostProcessor；

 * 			4）、再给容器中注册实现了Ordered接口的BeanPostProcessor；

 * 			5）、注册没实现优先级接口的BeanPostProcessor；

 * 			6）、注册BeanPostProcessor，实际上就是创建BeanPostProcessor对象，保存在容器中；

 * 				创建internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】

 * 					执行：PostProcessorRegistrationDelegate类的registerBeanPostProcessors()方法中的以下这一行代码会创建BeanPostProcessor对象

 * 						BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);

 * 				1）、创建Bean的实例

 * 				2）、populateBean；给bean的各种属性赋值

 * 				3）、initializeBean：初始化bean；

 * 						1）、invokeAwareMethods()：处理Aware接口的方法回调

 * 						2）、applyBeanPostProcessorsBeforeInitialization()：应用后置处理器的postProcessBeforeInitialization（）

 * 						3）、invokeInitMethods()；执行自定义的初始化方法

 * 						4）、applyBeanPostProcessorsAfterInitialization()；执行后置处理器的postProcessAfterInitialization（）；

 * 				4）、BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功；--> aspectJAdvisorsBuilder

 * 			7）、把BeanPostProcessor注册到BeanFactory中；

 * 				beanFactory.addBeanPostProcessor(postProcessor);

 * =======以上是创建和注册AnnotationAwareAspectJAutoProxyCreator的过程========

 *

 * 			AnnotationAwareAspectJAutoProxyCreator => InstantiationAwareBeanPostProcessor

 * 		4）、finishBeanFactoryInitialization(beanFactory);完成BeanFactory初始化工作；创建剩下的单实例bean

 * 				执行：AbstractApplicationContext类

 * 						--> refresh();

 * 						--> finishBeanFactoryInitialization(beanFactory);

 * 						--> beanFactory.preInstantiateSingletons();

 * 						--> getBean(beanName);

 * 						--> doGetBean(name, null, null, false);

 * 						--> getSingleton(beanName, ());

 * 						--> createBean(beanName, mbd, args);

 * 			1）、遍历获取容器中所有的Bean，依次创建对象getBean(beanName);

 * 			2）、创建bean

 * 				【AnnotationAwareAspectJAutoProxyCreator在所有bean创建之前会有一个拦截，InstantiationAwareBeanPostProcessor，会调用postProcessBeforeInstantiation()】

 * 				1）、先获取BeanPostProcessors类的bean,如果获取到对应的bean则返回当前bean，否则再执行下边的createBean()方法。

 * 					先从缓存中获取当前bean，如果能获取到，说明bean是之前被创建过的，直接使用，否则再创建；

 * 					只要创建好的Bean都会被缓存起来

 * 					执行：AbstractAutowireCapableBeanFactory类

 * 							--> createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

 * 							--> resolveBeforeInstantiation(beanName, mbdToUse);

 * 							--> applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName);

 * 							--> AbstractAutoProxyCreator类的 --> postProcessBeforeInstantiation(Class<?> beanClass, String beanName)方法。

 * 				2）、createBean（）;创建bean；

 * 					AnnotationAwareAspectJAutoProxyCreator 会在任何bean创建之前先尝试返回bean的实例

 * 					【BeanPostProcessor是在Bean对象创建完成初始化前后调用的】

 * 					【InstantiationAwareBeanPostProcessor是在创建Bean实例之前先尝试用后置处理器返回对象的】

 * 					1）、resolveBeforeInstantiation(beanName, mbdToUse);解析BeforeInstantiation

 * 						希望后置处理器在此能返回一个代理对象；如果能返回代理对象就使用，如果不能就继续

 * 						1）、后置处理器先尝试返回对象；

 * 							bean = applyBeanPostProcessorsBeforeInstantiation（）：

 * 								拿到所有后置处理器，如果是InstantiationAwareBeanPostProcessor;

 * 								就执行postProcessBeforeInstantiation

 * 							if (bean != null) {

								bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);

							}

 *

 * 					2）、doCreateBean(beanName, mbdToUse, args);真正的去创建一个bean实例；和3.6流程一样；

 *

 *

 * AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】	的作用：

 * 1）、每一个bean创建之前，调用postProcessBeforeInstantiation()；

 * 		关心MathCalculator和LogAspect的创建

 * 		1）、判断当前bean是否在advisedBeans[增强器bean](保存了所有需要增强bean)中

 * 		2）、判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean，

 * 			或者是否是切面（@Aspect）

 * 		3）、是否需要跳过

 * 			1）、获取候选的增强器（切面里面的通知方法）【List<Advisor> candidateAdvisors】

 * 				每一个封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor；

 * 				判断每一个增强器是否是 AspectJPointcutAdvisor 类型的；返回true

 * 			2）、永远返回false

 *

 * 2）、创建对象时，调用postProcessAfterInitialization；

 * 			执行：AbstractAutoProxyCreator类

 * 					--> postProcessAfterInitialization(@Nullable Object bean, String beanName);

 * 					--> wrapIfNecessary(bean, beanName, cacheKey);//包装如果需要的情况下

 * 		1）、获取当前bean的所有增强器（通知方法）  Object[]  specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);

 * 			1、找到候选的所有的增强器（找哪些通知方法是需要切入当前bean方法的）

 * 			2、获取到能在bean使用的增强器。

 * 			3、给增强器排序

 * 		2）、保存当前bean在advisedBeans中；

 * 		3）、如果当前bean需要增强，创建当前bean的代理对象；

 * 			1）、获取所有增强器（通知方法）

 * 			2）、保存到proxyFactory

 * 			3）、创建代理对象：Spring自动决定

 * 				JdkDynamicAopProxy(config);jdk动态代理；

 * 				ObjenesisCglibAopProxy(config);cglib的动态代理；

 * 		4）、给容器中返回当前组件使用cglib增强了的代理对象；

 * 		5）、以后容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程；

 *

 *

 * 	3）、目标方法执行	；

 * 		容器中保存了组件的代理对象（cglib增强后的对象），这个对象里面保存了详细信息（比如增强器，目标对象，xxx）；

 * 		1）、CglibAopProxy.intercept();拦截目标方法的执行

 * 		2）、根据ProxyFactory对象获取将要执行的目标方法拦截器链；

 * 			List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

 * 			1）、List<Object> interceptorList保存所有拦截器 5

 * 				一个默认的ExposeInvocationInterceptor 和 4个增强器；

 * 			2）、遍历所有的增强器，将其转为Interceptor；

 * 				registry.getInterceptors(advisor);

 * 			3）、将增强器转为List<MethodInterceptor>；

 * 				如果是MethodInterceptor，直接加入到集合中

 * 				如果不是，使用AdvisorAdapter将增强器转为MethodInterceptor；

 * 				转换完成返回MethodInterceptor数组；

 *

 * 		3）、如果没有拦截器链，直接执行目标方法;

 * 			拦截器链（每一个通知方法又被包装为方法拦截器，利用MethodInterceptor机制）

 * 		4）、如果有拦截器链，把需要执行的目标对象，目标方法，

 * 			拦截器链等信息传入创建一个 CglibMethodInvocation 对象，

 * 			并调用 Object retVal =  mi.proceed();

 * 		5）、拦截器链的触发过程;

 * 			1)、如果没有拦截器执行执行目标方法，或者拦截器的索引和拦截器数组-1大小一样（指定到了最后一个拦截器）执行目标方法；

 * 			2)、链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行；

 * 				拦截器链的机制，保证通知方法与目标方法的执行顺序；

 *

 * 	总结：

 * 		1）、 @EnableAspectJAutoProxy 开启AOP功能

 * 		2）、 @EnableAspectJAutoProxy 会给容器中注册一个组件 AnnotationAwareAspectJAutoProxyCreator

 * 		3）、AnnotationAwareAspectJAutoProxyCreator是一个后置处理器；

 * 		4）、容器的创建流程：

 * 			1）、registerBeanPostProcessors（）注册后置处理器；创建AnnotationAwareAspectJAutoProxyCreator对象

 * 			2）、finishBeanFactoryInitialization（）初始化剩下的单实例bean

 * 				1）、创建业务逻辑组件和切面组件

 * 				2）、AnnotationAwareAspectJAutoProxyCreator拦截组件的创建过程

 * 				3）、组件创建完之后，判断组件是否需要增强

 * 					是：切面的通知方法，包装成增强器（Advisor）;给业务逻辑组件创建一个代理对象（cglib）；

 * 		5）、执行目标方法：

 * 			1）、代理对象执行目标方法

 * 			2）、CglibAopProxy.intercept()；

 * 				1）、得到目标方法的拦截器链（增强器包装成拦截器MethodInterceptor）

 * 				2）、利用拦截器的链式机制，依次进入每一个拦截器进行执行；

 * 				3）、效果：

 * 					正常执行：前置通知->目标方法->后置通知->返回通知

 * 					出现异常：前置通知->目标方法->后置通知->异常通知