Spring AOP原理分析

·  阅读 609

在分析Spring AOP之前,需要先理解AOP的术语,并理解它们代表的含义:

  • Advice:切面,切面是一个横切关注点的模块化,比如事务管理,日志处理是两个切面

  • JoinPoint:连接点,在Spring AOP中一个连接点总是代表一个方法的执行,其实AOP拦截的方法就是一个连接点

  • Advise:通知,在切面的某个连接点上执行的动作,通知类型包括“before”、“after”、“around”等。通知是指一个方法被AOP拦截到的时候要执行的代码

  • PointCut:切入点,切入点是对连接点进行拦截的条件定义

  • Target:目标对象,将要被增强的对象

  • Weaving:织入,织入是将切面和业务逻辑对象连接起来, 并创建通知代理的过程。织入可以在编译时,类加载时和运行时完成。在编译时进行织入就是静态代理,而在运行时进行织入则是动态代理

我相信,上面的描述,是足够清晰的。我们要搞清楚的一点是,上面的这些,最终目的就是为了找到某些方法,然后为这些方法生成代理类,并把方法的执行委托给代理类,让代理类在方法执行时机,执行其他动作,比如打日志,为方法启动事务等

看源码的目的不是为了面面俱到的了解框架,而是了解其主线设计,所以我们对Spring AOP这篇文章,也不会讲很多细节,而是把主线讲清楚,就达到目的了

下面将从ConcurrencyThrottleInterceptorTests测试类入手

有时候,我觉得从测试类作为入口,去了解代码,是个不错的突破点

testSerializable

先看一下testSerializable单测方法

@Test
public void testSerializable() throws Exception {
	// DerivedTestBean继承TestBean,TestBean有个age属性
	DerivedTestBean tb = new DerivedTestBean();
	// 代理类工厂
	ProxyFactory proxyFactory = new ProxyFactory();
	proxyFactory.setInterfaces(ITestBean.class);
	// 拦截器
	ConcurrencyThrottleInterceptor cti = new ConcurrencyThrottleInterceptor();
	// 添加切面,而这个切面就是ConcurrencyThrottleInterceptor拦截器
	proxyFactory.addAdvice(cti);
	// 添加目标类
	proxyFactory.setTarget(tb);
	// 生成代理类
	ITestBean proxy = (ITestBean) proxyFactory.getProxy();
	// 执行代理类方法
	proxy.getAge();

	// 省略
}
复制代码

整个流程挺清晰,由代理类工厂生成代理类,并为代理类工厂配置切面和目标类。这里可能会有个疑问,拦截器和切面有什么关系?

image.png

从这个继承图可以看到,MethodInterceptor继承了Advice,从这个角度来说,拦截器就是切面,另外还有其他的切面,比如AfterReturningAdvice,在方法返回后执行

ProxyFactory

image.png

ProxyFactory继承ProxyCreatorSupport,ProxyCreatorSupport是代理类工厂的基类,为访问AopProxyFactory提供了方便的操作,其内部也持有AopProxyFactory实例

比如最常用的getProxy()方法,就是创建通过AopProxyFactory返回代理类,而这个动作就在ProxyCreatorSupport的createAopProxy()方法里。

protected final synchronized AopProxy createAopProxy() {
	// 判断Spring AOP是否已被创建,如果未创建过,则设置为true
	if (!this.active) {
		activate();
	}
	// 这里创建AopProxyFactory实例,并返回AopProxy代理类
	return getAopProxyFactory().createAopProxy(this);
}
复制代码

DefaultAopProxyFactory

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
	// 	两种AopProxy,接口就返回JdkDynamicAopProxy,类就返回ObjenesisCglibAopProxy
	if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
		Class<?> targetClass = config.getTargetClass();
		if (targetClass == null) {
			throw new AopConfigException("TargetSource cannot determine target class: " +
					"Either an interface or a target is required for proxy creation.");
		}
		if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
			return new JdkDynamicAopProxy(config);
		}
		return new ObjenesisCglibAopProxy(config);
	}
	else {
		return new JdkDynamicAopProxy(config);
	}
}
复制代码

从名字可以看出ObjenesisCglibAopProxy是通过cglib生成的AopProxy,JdkDynamicAopProxy是通过jdk的动态代理生成AopProxy,这里我们看JdkDynamicAopProxy就行了

JdkDynamicAopProxy

JdkDynamicAopProxy实现了AopProxy接口,和InvocationHandler接口,用来创建动态代理类。我们知道在ProxyFactory的getProxy()方法,调用的就是JdkDynamicAopProxy的getProxy(),这个方法就是通过JDK Proxy的newProxyInstance创建代理类,如果直观一点看的话,是下面这样的

public Object getProxy(@Nullable ClassLoader classLoader) {
	if (logger.isDebugEnabled()) {
		logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
	}
	Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
	findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
	return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}
复制代码

image.png

生成的动态代理类类名是$Proxy20@1991,因为Proxy.newProxyInstance传的InvocationHandler是this,也就是JdkDynamicAopProxy自身,所以h是JdkDynamicAopProxy实例。从上面的代码还知道,我们要代理的目标类,是来自于AdvisedSupport配置,AdvisedSupport继承ProxyConfig,关于这些配置,不是关注的重点,所以跳过......

到这里,代理类已经生成了,接下来就是调用代理类的方法了,在单测里,是proxy.getAge(),会被代理到JdkDyn-amicAopProxy的invoke()

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	MethodInvocation invocation;
	Object oldProxy = null;
	boolean setProxyContext = false;

	TargetSource targetSource = this.advised.targetSource;
	// 目标类
	Object target = null;

	try {
		if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
			// The target does not implement the equals(Object) method itself.
			return equals(args[0]);
		}
		else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
			// The target does not implement the hashCode() method itself.
			return hashCode();
		}
		else if (method.getDeclaringClass() == DecoratingProxy.class) {
			// There is only getDecoratedClass() declared -> dispatch to proxy config.
			return AopProxyUtils.ultimateTargetClass(this.advised);
		}
		else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
				method.getDeclaringClass().isAssignableFrom(Advised.class)) {
			// Service invocations on ProxyConfig with the proxy config...
			return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
		}
		// 返回值
		Object retVal;

		if (this.advised.exposeProxy) {
			// Make invocation available if necessary.
			oldProxy = AopContext.setCurrentProxy(proxy);
			setProxyContext = true;
		}
		// 从TargetSource的对象池中获取目标类
		target = targetSource.getTarget();
		Class<?> targetClass = (target != null ? target.getClass() : null);

		// 获取拦截器链
		List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

		if (chain.isEmpty()) {
			// 如果拦截器链为空,就直接执行方法
			Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
			retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
		}
		else {
			// 如果拦截器链不为空,就通过MethodInvocation来执行目标方法和拦截器链
			invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
			// Proceed to the joinpoint through the interceptor chain.
			retVal = invocation.proceed();
		}

		// Massage return value if necessary.
		Class<?> returnType = method.getReturnType();
		if (retVal != null && retVal == target &&
				returnType != Object.class && returnType.isInstance(proxy) &&
				!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
			// Special case: it returned "this" and the return type of the method
			// is type-compatible. Note that we can't help if the target sets
			// a reference to itself in another returned object.
			retVal = proxy;
		}
		else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
			throw new AopInvocationException(
					"Null return value from advice does not match primitive return type for: " + method);
		}
		return retVal;
	}
	finally {
		if (target != null && !targetSource.isStatic()) {
			// Must have come from TargetSource.
			targetSource.releaseTarget(target);
		}
		if (setProxyContext) {
			// Restore old proxy.
			AopContext.setCurrentProxy(oldProxy);
		}
	}
}
复制代码

这里关键是获取拦截器链,因为拦截器里包装了我们想要的增强的功能

public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable Class<?> targetClass) {
	// 先从缓存获取
	MethodCacheKey cacheKey = new MethodCacheKey(method);
	List<Object> cached = this.methodCache.get(cacheKey);
	if (cached == null) {
		// 通过AdvisorChainFactory获取拦截器链,然后再放在缓存
		cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
				this, method, targetClass);
		this.methodCache.put(cacheKey, cached);
	}
	return cached;
}
复制代码

因为我们设置拦截器只有ConcurrencyThrottleInterceptor对象,所以这里返回的就是只有一个元素的list,而这个元素就是ConcurrencyThrottleInterceptor对象。

我们再看ReflectiveMethodInvocation,最终是执行它的proceed(),ReflectiveMethodInvocation其实是个中间桥梁,粘接了target方法和拦截器方法,我们看一下proceed()

public Object proceed() throws Throwable {
	//	如果拦截器链方法都执行完,就执行invokeJoinpoint()
	if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
		return invokeJoinpoint();
	}

	// 获取下一个拦截器,从0开始顺序获取
	Object interceptorOrInterceptionAdvice =
			this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
	if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
		// Evaluate dynamic method matcher here: static part will already have
		// been evaluated and found to match.
		InterceptorAndDynamicMethodMatcher dm =
				(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
		if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
			return dm.interceptor.invoke(this);
		}
		else {
			// Dynamic matching failed.
			// Skip this interceptor and invoke the next in the chain.
			return proceed();
		}
	}
	else {
		// 执行拦截器
		return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
	}
}
复制代码

执行拦截器方法,又会继续执行当前方法,以为invoke方法传递的是this对象,所以拦截器执行完后,最终执行的是invokeJoinpoint(),而这个方法也挺简单,调用的是AopUtils.invokeJoinpointUsingReflection()

至此,整个思路已经梳理出来了

但还是有个疑问,就是我们平时使用切面,是由Spring框架启动的,而上面是有单测的ProxyFactory的,那Spring框架又是如何启动AOP的呢,换句话就是,Spring如何扩展AOP?

答案就是FactoryBean,还记得在讲Spring IoC讲过,很多功能的扩展是通过FactoryBean来实现的,Spring AOP也是,具体是通过ProxyFactoryBean来实现的

ProxyFactoryBean

我们直接看getObject()方法

public Object getObject() throws BeansException {
	// 初始化拦截器链
	initializeAdvisorChain();
	if (isSingleton()) {
		// 返回单例代理类
		return getSingletonInstance();
	}
	else {
		if (this.targetName == null) {
			logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +
					"Enable prototype proxies by setting the 'targetName' property.");
		}
		// 返回原型代理类
		return newPrototypeInstance();
	}
}
复制代码

getSingletonInstance()的创建逻辑,就是上面分析的,这里就不再重复了。

总结

Spring AOP的原理就是通过AOP配置生成拦截器链,并为目标方法生成代理类,并把方法的执行委托给代理类,当执行代理类方法时,先触发拦截器链,所有拦截器执行完毕,再执行目标方法。

分类:
后端
标签:
收藏成功!
已添加到「」, 点击更改