Spring AOP --JDK动态代理方式

我们知道Spring是通过JDK或者CGLib实现动态代理的,今天我们讨论一下JDK实现动态代理的原理。

一、简述

Spring在解析Bean的定义之后会将Bean的定义生成一个BeanDefinition对象并且由BeanDefinitionHolder对象持有。在这个过程中,如果Bean需要被通知切入,BeanDefinition会被重新转换成一个proxyDefinition(其实也是一个BeanDefinition对象,只不过描述的是一个ProxyFactoryBean)。ProxyFactoryBean是一个实现了FactoryBean的接口,用来生成被被切入的对象。Spring AOP的实现基本上是通过ProxyFactoryBean实现的。我们今天讨论的重点也是这个类。

在讨论ProxyFactoryBean之前,我们先看一下一个BeanDefinition转换成proxyDefintion的过程。

public final BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definitionHolder, ParserContext parserContext) {

BeanDefinitionRegistry registry = parserContext.getRegistry();

// get the root bean name - will be the name of the generated proxy factory bean

String existingBeanName = definitionHolder.getBeanName();

BeanDefinition targetDefinition = definitionHolder.getBeanDefinition();

BeanDefinitionHolder targetHolder = new BeanDefinitionHolder(targetDefinition, existingBeanName + ".TARGET");

// delegate to subclass for interceptor definition

BeanDefinition interceptorDefinition = createInterceptorDefinition(node);

// generate name and register the interceptor

String interceptorName = existingBeanName + "." + getInterceptorNameSuffix(interceptorDefinition);

BeanDefinitionReaderUtils.registerBeanDefinition(

new BeanDefinitionHolder(interceptorDefinition, interceptorName), registry);

BeanDefinitionHolder result = definitionHolder;

if (!isProxyFactoryBeanDefinition(targetDefinition)) {

// create the proxy definition 这里创建proxyDefinition对象,并且从原来的BeanDefinition对象中复制属性

RootBeanDefinition proxyDefinition = new RootBeanDefinition();

// create proxy factory bean definition

proxyDefinition.setBeanClass(ProxyFactoryBean.class);

proxyDefinition.setScope(targetDefinition.getScope());

proxyDefinition.setLazyInit(targetDefinition.isLazyInit());

// set the target

proxyDefinition.setDecoratedDefinition(targetHolder);

proxyDefinition.getPropertyValues().add("target", targetHolder);

// create the interceptor names list

proxyDefinition.getPropertyValues().add("interceptorNames", new ManagedList());

// copy autowire settings from original bean definition.

proxyDefinition.setAutowireCandidate(targetDefinition.isAutowireCandidate());

proxyDefinition.setPrimary(targetDefinition.isPrimary());

if (targetDefinition instanceof AbstractBeanDefinition) {

proxyDefinition.copyQualifiersFrom((AbstractBeanDefinition) targetDefinition);

}

// wrap it in a BeanDefinitionHolder with bean name

result = new BeanDefinitionHolder(proxyDefinition, existingBeanName);

}

addInterceptorNameToList(interceptorName, result.getBeanDefinition());

return result;

}

Spring AOP --JDK动态代理方式_第1张图片

Java

二、ProxyFactoryBean的原理

我们先来看一下ProxyFactoryBean的继承关系:

ProxyFactoryBean类图

ProxyFactoryBean实现了FactoryBean、BeanClassLoaderAware、BeanFactoryAware接口,这里就不多说了。ProxyCreatorSupport这个类则是创建代理对象的关键所在。  我们先来看看产生代理对象的方法:

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();

}

}

initializeAdvisorChain() 方法是将通知链实例化。然后判断对象是否要生成单例而选择调用不同的方法,这里我们只看生成单例对象的方法。

private synchronized Object getSingletonInstance() {

if (this.singletonInstance == null) {

this.targetSource = freshTargetSource();

//如果以接口的方式代理对象

if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {

// Rely on AOP infrastructure to tell us what interfaces to proxy.

Class targetClass = getTargetClass();

if (targetClass == null) {

throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");

}

//获取目标类实现的所有接口,并注册给父类的interfaces属性,为jdk动态代理做准备

setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));

}

// Initialize the shared singleton instance.

super.setFrozen(this.freezeProxy);

//这里产生代理对象

this.singletonInstance = getProxy(createAopProxy());

}

return this.singletonInstance;

}

我们可以看到,产生代理对象是通过getProxy()方法实现的,这个方法我们看一下:

protected Object getProxy(AopProxy aopProxy) {

return aopProxy.getProxy(this.proxyClassLoader);

}

AopProxy对象的getProxy()方法产生我们需要的代理对象,究竟AopProxy这个类是什么,我们接下来先看一下产生这个对象的方法createAopProxy():

protected final synchronized AopProxy createAopProxy() {

if (!this.active) {

activate();

}

return getAopProxyFactory().createAopProxy(this);

}

createAopProxy方法:

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {

//目标对象不是接口类的实现或者没有提供代理接口

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()) {

return new JdkDynamicAopProxy(config);

}

return new ObjenesisCglibAopProxy(config);

}

else {

return new JdkDynamicAopProxy(config);

}

}

Spring AOP --JDK动态代理方式_第2张图片

Java

在这里我们只看JdkDynamicAopProxy这个类的实现,我们前面提到,真正代理对象的生成是由AopProxy的getProxy方法完成的,这里我们看一下JdkDynamicAopProxy的getProxy方法,这也是本文讨论的重点:

public Object getProxy(ClassLoader classLoader) {

if (logger.isDebugEnabled()) {

logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());

}

Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);

findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);

return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);

}

我们看可以很清楚的看到,代理对象的生成直接使用了jdk动态代理:Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);而代理逻辑是通过实现了InvocationHandler接口的invoke方法实现的。而这里用到的实现了InvocationHandler接口的类就是JdkDynamicAopProxy自身。JdkDynamicAopProxy自身实现了InvocationHandler接口,完成了Spring AOP拦截器链拦截等一系列逻辑,我们看一下JdkDynamicAopProxy的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;

Class targetClass = null;

Object target = null;

try {

//没有重写equals方法

if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {

// The target does not implement the equals(Object) method itself.

return equals(args[0]);

}

//没有重写hashCode方法

if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {

// The target does not implement the hashCode() method itself.

return hashCode();

}

//代理的类是Advised,这里直接执行,不做任何代理

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;

}

// May be null. Get as late as possible to minimize the time we "own" the target,

// in case it comes from a pool.

//获得代理对象

target = targetSource.getTarget();

if (target != null) {

targetClass = target.getClass();

}

// Get the interception chain for this method.

//获得已经定义的拦截器链

List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

// Check whether we have any advice. If we don't, we can fallback on direct

// reflective invocation of the target, and avoid creating a MethodInvocation.

if (chain.isEmpty()) {

// We can skip creating a MethodInvocation: just invoke the target directly

// Note that the final invoker must be an InvokerInterceptor so we know it does

// nothing but a reflective operation on the target, and no hot swapping or fancy proxying.

//拦截器链是空的,直接执行需要代理的方法

retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);

}

else {

// We need to create a method invocation...

//这里是调用拦截器链的地方,先创建一个MethodInvocation对象,然后调用该对象的proceed方法完成拦截器链调用

Spring AOP --JDK动态代理方式_第3张图片

Java

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.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);

}

}

}

拦截器链的调用

从上面的代码和注释中我们可以看到spring实现aop的主要流程,具体如何调用拦截器链,我们来看一下MethodInvocation的proceed方法

public Object proceed() throws Throwable {

// We start with an index of -1 and increment early.

// currentInterceptorIndex是从-1开始的,所以拦截器链调用结束的时候index是 this.interceptorsAndDynamicMethodMatchers.size() - 1

// 调用链结束后执行目标方法

if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {

return invokeJoinpoint();

}

// 获得当前处理到的拦截器

Object interceptorOrInterceptionAdvice =

this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);

// 这里判断是否是InterceptorAndDynamicMethodMatcher,如果是,这要判断是否匹配methodMatcher,不匹配则此拦截器不生效

Spring AOP --JDK动态代理方式_第4张图片

Java

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 {

// It's an interceptor, so we just invoke it: The pointcut will have

// been evaluated statically before this object was constructed.

return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);

}

}

proceed()方法是一个递归方法,我们可以根据代码的注释知道大体逻辑,InterceptorAndDynamicMethodMatcher的代码如下,我们可以看到,InterceptorAndDynamicMethodMatcher 持有一个MethodInterceptor 对象和一个MethodMatcher 对象,在拦截器链调用过程中,如果拦截器是InterceptorAndDynamicMethodMatcher ,则会先根据MethodMatcher 判断是否匹配,匹配MethodInterceptor 才会生效。

class InterceptorAndDynamicMethodMatcher {

final MethodInterceptor interceptor;

final MethodMatcher methodMatcher;

public InterceptorAndDynamicMethodMatcher(MethodInterceptor interceptor, MethodMatcher methodMatcher) {

this.interceptor = interceptor;

this.methodMatcher = methodMatcher;

}

}

Spring AOP --JDK动态代理方式_第5张图片

Java

至于MethodInterceptor 是什么,MethodInterceptor 的逻辑是怎么样的,我们可以看一下MethodInterceptor 的一个子类AfterReturningAdviceInterceptor的实现:

public class AfterReturningAdviceInterceptor implements MethodInterceptor, AfterAdvice, Serializable { private final AfterReturningAdvice advice; /** * Create a new AfterReturningAdviceInterceptor for the given advice. * @param advice the AfterReturningAdvice to wrap */ public AfterReturningAdviceInterceptor(AfterReturningAdvice advice) { Assert.notNull(advice, "Advice must not be null"); this.advice = advice; } @Override public Object invoke(MethodInvocation mi) throws Throwable { Object retVal = mi.proceed(); this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis()); return retVal; }}

AfterReturningAdviceInterceptor的作用是在被代理的方法返回结果之后添加我们需要的处理逻辑,其实现方式我们可以看到,先调用MethodInvocation 的proceed,也就是先继续处理拦截器链,等调用完成后执行我们需要的逻辑:this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());

到这里,spring使用jdk动态代理实现aop的分析基本上结束,其中拦截器链的调用比较难懂而且比较重要,需要的同学可以多看看这一块。

在程序员这条路上遇到瓶颈的朋友可以加入群:686579014 大家一起来提升进步 但要备注好信息哦! 有Java高级大牛直播讲解知识点,分享知识,都是各位老师多年工作经验的梳理和总结,带着大家全面、科学地建立自己的技术体系和技术认知

阶段一:工程化技术-提升效率 才能有更多的时间来思考

阶段二:源码分析-成为一个内功深厚的程序员

阶段三:高性能 分布式 高可用-进入互联网公司不再是你的难题

阶段四:性能调优-我不甘心只做一个程序员 我还有更高的成就

阶段五:项目实战-理论与时间实践相结合 你离梦想的距离只学要你点起脚尖

你可能感兴趣的:(Java)