// JDK的动态代理是基于接口的，故只能代理接口中定义的方法。

// 该类需要通过代理工厂，具体为继承了AdvisedSupport的代理工厂来创建，而不是直接创建，

// 因为AdvisedSupport提供了AOP的相关配置信息，如Advisors列表等。

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {

    ...

    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 {

            ...

            Object retVal;

            if (this.advised.exposeProxy) {

                // Make invocation available if necessary.

                oldProxy = AopContext.setCurrentProxy(proxy);

                setProxyContext = true;

            }

            // Get as late as possible to minimize the time we "own" the target,

            // in case it comes from a pool.

            target = targetSource.getTarget();

            Class<?> targetClass = (target != null ? target.getClass() : null);

            // 获取该方法对应的方法拦截器列表

            // 实现：通过该方法所在类对应的Advisors，获取该方法的辅助功能Advices列表，即方法拦截器列表。这里的实现为懒加载，

            // 即当方法第一次调用的时候才创建该方法拦截器列表，然后使用一个ConcurrentHashMap缓存起来，之后的方法调用直接使用。

            // 其中advised就是该方法的所在bean对应的ProxyFactory对象引用，通过ProxyFactory来创建AopProxy，即当前类对象实例。

            // Get the interception chain for this method.

            List<Object> 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.

                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);

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

            }

            else {

                // 如果当前方法包括方法拦截器，即在执行时需要其他额外的辅助功能，则创建ReflectiveMethodInvocation

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

                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;

        }

        ...

    }

    ...

}

// 基于类的代理，具体实现为通过创建目标类的子类来实现代理，即代理对象对应的类为目标类的子类。

// 所以目标类的需要被代理的方法不能为final，因为子类无法重写final的方法；同时被代理的方法需要是public或者protected，不能是static，private或者包可见，即不加可见修饰符。

// 如在事务中，@Transactional注解不能对private，static，final，包可见的方法添加事务功能，只能为public方法。

// 这个代理对象也需要通过代理工厂来创建，具体为继承了AdvisedSupport的代理工厂来创建，而不是直接创建。

@SuppressWarnings("serial")

class CglibAopProxy implements AopProxy, Serializable {

    ...

    // 创建代理对象

    public Object getProxy(@Nullable ClassLoader classLoader) {

            ...

            Class<?> rootClass = this.advised.getTargetClass();

            Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");

            Class<?> proxySuperClass = rootClass;

            if (ClassUtils.isCglibProxyClass(rootClass)) {

                proxySuperClass = rootClass.getSuperclass();

                Class<?>[] additionalInterfaces = rootClass.getInterfaces();

                for (Class<?> additionalInterface : additionalInterfaces) {

                    this.advised.addInterface(additionalInterface);

                }

            }

            // Validate the class, writing log messages as necessary.

            validateClassIfNecessary(proxySuperClass, classLoader);

            // 创建目标类的子类来实现代理，即织入辅助功能

            // Configure CGLIB Enhancer...

            Enhancer enhancer = createEnhancer();

            if (classLoader != null) {

                enhancer.setClassLoader(classLoader);

                if (classLoader instanceof SmartClassLoader &&

                        ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {

                    enhancer.setUseCache(false);

                }

            }

            enhancer.setSuperclass(proxySuperClass);

            enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));

            enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);

            enhancer.setStrategy(new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));

            Callback[] callbacks = getCallbacks(rootClass);

            Class<?>[] types = new Class<?>[callbacks.length];

            for (int x = 0; x < types.length; x++) {

                types[x] = callbacks[x].getClass();

            }

            // fixedInterceptorMap only populated at this point, after getCallbacks call above

            enhancer.setCallbackFilter(new ProxyCallbackFilter(

                    this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));

            enhancer.setCallbackTypes(types);

            // 创建代理对象

            // Generate the proxy class and create a proxy instance.

            return createProxyClassAndInstance(enhancer, callbacks);

        }

        ...

    }

    ...

}