jdk动态代理（Spring）

前言

我们知道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;

}

二、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);
 }
 }

在这里我们只看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