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;
}
复制代码
  1. 调用

拿到方法的拦截链,然后调用。调用的时候有个地方比较有意思。它先创建了一个对象 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实现增强。

原文 

https://juejin.im/post/5c7ba93ff265da2d89634b1c

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » Spring源码分析(七)SpringAOP生成代理类及执行的过程

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址