在processOn上看到了aop的时序图,于是就看了看,整理了并写出此篇

在springboot中,开启AOP只需要加入如下注解 file 于是,追踪源码:

@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呢? 下面一起一探揪净~~

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类,于是乎,点开源码看看咯,你瞧我这看源码的脾气~

这里,这个类继承了很多很多的类,这里用下面一张图来展示它的类依赖关系 file 你瞧,我的mac截图清晰不?哈哈,扯个dan。。。 看到上面的类依赖关系之后,经常玩spring的同学一下就可以看出下一步要追踪哪个类…… 对对对,没错,就是这个类,org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor,这个类是啥意思呢?你木讷不?我不卖关子了,这个类就是在类实例化前做的一些操作,也就是如果beanMap不包含当前bean,就执行这里面的方法,具体实现自己可以去写个demo……知道这个就好了,断点就在org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization方法,也就是在初始化之后调用这个方法,看代码:

@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,从方法命名也看得出来

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

眼看马上要修成正果了~~ 创建代理的方法我单独贴出来去分析:

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 源码解析时序图.pngfile

到了这里,aop的初始化的一部分原理就调试完了,那么他为什么要这么做呢?有什么好处呢?他可以用到哪些场景?

评论区见!