springAOP之framework包的解读(四)

类JdkDynamicAopProxy

package org.springframework.aop.framework;

import java.io.Serializable;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.List;

import org.aopalliance.intercept.MethodInvocation;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.aop.AopInvocationException;
import org.springframework.aop.RawTargetAccess;
import org.springframework.aop.TargetSource;
import org.springframework.aop.support.AopUtils;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;

/**
 * springAOP框架的基于JDK的AopProxy实现
 * 创建一个动态代理，实现AopProxy暴露的接口。动态代理不能用于代理方法，这些方法在类中定义，而不是在接口定义
 * 该类型的对象必须通过代理工厂获取，根据AdvisedSupport进行配置。
 * 该类是springAOP框架的内部类，不能直接供客户端代码使用。
 * 如果目标类是线程安全，那用该类创建的代理也是线程安全的。
 * 只要顾问(包括通知和切入点)和目标源是序列化的，这些代理也是序列化的
 */
final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {

    /** use serialVersionUID from Spring 1.2 for interoperability */
    private static final long serialVersionUID = 5531744639992436476L;


    /*
     * 我们可以避免该类与CGLIB代理之前的代码复制，通过重构"invoke"为一个模板方法。
     * 但这个方法增加了至少10%的性能开销，相对于复制粘贴的解决方案，因此我们为了性能牺牲简洁。
     * (我们有一个很好的测试套件确保不同的代理表现相同的行为)
     * 用这个方法，我们可以更简单地利用最小的优化，在每一个类中。
     */

    /** We use a static Log to avoid serialization issues */
    private static final Log logger = LogFactory.getLog(JdkDynamicAopProxy.class);

    /** 代理配置 */
    private final AdvisedSupport advised;

    /**
     * 代理接口是否定义了equals方法?
     */
    private boolean equalsDefined;

    /**
     * 代理接口是否定义了hashCode方法?
     */
    private boolean hashCodeDefined;


    /**
     * 构造一个新的JdkDynamicAopProxy，根据给定的AOP配置。
     * @param config AdvisedSupport配置类
     * @throws AopConfigException 如果配置是失效的，我们抛出一个有相关信息的异常，而不是一个未知的失败
     */
    public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
        Assert.notNull(config, "AdvisedSupport must not be null");
        if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
            throw new AopConfigException("No advisors and no TargetSource specified");
        }
        this.advised = config;
    }


    @Override
    public Object getProxy() {
        return getProxy(ClassUtils.getDefaultClassLoader());
    }

    @Override
    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);
    }

    /**
     * 在提供的接口中查找已定义的equals或hashCode方法
     * @param proxiedInterfaces 查找的接口
     */
    private void findDefinedEqualsAndHashCodeMethods(Class[] proxiedInterfaces) {
        for (Class proxiedInterface : proxiedInterfaces) {
            Method[] methods = proxiedInterface.getDeclaredMethods();
            for (Method method : methods) {
                if (AopUtils.isEqualsMethod(method)) {
                    this.equalsDefined = true;
                }
                if (AopUtils.isHashCodeMethod(method)) {
                    this.hashCodeDefined = true;
                }
                if (this.equalsDefined && this.hashCodeDefined) {
                    return;
                }
            }
        }
    }


    /**
     * InvocationHandler.invoke的实现。调用者将会看到由目标对象抛出明确的异常，除非一个锚定的方法抛出异常。
     */
    @Override
    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 {
            if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
                // The target does not implement the equals(Object) method itself.
                return equals(args[0]);
            }
            if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                // The target does not implement the hashCode() method itself.
                return hashCode();
            }
            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