在processOn上看到了aop的时序图，于是就看了看，整理了并写出此篇
在springboot中，开启AOP只需要加入如下注解
于是，追踪源码：
代码语言：javascript复制@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
//根据spring体系的特殊功能，即注解具有继承性，于是可看出AspectJAutoProxyRegistrar类
@Import({AspectJAutoProxyRegistrar.class})
public @interface EnableAspectJAutoProxy {
boolean proxyTargetClass() default false;
boolean exposeProxy() default false;
}点开AspectJAutoProxyRegistrar类之后，会发现这里会注入bean的定义信息，那么定义那个bean呢？ 下面一起一探揪净~~
代码语言：javascript复制class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
AspectJAutoProxyRegistrar() {
}
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);
}
}
}
}点开看看 原来是注册了org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator类，于是乎，点开源码看看咯，你瞧我这看源码的脾气~
这里，这个类继承了很多很多的类，这里用下面一张图来展示它的类依赖关系
你瞧，我的mac截图清晰不？哈哈，扯个dan。。。 看到上面的类依赖关系之后，经常玩spring的同学一下就可以看出下一步要追踪哪个类…… 对对对，没错，就是这个类，org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor，这个类是啥意思呢？你木讷不？我不卖关子了，这个类就是在类实例化前做的一些操作，也就是如果beanMap不包含当前bean，就执行这里面的方法，具体实现自己可以去写个demo……知道这个就好了，断点就在org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization方法，也就是在初始化之后调用这个方法，看代码：
代码语言：javascript复制@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
//bean肯定不为null
Object cacheKey = getCacheKey(bean.getClass(), beanName);
//看它的缓存有没有，代理集合跟当前bean是不是一个 不是的话包装一下，也就是创建代理那一步
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}下面就是看是否需要用代理包装一下当前bean，从方法命名也看得出来
代码语言：javascript复制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;
}
//这一步 …… 看目标类是不是实现了Pointcut/Advisor/AopInfrastructureBean/Advice接口，如果实现了，直接返回
//看目标类和beanName命名是否有关联
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// Create proxy if we have advice.
//好戏来了，上面判断完了之后，这里就要开始获取当前目标类对应的各种通知（前置/环绕通知，切面等）方法了,
//，也就是匹配那几个注解了@pointcut，@Around等等 如果不等于代理，也就是返回的数组里面有切面和通知方法，
//即给创建代理
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;
}眼看马上要修成正果了~~ 创建代理的方法我单独贴出来去分析：
代码语言：javascript复制protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
@Nullable Object[] specificInterceptors, TargetSource targetSource) {
//如果是beanFactory 暴露目标类
if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
}
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.copyFrom(this);
if (!proxyFactory.isProxyTargetClass()) {
//是否可暴露目标类，也就是一开始我们注解的那两个属性
//EnableAspectJAutoProxy(proxyTargetClass = true,exposeProxy = true)
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}
//构造它的aop切面拦截器>>>高能：这段代码就是为什么aop可以拦截到当前方法，包括各种通知
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 AOP 源码解析时序图.png
到了这里，aop的初始化的一部分原理就调试完了，那么他为什么要这么做呢？有什么好处呢？他可以用到哪些场景？
