Spring源码分析（七）SpringAOP生成代理类及执行的过程

上一节我们在分析解析AOP标签的时候，第一步就是注册了一个类 AspectJAwareAdvisorAutoProxyCreator ，我们说它是AOP的入口类。为什么这样说呢？ 来看它父类的父类 AbstractAutoProxyCreator ，它继承了BeanPostProcessor接口。 那么，有两个方法肯定要被调用到 postProcessBeforeInitialization、postProcessAfterInitialization 。一个在依赖注入完成之前调用，一个在之后调用。

public Object postProcessAfterInitialization(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) {
	// Create proxy if we have advice.
	//先看它的注释，大意说：如果有通知，就创建代理。
	//其实就是在bean.getClass()找到所有的通知和advisor
	//这里面其实又分为两个步骤:
	//第一，在Bean工厂找到所有的Advisor 第二，根据beanClass和Pointcut去做匹配
	Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
	if (specificInterceptors != DO_NOT_PROXY) {
		this.advisedBeans.put(cacheKey, Boolean.TRUE);
		//真正创建代理并返回，这时候返回的就是代理类了，把真实的bean替换掉
		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;
}
复制代码

看到上面的源码，整个过程就分为了两步，匹配和创建返回。这样就完成了代理类的替换，是不是有点偷梁换柱的感觉。

匹配

先是找到所有的Advisor，这个比较简单。因为我们知道，在解析的时候就把配置的通知封装成advisor注册了进去。首先拿到beanDefinitionNames容器所有beanName，循环判断bean的类型是不是advisor接口的类型，符合条件返回。

public List<Advisor> findAdvisorBeans() {
	// Determine list of advisor bean names, if not cached already.
	String[] advisorNames = null;
	
	//先拿到beanName
	advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
			this.beanFactory, Advisor.class, true, false);
		
	List<Advisor> advisors = new LinkedList<Advisor>();
	for (String name : advisorNames) {
		if (isEligibleBean(name)) {		
			try {
				//再从Bean工厂中拿bean的实例
				advisors.add(this.beanFactory.getBean(name, Advisor.class));
			}
		}
	}
	//返回的advisors就是配置文件中所有的advice和advisor
	return advisors;
}
复制代码

找到advisors并未结束，还要跟pointcut做匹配，看这些advisor符不符合表达式条件。它最终调用到Pointcut的match方法。这个方法嵌套的太深，就不贴代码了，核心思想就是判断class和class对应的method是否与pointcut表达式匹配。

创建代理

经过上面查找匹配后，确定当前的bean确实需要代理，就调用createProxy方法。

• 设置代理工厂

protected Object createProxy(Class<?> beanClass, 
		String beanName, Object[] specificInterceptors, TargetSource targetSource) {
	//创建代理工厂
	ProxyFactory proxyFactory = new ProxyFactory();
	// Copy our properties (proxyTargetClass etc) inherited from ProxyConfig.
	proxyFactory.copyFrom(this);

	//将beanClass上的接口设置到代理工厂
	evaluateProxyInterfaces(beanClass, proxyFactory);
		
	//设置Advisor到代理工厂
	Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
	for (Advisor advisor : advisors) {
		proxyFactory.addAdvisor(advisor);
	}
	//设置目标对象
	proxyFactory.setTargetSource(targetSource);
	return proxyFactory.getProxy(this.proxyClassLoader);
}
复制代码

• 创建

创建代理分为JDK的代理和Cglib的代理，这里我们先关注JDK的代理。getProxy方法就调用到 JdkDynamicAopProxy 类的方法。这个类还实现了InvocationHandler接口，说明它同时还是调用处理程序。即在调用代理类的invoke方法时，实际上就会调用到 JdkDynamicAopProxy.invoke() 。

public Object getProxy(ClassLoader classLoader) {
	//这里又给代理工厂加了两个接口 SpringProxy和Advised
	Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
	
	//这个方法就比较熟悉了，正是JDK动态代理的方法
	//这里的this就是JdkDynamicAopProxy实例。
	return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}
复制代码

2、代理类的调用

在实例化Bean和完成依赖注入后，会判断当前的Bean是否需要代理，如果需要，就生成代理类把原始类替换掉。在业务方法里面调用的时候，就会调用到 JdkDynamicAopProxy.invoke() 。

在执行invoke的时候，我们又可以分为两个步骤...-_-||，是不是跟二很有缘，每次都是两个步骤。。

1. 获取方法的拦截链

首先从代理工厂中拿到所有的advisor，然后判断是不是PointcutAdvisor类型，其次先matches一下targetClass，再matches一下method，证明这个类的方法在pointcut范围内，加入interceptorList，最后返回。

public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
			Advised config, Method method, Class<?> targetClass) {
	List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);
	//config就是代理工厂的实例
	for (Advisor advisor : config.getAdvisors()) {
		if (advisor instanceof PointcutAdvisor) {
			PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
			if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(targetClass)) {
				MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
				MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
				if (MethodMatchers.matches(mm, method, targetClass, hasIntroductions)) {
					interceptorList.addAll(Arrays.asList(interceptors));
				}
			}
		}
	}
	return interceptorList;
}
复制代码

2. 调用

拿到方法的拦截链，然后调用。调用的时候有个地方比较有意思。它先创建了一个对象 ReflectiveMethodInvocation 。这个对象有两个参数

currentInterceptorIndex   //当前调用的拦截器的索引,默认值-1
interceptorsAndDynamicMethodMatchers   //拦截器的列表
复制代码

然后看它的调用方法。

public Object proceed() throws Throwable {
	
	//如果俩个变量相等，说明已经调用完了所有的拦截器
	if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
		//执行被代理方法
		return invokeJoinpoint();
	}
	//从-1开始，每次累加1。interceptorOrInterceptionAdvice就是对应的每一个通知
	//比如before、after、after-returning...
	//对应的实例类分别是：
	//MethodBeforeAdviceInterceptor、AspectJAfterAdvice、AfterReturningAdviceInterceptor
	Object interceptorOrInterceptionAdvice =
			this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
			
	
	//在调用具体通知的invoke方法时，把当前对象当参数传了过去。
	//因为在具体的通知执行之后还要回调回来，执行当前对象的proceed().
	//这样就形成了一个通知调用链，当所有的通知执行完毕，调用上面的invokeJoinpoint()
	return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
复制代码

看完它的调用流程，我们还有一个疑问。通知一共有5种类型，前置通知、后置通知、方法返回后通知、环绕通知、异常通知。那么，它是怎么保证调用顺序的呢？ 我们来看两个通知类里面具体的实现。

前置通知

public Object invoke(MethodInvocation mi) throws Throwable {
	//这个比较简单，执行完before就回调
	this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() );
	return mi.proceed();
}
复制代码

后置通知

public Object invoke(MethodInvocation mi) throws Throwable {
	//这个就比较有趣了，它先执行回调
	//通过finally机制再执行自己的通知方法
	try {
		return mi.proceed();
	}
	finally {
		invokeAdviceMethod(getJoinPointMatch(), null, null);
	}
}
复制代码

环绕通知

//环绕通知会调用到切面类的自定义方法
public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
	System.out.println("环绕通知之前");
	//可以自己判断还要不要回调回去。
	//回调回去的话，接着循环调用链
	//如果不再回调，就要看链的顺序了，在它之后的就不再执行
	Object result = joinPoint.proceed();
	System.out.println("环绕通知之后");
	return result;
}
复制代码

3、基于注解的AOP

如果想使用注解AOP，需要开启一个配置。 <aop:aspectj-autoproxy /> 。Spring解析配置标签的时候，调用到 AspectJAutoProxyBeanDefinitionParser.parse() 。 这个方法主要就干了一件事：注册入口类 AnnotationAwareAspectJAutoProxyCreator 。 XML配置方式的AOP，Spring注册的入口类叫做 AspectJAwareAdvisorAutoProxyCreator 。

它们的调用流程是一样的，都是在实例化之后调用爷爷类的 AbstractAutoProxyCreator.postProcessAfterInitialization() 。回忆一下，wrapIfNecessary方法是真正产生代理的地方。它先获取所有的通知并与当前的bean class匹配，如果有，就说明当前的Bean需要代理，则产生代理类。我们知道，在XML配置方式的AOP中，Spring把配置的通知都封装成advisor注册到容器里，所以在获取的时候，直接在Bean工厂中匹配Advisor类型的Bean就行。 但是，在解析注解AOP的时候，我们看到它只是注册了一个入口类而已呀，并没有注册advisor，那么，在这里怎么获取呢？

目光回到查询advisor的方法。

protected List<Advisor> findCandidateAdvisors() {
	// Add all the Spring advisors found according to superclass rules.
	// 这个是查询XML配置方式的advoisor
	List<Advisor> advisors = super.findCandidateAdvisors();
	// Build Advisors for all AspectJ aspects in the bean factory.
	// 这个就是查询注解方式的advisor
	advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
	return advisors;
}
复制代码

在 buildAspectJAdvisors 方法查询advisor的时候，它大致可以分3个步骤。

• 从Bean工厂获取所有的beanName String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Object.class, true, false);

• 循环beanNames，判断bean是否包含Aspect注解

for (String beanName : beanNames) {
	Class<?> beanType = this.beanFactory.getType(beanName);
	if (this.advisorFactory.isAspect(beanType)) {
		aspectNames.add(beanName);
		......
	}
}
复制代码

• 获取Advisors。先拿到Class对象上的所有Method对象，根据Method对象的Annotation类型，返回不同的Advice对象。这个跟XML方式返回的Advice对象是一样的。

switch (aspectJAnnotation.getAnnotationType()) {
	case AtBefore:
		springAdvice = new AspectJMethodBeforeAdvice(candidateAdviceMethod, ajexp, aif);
		break;
	case AtAfter:
		springAdvice = new AspectJAfterAdvice(candidateAdviceMethod, ajexp, aif);
		break;
	case AtAfterReturning:
		springAdvice = new AspectJAfterReturningAdvice(candidateAdviceMethod, ajexp, aif);
		AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
		if (StringUtils.hasText(afterReturningAnnotation.returning())) {
			springAdvice.setReturningName(afterReturningAnnotation.returning());
		}
		break;
	case AtAfterThrowing:
		springAdvice = new AspectJAfterThrowingAdvice(candidateAdviceMethod, ajexp, aif);
		AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
		if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
			springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
		}
		break;
	case AtAround:
		springAdvice = new AspectJAroundAdvice(candidateAdviceMethod, ajexp, aif);
		break;
	case AtPointcut:
		if (logger.isDebugEnabled()) {
			logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
		}
		return null;
	default:
		throw new UnsupportedOperationException(
				"Unsupported advice type on method " + candidateAdviceMethod);
}
复制代码

最后将advice和pointcut封装成InstantiationModelAwarePointcutAdvisorImpl对象返回。返回之后，创建代理类进行替换。

由此看来，注解方式的AOP，是在查询Advisors的时候才去解析并生成的，其他的与XML的配置方式处理流程都是一样的。

4、 总结

本章节我们重点阐述了3个问题。即怎样产生代理类、代理类的执行过程、AnnotationAOP的处理流程。结合本章节和上一章节的内容，可能使我们对Spring AOP的内部处理流程加深了印象。

• 怎样产生代理类？ 通过循环beanNames实例化Bean对象，判断此对象是否与pointcut表达式匹配。如果匹配就根据advice生成不同的advisor对象，然后调用JDK或者CGLIB的方法生成代理类返回。

• 代理类执行 调用JDK或者CGLIB的invoke方法，查询advisor的调用链。链式调用，根据通知类型调用不同的advice实现增强。