SpringAOP自动代理创建器AnnotationAwareAspectJAutoProxyCreator

参考文章【小家Spring】Spring AOP的核心类:AbstractAdvisorAutoProxy自动代理创建器深度剖析(AnnotationAwareAspectJAutoProxyCreator)

前言

SpringAOP面向切面编程应用结合实例,介绍了Spring AOP的过程以及对源码进行了逐步分析~

但是这中间当时事忽略了整个Spring AOP最为核心的一个类:自动代理创建器。

本文将主要以AnnotationAwareAspectJAutoProxyCreator为引线,好好聊聊自动代理创建器是做什么的,具体做了什么,以及Spring为我们提供的其它几个Creator:DefaultAdvisorAutoProxyCreatorInfrastructureAdvisorAutoProxyCreatorAspectJAwareAdvisorAutoProxyCreator,有何区别和对应的实用场景
SpringAOP自动代理创建器AnnotationAwareAspectJAutoProxyCreator_第1张图片
可以看出来,所有的创建器都是AbstractAutoProxyCreator该抽象类的子类~

当系统比较复杂,或者中需要进行aop进行织入的bean较多时,简单采用ProxyFacotryBean无疑会增加很多工作量(因为每个Bean都得手动写一个)。另外由于要从ProxyFactoryBean获得代理对象,也会使应用和Spring之间的耦合度增加,并且很多时候可维护性不强(我个人认为耦合这个不是最主要的原因,毕竟现在Spring已成为实际上的规范了)。

譬如,我们需要给bean名字满足“*service”的bean每个方法增加事务功能,如果采用ProxyFacotryBean必须为每个以service结尾的bean增加一个配置(工作量巨大),若需要修改,这个后果是灾难性的。

在内部,Spring使用BeanPostProcessor让自动生成代理。基于BeanPostProcessor的自动代理创建器的实现类,将根据一些规则在容器实例化Bean时为匹配的Bean生成代理实例。代理创建器可以分为三类:

1、BeanNameAutoProxyCreator:基于Bean配置名规则的自动代理生成器:允许为一组特定配置名的Bean自动创建代理实例的代理创建器

2、DefaultAdvisorAutoProxyCreator:基于Advisor匹配机制的自动代理创建器它会对容器中的所有Advisor进行扫描,自动将这些切面应用到匹配的Bean中

3、AbstractAdvisorAutoProxyCreator:基于Bean中AspectJ注解的自动代理生成器:为包含AspectJ注解的切入的Bean自动创建代理实例

一、AbstractAutoProxyCreator的注册
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

	boolean proxyTargetClass() default false;

	boolean exposeProxy() default false;
}

配置类上标注@EnableAspectJAutoProxy,会往容器注入类AspectJAutoProxyRegistrar

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

	@Override
	public void registerBeanDefinitions( AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry){
        //往容器中注入AnnotationAwareAspectJAutoProxyCreator的tBeanDefinition
		AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
    
		AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
		if (enableAspectJAutoProxy != null) {
			// 若为true,表示强制指定了要使用CGLIB,那就强制告知到时候使用CGLIB的动态代理方式
			if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
				AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
			}
			// 告知,强制暴露Bean的代理对象到AopContext
			if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
				AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
			}
		}
	}
}
二、AbstractAutoProxyCreator源码

AbstractAutoProxyCreator是对自动代理创建器的一个抽象实现。最重要的是,它实现了SmartInstantiationAwareBeanPostProcessor接口,因此会介入到Spring IoC容器Bean实例化的过程,因此由此为入口进行展开~

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
	
	// 实现类就是我们熟悉的它:	DefaultAdvisorAdapterRegistry
	private AdvisorAdapterRegistry advisorAdapterRegistry = GlobalAdvisorAdapterRegistry.getInstance();	

	// 目标源的创建器。它有一个方法getTargetSource(Class beanClass, String beanName)
	// 两个实现类:QuickTargetSourceCreator和LazyInitTargetSourceCreator
	// 它的具体使用 后面有详解
	@Nullable
	private TargetSourceCreator[] customTargetSourceCreators;
	@Nullable
	private BeanFactory beanFactory;
	...
	private final Set<String> targetSourcedBeans = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
	private final Set<Object> earlyProxyReferences = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
	private final Map<Object, Class<?>> proxyTypes = new ConcurrentHashMap<>(16);
	private final Map<Object, Boolean> advisedBeans = new ConcurrentHashMap<>(256);
	...
	
     
	
	// 这个很重要,在Bean实例化之前,先给一个机会,看看缓存里有木有,有就直接返回得了
	// 简单的说:其主要目的在于如果用户使用了自定义的TargetSource对象,则直接使用该对象生成目标对象,而不会使用Spring的默认逻辑生成目标对象
	// (并且这里会判断各个切面逻辑是否可以应用到当前bean上)
	@Override
	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		Object cacheKey = getCacheKey(beanClass, beanName);
		
		// beanName无效或者targetSourcedBeans里不包含此Bean
		if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
			
			//advisedBeans:已经被通知了的(被代理了的)Bean~~~~  如果在这里面  也返回null 
			if (this.advisedBeans.containsKey(cacheKey)) {
				return null;
			}
			// isInfrastructureClass:Advice、Pointcut、Advisor、AopInfrastructureBean的子类,表示是框架所属的Bean
			// shouldSkip:默认都是返回false的。AspectJAwareAdvisorAutoProxyCreator重写此方法:只要存在一个Advisor   ((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)成立  就返回true
			if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {	
				// 所以这里会把我们所有的Advice、Pointcut、Advisor、AopInfrastructureBean等Bean都装进来
				this.advisedBeans.put(cacheKey, Boolean.FALSE);
				return null;
			}
		}

		//到这,只有在TargetSource中没有进行缓存,并且应该被切面逻辑环绕,但是目前还未生成代理对象的bean才会通过此方法

		// Create proxy here if we have a custom TargetSource.
		// 如果我们有TargetSourceCreator,这里就会创建一个代理对象
		// getCustomTargetSource逻辑:存在TargetSourceCreator  并且 beanFactory.containsBean(beanName)  然后遍历所有的TargetSourceCreator,调用getTargetSource谁先创建不为null就终止
		TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
		// 若创建好了这个代理对象,继续进一步的操作:::
		if (targetSource != null) {
			if (StringUtils.hasLength(beanName)) {
			  	// 缓存起来
				this.targetSourcedBeans.add(beanName);
			}
			
			//getAdvicesAndAdvisorsForBean:方法判断当前bean是否需要进行代理,若需要则返回满足条件的Advice或者Advisor集合
			// 这个方法由子类实现,AbstractAdvisorAutoProxyCreator和BeanNameAutoProxyCreator  代表中两种不同的代理方式
			Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
			
			// 顾名思义,就是根据目标对象创建代理对象的核心逻辑了 下面详解
			Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
			
			// 把创建好的代理  缓存~~~
			this.proxyTypes.put(cacheKey, proxy.getClass());
			return proxy;
		}

		return null;
	}



	// 这三个方法,没做什么动作~~
	@Override
	public boolean postProcessAfterInstantiation(Object bean, String beanName) {
		return true;
	}
	@Override
	public PropertyValues postProcessPropertyValues(
			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) {
		return pvs;
	}
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) {
		return bean;
	}


	// 代理是通过AbstractAutoProxyCreator中的postProcessAfterInitialization()创建的
	// 因此这个方法是蛮重要的,主要是wrapIfNecessary()方法会特别的重要
	// earlyProxyReferences缓存:该缓存用于保存已经创建过代理对象的cachekey,**避免重复创建**
	@Override
	public Object postProcessAfterInitialization(@Nullable 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;
	}

	// ============wrapIfNecessary方法==============
	protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
		// 若此Bean已经在targetSourcedBeans里,说明已经被代理过,那就直接返回即可
		// (postProcessBeforeInstantiation()中成功创建的代理对象都会将beanName加入到targetSourceBeans中)
		if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
			return bean;
		}
		
		// 如果该Bean基础框架Bean或者免代理得Bean,那也不处理
		if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
			return bean;
		}
		// 逻辑同上,对于实现了Advice,Advisor,AopInfrastructureBean接口的bean,都认为是spring aop的基础框架类,不能对他们创建代理对象,
		// 同时子类也可以覆盖shouldSkip方法来指定不对哪些bean进行代理
		if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return bean;
		}

		// Create proxy if we have advice.
		// getAdvicesAndAdvisorsForBean该方法由子类实现,如国有Advice切面切进去了,我们就要给他代理
		//根据getAdvicesAndAdvisorsForBean()方法的具体实现的不同,AbstractAutoProxyCreator又分成了两类自动代理机制
		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
		
		// 需要代理,那就进来给它创建一个代理对象吧
		if (specificInterceptors != DO_NOT_PROXY) {
			// 缓存起来,赋值为true,说明此key是被代理了的
			this.advisedBeans.put(cacheKey, Boolean.TRUE);
			
			// 创建这个代理对象
			Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
			// 创建好后缓存起来  避免重复创建
			this.proxyTypes.put(cacheKey, proxy.getClass());
			return proxy;
		}
		
		// 不需要代理,也把这种不需要代理的对象给与缓存起来  赋值为false
		this.advisedBeans.put(cacheKey, Boolean.FALSE);
		return bean;
	}

	// 创建代理对象  specificInterceptors:作用在这个Bean上的增强器们
	// 这里需要注意的地方:入参是targetSource  而不是target
	// 所以最终代理的是  ``每次AOP代理处理方法调用时,目标实例都会用到TargetSource实现``
	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 proxyFactory = new ProxyFactory();
		// 复制当前类的相关配置,因为当前类它也是个ProxyConfig
		proxyFactory.copyFrom(this);

		// 看看是否是基于类的代理(CGLIB),若表面上是基于接口的代理  我们还需要进一步去检测
		if (!proxyFactory.isProxyTargetClass()) {
			// shouldProxyTargetClass方法用于判断是否应该使用targetClass类而不是接口来进行代理
			// 默认实现为和该bean定义是否属性值preserveTargetClass为true有关。默认情况下都不会有此属性值的~~~~~
			if (shouldProxyTargetClass(beanClass, beanName)) {
				proxyFactory.setProxyTargetClass(true);
			}
			
			// 到此处,上面说了,就是把这个类实现的接口们,都放进proxyFactory(当然也会处理一些特殊的接口~~~不算数的)
			else {
				evaluateProxyInterfaces(beanClass, proxyFactory);
			}
		}
		
		// buildAdvisors:整理合并得到最终的advisors (毕竟interceptorNames还指定了一些拦截器的)
		// 至于调用的先后顺序,通过applyCommonInterceptorsFirst参数可以进行设置,若applyCommonInterceptorsFirst为true,interceptorNames属性指定的Advisor优先调用。默认为true
		Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
		// 添加进工厂里
		proxyFactory.addAdvisors(advisors);
		// 把targetSource放进去  TargetSource的实现方式有多种 后面会介绍
		proxyFactory.setTargetSource(targetSource);

		// 这个方法是交给子类的,子类可以继续去定制此proxyFactory(Spring内部并没有搭理它)
		customizeProxyFactory(proxyFactory);
		
		// 沿用this得freezeProxy的属性值
		proxyFactory.setFrozen(this.freezeProxy);
		
		// 设置preFiltered的属性值,默认是false。子类:AbstractAdvisorAutoProxyCreator修改为true
		// preFiltered:字段意思为:是否已为特定目标类筛选Advisor
		// 这个字段和DefaultAdvisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice获取所有的Advisor有关
		//CglibAopProxy和JdkDynamicAopProxy都会调用此方法,然后递归执行所有的Advisor的
		if (advisorsPreFiltered()) {
			proxyFactory.setPreFiltered(true);
		}
		
		// getProxyClassLoader():调用者可议指定  否则为:ClassUtils.getDefaultClassLoader()
		return proxyFactory.getProxy(getProxyClassLoader());
	}
}

AbstractAutoProxyCreator的创建步骤就是上面源码分析的,它就相当于一个代理创建的模版,规定了一些步骤。获取Advisor的getAdvicesAndAdvisorsForBean由各子类自己去实现~~~

接下来主要是根据对方法getAdvicesAndAdvisorsForBean()的实现不一样,策略也就有两种了。它有两个直接实现:BeanNameAutoProxyCreator和AbstractAdvisorAutoProxyCreator。

三、AbstractAutoProxyCreator子类
3.1 BeanNameAutoProxyCreator

顾名思义,它和Advisor无关,只和BeanName有关(只有名字匹配上了,都会给创建一个代理类)
所以我认为它是个半自动的,哪些需要创建代理,还需要我们自己指定(虽然支持*通配符)

public class BeanNameAutoProxyCreator extends AbstractAutoProxyCreator {

	@Nullable
	private List<String> beanNames;


	//设置应该用代理自动包装的bean的名称
	public void setBeanNames(String... beanNames) {
		Assert.notEmpty(beanNames, "'beanNames' must not be empty");
		this.beanNames = new ArrayList<>(beanNames.length);
		for (String mappedName : beanNames) {
			this.beanNames.add(StringUtils.trimWhitespace(mappedName));
		}
	}


	// 这里面注意一点:BeanNameAutoProxyCreator的此方法并没有去寻找Advisor,所以需要拦截的话
	// 只能依靠:setInterceptorNames()来指定拦截器。它是根据名字去Bean容器里取的
	protected Object[] getAdvicesAndAdvisorsForBean(
			Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {

		if (this.beanNames != null) {
			for (String mappedName : this.beanNames) {
				if (FactoryBean.class.isAssignableFrom(beanClass)) {
					if (!mappedName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
						continue;
					}
					mappedName = mappedName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
				}
				if (isMatch(beanName, mappedName)) {
					return PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS;
				}
				BeanFactory beanFactory = getBeanFactory();
				if (beanFactory != null) {
					String[] aliases = beanFactory.getAliases(beanName);
					for (String alias : aliases) {
						if (isMatch(alias, mappedName)) {
							return PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS;
						}
					}
				}
			}
		}
		return DO_NOT_PROXY;
	}

	//simpleMatch并不是完整的正则。但是支持*这种通配符,其余的不支持哦
	protected boolean isMatch(String beanName, String mappedName) {
		return PatternMatchUtils.simpleMatch(mappedName, beanName);
	}

}

案例

@Component
public class HelloService {
	public void hello() {
		System.out.println("调用hello方法...");
	}
}

@Component
public class MyAspect implements MethodBeforeAdvice {
	@Override
	public void before(Method method, Object[] args, Object target) throws Throwable {
		System.out.println("before");
	}
}


@ComponentScan(value = {"aop"})
@Configuration
//@EnableAspectJAutoProxy
public class RootConfig {

	@Bean
	public BeanNameAutoProxyCreator beanNameAutoProxyCreator() {
		BeanNameAutoProxyCreator beanNameAutoProxyCreator = new BeanNameAutoProxyCreator();
		// 给所有以serviceImpl结尾的类创建代理对象(支持正则)  备注:aliases也是被支持的
		// 注意此处若只写`*Service` 是匹配不上helloServiceImpl
		beanNameAutoProxyCreator.setBeanNames("helloService");
		// 备注:它要想使用拦截,只能通过setInterceptorNames,从容器内拿Advice的实现类(自己书写)
		beanNameAutoProxyCreator.setInterceptorNames("myAspect");
		return beanNameAutoProxyCreator;
	}
}

public class App {
	public static void main( String[] args ) {
		AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(RootConfig.class);
		((HelloService)annotationConfigApplicationContext.getBean("helloService")).hello();


	}
}

程序输出:

 before
调用hello方法...

备注:此时我们采用了BeanNameAutoProxyCreator,自然就不用再@EnableAspectJAutoProxy,自然@Aspect切面也就不生效了。 当然,也可以开启的,这样他俩就联合生效了(但不太建议去这么使用)

另外,如果你想用自己注册的@Bean代替@EnableAspectJAutoProxy默认给你注册的自动创建器,那么你可以注册一个Bean名称如下的Bean即可:

// 手动注册一个自动代理创建器,且名字务必叫AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME
@Bean(AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME) 
public BeanNameAutoProxyCreator beanNameAutoProxyCreator() {
	...
}

特别提醒:首先我强烈不建议这么去做
然后,此处要注意Bean定义信息的加载循序,否则也是不会生效的~~~~~~~~(需要对原理更多的了解吧) 毕竟人家判断是根据Bean的定义信息来判断的:if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {} 而这个就和@Configuration配置文件的加载顺序有关喽(Spring环境下不好控制~)

3.2 AbstractAdvisorAutoProxyCreator

AbstractAdvisorAutoProxyCreator 这是另一类自动代理方式
它是Spring2.0提供的(2.0版本2006年才发布哦~~~)
顾名思义,它和Advisor有关(只有被切入的类,才会给它创建一个代理类),它的核心方法是实现了父类的:getAdvicesAndAdvisorsForBean来获取Advisor们

public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator {

	// 这个类是重点,后面会详细介绍
	@Nullable
	private BeanFactoryAdvisorRetrievalHelper advisorRetrievalHelper;

	// 重写了setBeanFactory方法,事需要保证bean工厂必须是ConfigurableListableBeanFactory
	@Override
	public void setBeanFactory(BeanFactory beanFactory) {
		super.setBeanFactory(beanFactory);
		if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
			throw new IllegalArgumentException(
					"AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
		}
		// 就这一句话:this.advisorRetrievalHelper = new BeanFactoryAdvisorRetrievalHelperAdapter(beanFactory)
		// 对Helper进行初始化,找advisor最终事委托给他了的
		// BeanFactoryAdvisorRetrievalHelperAdapter继承自BeanFactoryAdvisorRetrievalHelper,为私有内部类,主要重写了isEligibleBean()方法,调用.this.isEligibleAdvisorBean(beanName)方法
		initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
	}

	// 这是复写父类的方法,也是实现代理方式。找到作用在这个Bean里面的切点方法
	// 当然 最终最终事委托给BeanFactoryAdvisorRetrievalHelper去做的
	@Override
	@Nullable
	protected Object[] getAdvicesAndAdvisorsForBean(
			Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
		
		// findEligibleAdvisors:显然这个是具体的实现方法了。
		// eligible:合格的  合适的
		List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
		if (advisors.isEmpty()) {
			return DO_NOT_PROXY;
		}
		return advisors.toArray();
	}
	
	// 找出合适的Advisor们~~~  主要分了下面几步
	protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
		
		// 首先找出所有的候选的Advisors,(根据名字判断)实现见下面~~~~
		List<Advisor> candidateAdvisors = findCandidateAdvisors();
		// 对上面找到的候选的Advisors们,进行过滤操作~~~  看看Advisor能否被用在Bean上(根据Advisor的PointCut判断)
		// 主要依赖于AopUtils.findAdvisorsThatCanApply()方法  在工具类讲解中有详细分析的
		// 逻辑简单概述为:看目标类是不是符合代理对象的条件,如果符合就把Advisor加到集合中,最后返回集合
		// 简单的说:它就是会根据ClassFilter和MethodMatcher等等各种匹配。(但凡只有有一个方法被匹配上了,就会给他创建代理类了)
		// 方法用的ReflectionUtils.getAllDeclaredMethods,**因此哪怕是私有方法,匹配上都会给创建的代理对象,这点务必要特别特别的注意**
		List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
		
		//提供一个钩子。子类可以复写此方法  然后对eligibleAdvisors进行处理(增加/删除/修改等等)
		// AspectJAwareAdvisorAutoProxyCreator提供了实现
		extendAdvisors(eligibleAdvisors);
		
		// 如果最终还有,那就排序吧 
		if (!eligibleAdvisors.isEmpty()) {
			// 默认排序方式:AnnotationAwareOrderComparator.sort()排序  这个排序和Order接口有关~~~
			// 但是子类:AspectJAwareAdvisorAutoProxyCreator有复写此排序方法,需要特别注意~~~
			eligibleAdvisors = sortAdvisors(eligibleAdvisors);
		}
		return eligibleAdvisors;
	}


	// 找到候选的Advisor们~~~~   抽象类自己的实现,是直接把这件事委托给了advisorRetrievalHelper
	// 关于它的具体逻辑  后文问详细分析  毕竟属于核心逻辑
	// AnnotationAwareAspectJAutoProxyCreator对它有复写
	protected List<Advisor> findCandidateAdvisors() {
		Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
		return this.advisorRetrievalHelper.findAdvisorBeans();
	}

	// 判断给定的BeanName这个Bean,是否是合格的(BeanFactoryAdvisorRetrievalHelper里会用到这个属性)
	// 其中:DefaultAdvisorAutoProxyCreator和InfrastructureAdvisorAutoProxyCreator有复写
	protected boolean isEligibleAdvisorBean(String beanName) {
		return true;
	}

	// 此处复写了父类的方法,返回true了,表示
	@Override
	protected boolean advisorsPreFiltered() {
		return true;
	}
}

我们发现这个抽象类主要是提供getAdvicesAndAdvisorsForBean()这个方法的获取模版(虽然它没有提供抽象方法给子类去实现,但子类复写了protected方法,改变了一些默认行为。但是各个实现类都各有不同,现在我们看看实现:)

从简单到复杂,从不用到常用,现在分析分析这些实现类:

3.3 DefaultAdvisorAutoProxyCreator

个比方:它就是BeanNameAutoProxyCreator的加强版。如果说BeanNameAutoProxyCreator就是步枪需要自己装配,DefaultAdvisorAutoProxyCreator就是自动步枪了,Spring可以完成自动匹配的工作了

一般,我们只需要这样配置即可

    @Bean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
        return new DefaultAdvisorAutoProxyCreator();
    }

	// 还需要对应的Advisor(可以有多个~~)  从而给能够匹配上的创建代理对象了
    @Bean
    public NameMatchMethodPointcutAdvisor nameMatchMethodPointcutAdvisor() {
        NameMatchMethodPointcutAdvisor nameMatchMethodPointcutAdvisor = new NameMatchMethodPointcutAdvisor();
        
        //拦截到了HelloService#hello()方法,因此会给他创建代理对象
        nameMatchMethodPointcutAdvisor.addMethodName("*hello");
        
        // 请注意:此处虽然HelloController有个方法名叫helloGet,但是不会创建代理得。因为这在根容器里,这种情况不作用与子容器的Bean的
        nameMatchMethodPointcutAdvisor.addMethodName("helloGet"); 
        nameMatchMethodPointcutAdvisor.setAdvice(new MyMethodInteceptor());
        return nameMatchMethodPointcutAdvisor;
    }

这样它就会自动的去把Advisor匹配上的Bean进行代理掉。(不像BeanNameAutoProxyCreator还得手动指定BeanName,以及拦截器们)

一般都需要自己像容器注入自己的Advisor,比如NameMatchMethodPointcutAdvisor,否则它也不知道去代理谁嘛。只有被对应的Advisor匹配上的才会生成代理对象

它的源码很简单:它也是只复写了一个方法

public class DefaultAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCreator implements BeanNameAware {
	// Consider {@code Advisor} beans with the specified prefix as eligible, if activated.
	// 用到了前缀之类的。主要是考虑可以通过前缀匹配某一类Bean,而其他的Advisor我就不匹配了
	// 前缀的作用:进行分离匹配(而不是拿所有的Advisor~~)
	@Override
	protected boolean isEligibleAdvisorBean(String beanName) {
		if (!isUsePrefix()) {
			return true;
		}
		String prefix = getAdvisorBeanNamePrefix();
		return (prefix != null && beanName.startsWith(prefix));
	}
}
3.4 AspectJAwareAdvisorAutoProxyCreator

顾名思义,该类主要来处理AspectJ切面的。这也是当下最流行,也是功能最为强大的一种方式吧~~~

它对父类,做了如下几点扩展:

// @since 2.0
public class AspectJAwareAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCreator {

	// 默认的排序器,它就不是根据Order来了,而是根据@Afeter @Before类似的标注来排序
	private static final Comparator<Advisor> DEFAULT_PRECEDENCE_COMPARATOR = new AspectJPrecedenceComparator();

	// 核心逻辑:它重写了排序
	// 这个排序和`org.aspectj.util`提供的PartialOrder和PartialComparable有关 具体不详叙了
	// 这块排序算法还是比较复杂的,控制着最终的执行顺序~
	protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
		...
	}

	// 这个就是对已有的Advisor做了一个扩展:
	// AspectJProxyUtils这个工具类只有这一个方法  (其实每次addAspect()的时候,都会调用此方法)
	// Capable:能干的  有才华的
	// 它的作用:(若存在AspectJ的Advice),就会在advisors的第一个位置加入`ExposeInvocationInterceptor.ADVISOR`这个advisor
	@Override
	protected void extendAdvisors(List<Advisor> candidateAdvisors) {
		AspectJProxyUtils.makeAdvisorChainAspectJCapableIfNecessary(candidateAdvisors);
	}

	
	// 这个相当于:
	@Override
	protected boolean shouldSkip(Class<?> beanClass, String beanName) {
		List<Advisor> candidateAdvisors = findCandidateAdvisors();
		
		// 这个相当于AspectJPointcutAdvisor的子类不要拦截、AspectJ切面自己自己的所有方法不要去拦截。。。
		for (Advisor advisor : candidateAdvisors) {
			if (advisor instanceof AspectJPointcutAdvisor &&
					((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
				return true;
			}
		}
		// 父类返回的false
		return super.shouldSkip(beanClass, beanName);
	}
	...
}

ExposeInvocationInterceptor 的作用是用于暴露 MethodInvocation 对象到 ThreadLocal 中,其名字也体现出了这一点。如果其他地方需要当前的 MethodInvocation 对象,直接通过调用静态方法 ExposeInvocationInterceptor.currentInvocation 方法取出。那哪些地方会用到呢?

AspectJExpressionPointcut#matches就有用到~~

3.5 AnnotationAwareAspectJAutoProxyCreator

首先AnnotationAwareAspectJAutoProxyCreator它是AspectJAwareAdvisorAutoProxyCreator的子类。

然后从名字中可议看出,它和注解有关。因此其实我们的@EnableAspectJAutoProxy它导入的就是这个自动代理创建器去帮我们创建和AspectJ相关的代理对象的。这也是我们当下使用最为广泛的方式~

// @since 2.0
public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator {

	@Nullable
	private List<Pattern> includePatterns;
	//唯一实现类:ReflectiveAspectJAdvisorFactory
	// 作用:基于@Aspect时,创建Spring AOP的Advice
	// 里面会对标注这些注解Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class的方法进行排序
	// 然后把他们都变成Advisor( getAdvisors()方法 )
	@Nullable
	private AspectJAdvisorFactory aspectJAdvisorFactory;
	//该工具类用来从bean容器,也就是BeanFactory中获取所有使用了@AspectJ注解的bean
	//就是这个方法:aspectJAdvisorsBuilder.buildAspectJAdvisors()
	@Nullable
	private BeanFactoryAspectJAdvisorsBuilder aspectJAdvisorsBuilder;


	// 很显然,它还支持我们自定义一个正则的模版
	// isEligibleAspectBean()该方法使用此模版,从而决定使用哪些Advisor
	public void setIncludePatterns(List<String> patterns) {
		this.includePatterns = new ArrayList<>(patterns.size());
		for (String patternText : patterns) {
			this.includePatterns.add(Pattern.compile(patternText));
		}
	}
	
	// 可以自己实现一个AspectJAdvisorFactory  否则用默认的ReflectiveAspectJAdvisorFactory
	public void setAspectJAdvisorFactory(AspectJAdvisorFactory aspectJAdvisorFactory) {
		Assert.notNull(aspectJAdvisorFactory, "AspectJAdvisorFactory must not be null");
		this.aspectJAdvisorFactory = aspectJAdvisorFactory;
	}

	// 此处一定要记得调用:super.initBeanFactory(beanFactory);
	@Override
	protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		super.initBeanFactory(beanFactory);
		if (this.aspectJAdvisorFactory == null) {
			this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
		}
		this.aspectJAdvisorsBuilder = new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
	}


	// 拿到所有的候选的advisor们。请注意:这里没有先调用了父类的super.findCandidateAdvisors()  去容器里找出来一些
	// 然后,然后自己又通过aspectJAdvisorsBuilder.buildAspectJAdvisors()  解析@Aspect的方法得到一些Advisor
	@Override
	protected List<Advisor> findCandidateAdvisors() {
		List<Advisor> advisors = super.findCandidateAdvisors();
		if (this.aspectJAdvisorsBuilder != null) {
			advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
		}
		return advisors;
	}
	
	// 加了中类型   如果该Bean自己本身就是一个@Aspect, 那也认为是基础主键,不要切了
	@Override
	protected boolean isInfrastructureClass(Class<?> beanClass) {
		return (super.isInfrastructureClass(beanClass) ||
				(this.aspectJAdvisorFactory != null && this.aspectJAdvisorFactory.isAspect(beanClass)));
	}

	// 拿传入的正则模版进行匹配(没传就返回true,所有的Advisor都会生效)
	protected boolean isEligibleAspectBean(String beanName) {
		if (this.includePatterns == null) {
			return true;
		}
		else {
			for (Pattern pattern : this.includePatterns) {
				if (pattern.matcher(beanName).matches()) {
					return true;
				}
			}
			return false;
		}
	}
	...
}

AspectJAwareAdvisorAutoProxyCreator它用于xml配置版的AspectJ切面自动代理创建(aop:config/)
AnnotationAwareAspectJAutoProxyCreator用于基于注解的自动代理创建(aop:aspectj-autoproxy/ 或 @EnableAspectJAutoProxy)

BeanFactoryAdvisorRetrievalHelper:从Bean工厂检索出Advisor们
这个类很重要,是真正去容器中找出所有的Advisor的类

// @since 2.0.2
public class BeanFactoryAdvisorRetrievalHelper {

	private final ConfigurableListableBeanFactory beanFactory;
	// 本地会做一个简单的字段缓存
	@Nullable
	private String[] cachedAdvisorBeanNames;
	...
	
	// 这里显然就是核心方法了
	public List<Advisor> findAdvisorBeans() {
		String[] advisorNames = null;
		
		synchronized (this) {
			advisorNames = this.cachedAdvisorBeanNames;
			if (advisorNames == null) {
				// 这里不会实例化FactoryBeans
				// 我们需要保留所有常规bean未初始化以允许自动代理创建者应用于它们
				// 注意此处:连祖先容器里面的Bean都会拿出来  (这个方法平时我们也可以使用)
				advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
						this.beanFactory, Advisor.class, true, false);
				this.cachedAdvisorBeanNames = advisorNames;
			}
		}
		
		// 如果容器里面没有任何的advisor 那就拉倒吧
		if (advisorNames.length == 0) {
			return new LinkedList<>();
		}

		List<Advisor> advisors = new LinkedList<>();
		for (String name : advisorNames) {
			
			// isEligibleBean:表示这个bean是否是合格的,默认是true
			// 但上面书说了InfrastructureAdvisorAutoProxyCreator和DefaultAdvisorAutoProxyCreator都做了对应的复写
			if (isEligibleBean(name)) {
				// 如果当前Bean正在创建中  那好  就啥也不做吧
				if (this.beanFactory.isCurrentlyInCreation(name)) {
					if (logger.isDebugEnabled()) {
						logger.debug("Skipping currently created advisor '" + name + "'");
					}
				}
				// 否则就把这个Advisor加入到List里面,是个合法的
				else {
					try {
						advisors.add(this.beanFactory.getBean(name, Advisor.class));
					}
					catch (BeanCreationException ex) {
						... 
						continue;
					}
				}
			}
		}
		return advisors;
	}
	
	protected boolean isEligibleBean(String beanName) {
		return true;
	}

}

综上,整个Spring AOP中的自动代理创建器就全部介绍完了,相信收货不小吧~~~
不同的实现类都有自己不同的使用场景。但是在注解驱动大行其道的今天,显然AnnotationAwareAspectJAutoProxyCreator这个自动代理创建器是最流行、也是功能最强大、也是最实用的,所以是我们最应该掌握的

总结
总的来说:Spring的知识是个体系,很多都是环环相扣的。学知识和建楼一样,需要从根基开始,否则永远只能是半桶水,容易洒出来

最后,只给使用的时候两个不成熟的小建议吧:

SpringAOP应尽量避免自己创建AutoProxyCreator
避免使用低级别的AOP API

你可能感兴趣的:(Spring-AOP,java,代理模式,spring)