spring注解-AOP动态代理-@EnableAspectJAutoProxy注解如何工作
一.概述
AOP面向切面编程，生成目标方法所属类的代理类。代理类和目标类的关系：代理类继承目标类，并重载了目标类的方法。
代理类重载方法体里加入了切面业务逻辑和目标类方法的调用。
用户如何使用：从容器中获取目标类，实际上是获取代理类的实例， 代理类实例调用重载了父类的方法，就实现了AOP。
二.步骤
1.在配置类上添加@EnableAspectJAutoProxy注解，开启注解版的AOP功能
2.声明切面类：@Aspect表明这是一个切面类，注：@Aspect是spring-annotation2/libs/com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar的注解，
在其org.aspectj.lang.annotation包下包含了切面相关的的注解。aop包下载地址：https://www.eclipse.orgaspectj
3.声明切面方法：
1.切点：在哪些目标方法上添加该切面方法 。切点表达式：execution(* com.dr.service.*.buy*(..))：方法访问权限 包路径.类名.方法名(参数类型,参数类型...)
参数类型可以用“..”代替。
2.重用切点：在切面中声明切点方法：添加@Pointcut注解， @Pointcut(value="execution(*******)") 切点方法返回值 void，方法体为空。
在切面方法上引用切点：在通知类型注解里指定 pointcut="切面类.切点方法()"
3.几种通知类型：
1.@Before
到此，AOP功能就实现了。。。
三、运行流程源码解析
1.spring容器用DefaultListableBeanFactory保存 beanNames集合 ，beanName和BeanDefinition映射的集合
默认加载这6个bean定义：
这6个bean定义信息加载时机：
1.开始： ApplicationContext ctx=new AnnotationConfigApplicationContext(MainConfig.class); 2.进入构造方法： public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) { this(); register(annotatedClasses); refresh(); } 3.进入this() public AnnotationConfigApplicationContext() { this.reader = new AnnotatedBeanDefinitionReader(this); this.scanner = new ClassPathBeanDefinitionScanner(this); } 4.进入this.reader = new AnnotatedBeanDefinitionReader(this); public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) { this(registry, getOrCreateEnvironment(registry)); } 5.再进入 public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) { Assert.notNull(registry, "BeanDefinitionRegistry must not be null"); Assert.notNull(environment, "Environment must not be null"); this.registry = registry; this.conditionEvaluator = new ConditionEvaluator(registry, environment, null); AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry); } 6.AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry); 最终调用AnnotationConfigUtils的方法： public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors( BeanDefinitionRegistry registry, @Nullable Object source) 完成注册
AnnotationConfigApplicationContext调用自己的属性AnnotatedBeanDefinitionReader完成注册，AnnotatedBeanDefinitionReader又调
用AnnotationConfigUtils完成注册，而AnnotationConfigUtils定义了这6个beanName常量。
这6个bean如何注册：
if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)); }
这6个beanName，spring内部有对应的类： RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
开始分析AOP原理：
一、@EnableAspectJAutoProxy如何开启aop动态代理功能
它的注解源码如下：
@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Import(AspectJAutoProxyRegistrar.class) public @interface EnableAspectJAutoProxy { boolean proxyTargetClass() default false; boolean exposeProxy() default false; }
@Import(AspectJAutoProxyRegistrar.class)的功能是注册一个bean：AspectJAutoProxyRegistrar.class是AspectJ自动代理注册器
那么spring什么时候解析配置类上面的注解:（也是解析配置类上的注解，加载bean的流程）
1.进入AnnotationConfigApplicationContext构造器，运行到refresh（）
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) { this(); register(annotatedClasses); refresh(); }
2.refresh()方法里运行到invokeBeanFactoryPostProcessors(beanFactory)，该方法的作用是：调用beanFactory（这里的beanFactory实例是：DefaultListableBeanFactory）的后置处理器
public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { ...... // Invoke factory processors registered as beans in the context. invokeBeanFactoryPostProcessors(beanFactory); ...... } }
3.进入invokeBeanFactoryPostProcessors(beanFactory)，
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors()); // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor) if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); } }
4.PostProcessorRegistrationDelegate类invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors())，调用beanFactory的后置处理器
invokeBeanFactoryPostProcessors执行流程：
1.判断beanFactory是否 BeanDefinitionRegistry类型
如果是：
1.遍历ApplicationContext中的beanFactory后置处理器：
如果beanFactory是BeanDefinitionRegistryPostProcessor类型：
调用BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry(registry)
postProcessBeanDefinitionRegistry(registry)作用是：Derive further bean definitions from the configuration classes in the registry
从beanFactory中解析出所有要加载的bean
否则就先加到集合中保存。
2.从DefaultListableFactory之前默认加载6个BeanDefinition中找到BeanDefinitionRegistryPostProcessor类型并且实现了PriorityOrdered接口的bean定义。
把它实例化：beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class))，保存到集合中
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
3.invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);遍历第2步得到的BeanDefinitionRegistryPostProcessor集合，调用它的
postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) 从所有配置类中解析出要加载的bean。
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) { int registryId = System.identityHashCode(registry); if (this.registriesPostProcessed.contains(registryId)) { throw new IllegalStateException( "postProcessBeanDefinitionRegistry already called on this post-processor against " + registry); } if (this.factoriesPostProcessed.contains(registryId)) { throw new IllegalStateException( "postProcessBeanFactory already called on this post-processor against " + registry); } this.registriesPostProcessed.add(registryId); processConfigBeanDefinitions(registry); }
第4步解析到这里，停止，因为现在要了解 EnableAspectJAutoProxy注解什么时候加载AspectJAutoProxyRegistrar
5.进入processConfigBeanDefinitions(registry)方法。这里提醒一下：ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor
以下操作是在ConfigurationClassPostProcessor类中运行。
1.从DefaultListableBeanFactory的bean定义集合中找出标了@Configuration的bean定义，加到集合中
2.解析所有的配置类：使用ConfigurationClassParser类解析所有配置类--->parse(配置类集合)
6.进入ConfigurationClassParser.parse(配置类集合)
遍历配置类，对每个配置类的每个注解递归解析找到 @Import注解，再加加载该注解指定要加载的类
于是，这时加载了AspectJAutoProxyRegistrar.class,这个类的作用是加载AnnotationAwareAspectJAutoProxyCreator.class
---------------------现在分析AspectJAutoProxyRegistrar如何注册AnnotationAwareAspectJAutoProxyCreator-------------------------
1.ConfigurationClassParser解析完配置类后（上个解析第5步），ConfigurationClassPostProcessor类中的ConfigurationClassBeanDefinitionReader调用loadBeanDefinitions(ConfigurationClass configClasses集合)
ConfigurationClass包含了对应配置类解析出的所有bean定义
2.ConfigurationClassParser中的方法loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());这时就加载了AnnotationAwareAspectJAutoProxyCreator
3. AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar ，这时 AspectJAutoProxyRegistrar调用registerBeanDefinitions(metadata, this.registry)
private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars) { registrars.forEach((registrar, metadata) -> registrar.registerBeanDefinitions(metadata, this.registry)); }
4.
@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); } } }
@Nullable public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) { return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null); }
@Nullable public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary( BeanDefinitionRegistry registry, @Nullable Object source) { return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source); }
最后是调用DefaultListableBeanFactory 注册registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition)， beanDefinition就是AnnotationAwareAspectJAutoProxyCreator
的bean定义信息。
------------------------------------------------------------------------------------到此，如何注册AnnotationAwareAspectJAutoProxyCreator就分析完了。
现在开始分析，如何spring AOP如何创建切面目标类的代理类：
1.refresh()方法中：finishBeanFactoryInitialization(beanFactory);的作用是：实例化所有已解析加载的bean定义信息，bean就在这个方法中初始化。
2.beanFactory.preInstantiateSingletons();这个方法遍历DefaultListableBeanFactory中所有的bean定义信息（BeanDefinition）如果容器中没有，就初始化
3.以下也是bean的初始化步骤：
getBean(beanName) ——> doGetBean(beanName,...) ——>getSingleton(beanName,()->{... return CreateBean(beanName,RootBeanDefinition,args)})——>doCreateBean(...)
4.要知道AOP如何创建代理，分析doCreateBean(...)方法
doCreateBean(...)方法：{
populateBean(beanName, mbd, instanceWrapper); beanName,BeanDefinition,包含new 出来的目标对象的包装类
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
5. exposedObject = initializeBean(beanName, exposedObject, mbd);解析：
1. invokeAwareMethods(beanName, bean);如果属于BeanFactoryAware，setBeanFactory(DefaultListableBeanFactory )
2. applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
3. invokeInitMethods(beanName, wrappedBean, mbd);
4. applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);这个方法遍历DefaultListableBeanFactory里面beanPostProcessors的集合
依次执行processor.postProcessAfterInitialization(result, beanName)，如果返回null,技术遍历,
当遍历到AnnotationAwareAspectJAutoProxyCreator时，创建bean的代理对象：
它继承自 AbstractAutoProxyCreator extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
创建代理：1.Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);获得通知信息，如切点
// 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 poxy
到此代理类创建完毕，代理类包含了目标类和目标类实现的接口，和切面类的切点信息。
现在分析动态代理 -方法调用- 插入切面逻辑的实现：
1.
public static void main(String[] args) { // TODO Auto-generated method stub ApplicationContext ctx=new AnnotationConfigApplicationContext(MainConfig.class); Calculator cl=(Calculator) ctx.getBean("calculator"); cl.add(5, 5); }
2.这里Calculator实际上是对应的代理类 cl.add(5,5)也是调用代理类的方法
CglibAopProxy内部类DynamicAdvisedInterceptor ，调用inteceptor(...)方法 运行摘要如下：
new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();责任链模式实现链式执行切面逻辑：
ReflectiveMethodInvocation是责任链执行器，所有切面通知(before,after, ...)对应的类都实现了MethodInterceptor接口，这个接口有invoke()方法
执行流程：
ReflectiveMethodInvocation的proceed()方法遍历通知类，依次调用invoke( 传入ReflectiveMethodInvocation的this ) 方法
invoke(...)方法里面做两件事：1.调用切面通知(before,after,...)对应的类对象，执行对应的切面方法 2.传入的this.proceed()又回到proceed()方法中继续遍历
这是递归调用，1 和 2的顺序根据通知类型顺序不一样
到此，分析结束。
