【动态代理】从源码实现角度剖析JDK动态代理

桃扇骨 2022-06-12 02:11 229阅读 0赞

相比于静态代理，动态代理避免了开发人员编写各个繁锁的静态代理类，只需简单地指定一组接口及目标类对象就能动态的获得代理对象。动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成，所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。 关于JDK的动态代理，最为人熟知的可能要数spring AOP的实现，默认情况下，Spring AOP的实现对于接口来说就是使用的JDK的动态代理来实现的，而对于类的代理使用CGLIB来实现。

#### **1、[代理模式][Link 1]** ####

使用代理模式必须要让代理类和目标类实现相同的接口，客户端通过代理类来调用目标方法，代理类会将所有的方法调用分派到目标对象上反射执行，还可以在分派过程中添加”前置通知”和后置处理（如在调用目标方法前校验权限，在调用完目标方法后打印日志等）等功能。  
![这里写图片描述][SouthEast]

#### **2、先看看与动态代理紧密关联的Java API** ####

**1）java.lang.reflect.Proxy**  
这是 Java 动态代理机制生成的所有动态代理类的父类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。

Proxy类的静态方法
    // 方法 1: 该方法用于获取指定代理对象所关联的调用处理器 
    static InvocationHandler getInvocationHandler(Object proxy)  
    
    // 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象 
    static Class getProxyClass(ClassLoader loader, Class[] interfaces)  
    
    // 方法 3：该方法用于判断指定类对象是否是一个动态代理类 
    static boolean isProxyClass(Class cl)  
    
    // 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例 
    static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)

**2）java.lang.reflect.InvocationHandler**  
这是调用处理器接口，它自定义了一个 invoke 方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类的代理访问。每次生成动态代理类对象时都要指定一个对应的调用处理器对象。

InvocationHandler的核心方法
    // 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象 
    // 第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行 
    Object invoke(Object proxy, Method method, Object[] args)

**3）java.lang.ClassLoader**  
这是类装载器类，负责将类的字节码装载到 Java 虚拟机（JVM）中并为其定义类对象，然后该类才能被使用。Proxy 静态方法生成动态代理类同样需要通过类装载器来进行装载才能使用，它与普通类的唯一区别就是其字节码是由 JVM 在运行时动态生成的而非预存在于任何一个 .class 文件中。每次生成动态代理类对象时都需要指定一个类装载器对象。

#### **3、使用动态代理的五大步骤** ####

> 1).通过实现InvocationHandler接口来自定义自己的InvocationHandler;  
> 自定义InvocationHandler中有一个目标对象作为变量；一个目标对象作为入参的构造方法；invoke方法；  
> 在动态代理中InvocationHandler是核心，每个代理实例都具有一个关联的InvocationHandler(调用处理程序)。当代理实例调用方法时，将对方法调用进行编码并将其指派到它的InvocationHandler(调用处理程序)的 invoke 方法。所以对代理方法的调用都是通InvocationHadler的invoke来实现中，而invoke方法根据传入的代理对象，方法和参数来决定调用代理的哪个方法。invoke方法签名：invoke（Object Proxy，Method method，Object\[\] args）
> 
> 2).通过Proxy.getProxyClass获得动态代理类
> 
> 3).使用得到的动态代理类通过反射机制获得代理类的构造方法，方法签名为getConstructor(InvocationHandler.class)
> 
> 4).通过构造函数来创建动态代理对象，并将自定义的InvocationHandler实例对象传为参数传入newInstance(…)
> 
> 5).通过代理对象调用目标方法

#### **4、动态代理的使用** ####

**1).分步骤实现动态代理**

public class MyProxy {
        
    
        public interface IHello{
        
            void sayHello();
        }
    
        static class Hello implements IHello{
        
            public void sayHello() {
                System.out.println("Hello world!!");
            }
        }
    
        //自定义InvocationHandler
        static  class HWInvocationHandler implements InvocationHandler{
        
            //目标对象
            private Object target;
            public HWInvocationHandler(Object target){
                this.target = target;
            }
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("------插入前置通知代码-------------");
                //执行相应的目标方法
             //利用反射机制将请求分派给实现类处理。Method的invoke返回Object对象作为方法执行结果
             //因为示例程序没有返回值，所以这里忽略了返回值处理
                Object rs = method.invoke(target,args);
                System.out.println("------插入后置处理代码-------------");
                return rs;
            }
        }
    
        public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetExc    eption, InstantiationException {
            //设置生成$Proxy0的class文件保存到本地(sun.misc.ProxyGenerator是JDK代理生成器，在生成类是会根据参数“sun.misc.ProxyGenerator.saveGeneratedFiles”来决定是否将二进制文件保存到本地文件中)
            System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
            //获取动态代理类
            Class proxyClazz = Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class);
            //获得代理类的构造函数，并传入参数类型InvocationHandler.class
            Constructor constructor = proxyClazz.getConstructor(InvocationHandler.class);
            //通过构造函数来创建动态代理对象，将自定义的InvocationHandler实例传入
            IHello iHello = (IHello) constructor.newInstance(new HWInvocationHandler(new Hello()));
            //通过代理对象调用目标方法
            iHello.sayHello();
        }
    }

输出：
    ------插入前置通知代码-------------
    Hello world!!
    ------插入后置处理代码-------------

**2).简化后的动态代理实现**

Proxy类中还有个将2~4步骤封装好的简便方法来创建动态代理对象，其方法签名为：

newProxyInstance(ClassLoader loader,Class<?>[] instance, InvocationHandler h)

public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
           //生成$Proxy0的class文件
           System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
           IHello  ihello = (IHello) Proxy.newProxyInstance(IHello.class.getClassLoader(),  //加载接口的类加载器
                   new Class[]{IHello.class},      //一组接口
                   new HWInvocationHandler(new Hello())); //自定义的InvocationHandler
           ihello.sayHello();
    }

以上就是JDK动态代理的使用。抱着知其然，也要知其所以然的态度，下面的内容我们就通过源码来研究一下代理类是如何生成的(为了易看易懂省略部分次要代码)。

首先我们以newProxyInstance方法为入口来看一下源码是如何实现的:

public static Object newProxyInstance(ClassLoader loader,
                                              Class<?>[] interfaces,
                                              InvocationHandler h)throws IllegalArgumentException{
    
            if (h == null) {   //如果h为空直接抛出异常，所以InvocationHandler实例对象是必须的
                throw new NullPointerException();
            }
            //对象的拷贝
            final Class<?>[] intfs = interfaces.clone();
            //一些安全的权限检查
            final SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
            }
            //产生代理类
            Class<?> cl = getProxyClass0(loader, intfs);
    
            //获取代理类的构造函数对象
            //参数constructorParames为常量值：private static final Class<?>[] constructorParams = { InvocationHandler.class };
            final Constructor<?> cons = cl.getConstructor(constructorParames);
            final InvocationHandler ih = h;
            //根据代理类的构造函数对象来创建代理类对象
            return newInstance(cons, ih);
    }

newInstance实现的是上面动态代理五大步骤中的第四步：通过Constructor.newInstance来构造相应的代理类实例。这段代码的重点是生成代理类的方法getProxyClass0。

private static Class<?> getProxyClass0(ClassLoader loader, 
                                           Class<?>... interfaces) { 
        // 代理的接口数量不能超过65535
        if (interfaces.length > 65535) { 
            throw new IllegalArgumentException("interface limit exceeded"); 
        } 
        // JDK对代理进行了缓存，如果已经存在相应的代理类，则直接返回，否则才会通过ProxyClassFactory来创建代理 
        return proxyClassCache.get(loader, interfaces); 
    }

其中代理缓存是通过WeakCache实现的：

private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

下面我们看看ProxyClassFactory是如何生辰代理类的，ProxyClassFactory是Proxy的一个静态内部类，实现了WeakCache的内部接口BiFunction的apply方法：

private static final class ProxyClassFactory
            implements BiFunction<ClassLoader, Class<?>[], Class<?>>{
        
    
         //统一代理类的前缀名都以$Proxy开始
            private static final String proxyClassNamePrefix = "$Proxy";
            //用于生成代理类名字的计数器。使用唯一的编号给作为代理类名的一部分，如$Proxy0,$Proxy1等
            private static final AtomicLong nextUniqueNumber = new AtomicLong();
            @Override
            public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
                //**************验证代理接口的代码start******************************
             Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
                for (Class<?> intf : interfaces) {
                    //验证指定的类加载器(loader)加载接口所得到的Class对象(interfaceClass)是否与intf对象相同
                    Class<?> interfaceClass = null;
                    try {
                        interfaceClass = Class.forName(intf.getName(), false, loader);
                    } catch (ClassNotFoundException e) {
                    }
                    if (interfaceClass != intf) {
                        throw new IllegalArgumentException(
                            intf + " is not visible from class loader");
                    }
                    //验证该Class对象是不是接口
                    if (!interfaceClass.isInterface()) {
                        throw new IllegalArgumentException(
                            interfaceClass.getName() + " is not an interface");
                    }
                    // 验证该接口是否重复了
                    if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                        throw new IllegalArgumentException(
                            "repeated interface: " + interfaceClass.getName());
                    }
                }
             //**************验证代理接口的代码end******************************
                //声明代理类所在包
                String proxyPkg = null; 
             //对于非公共接口，代理类的包名与接口的相同
                /*验证你传入的接口中是否有非public接口，只要有一个接口是非public的，那么这些接口都必须在同一包中
                这里的接口修饰符直接影响到System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true")所生成
                的代理类的路径，往下看！！tf : interfaces) {
                    int flags = intf.getModifiers();
                    if (!Modifier.isPublic(flags)) {
                        String name = intf.getName();
                        int n = name.lastIndexOf('.');
                        //截取完整包名
                        String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                        if (proxyPkg == null) {
                            proxyPkg = pkg;
                        } else if (!pkg.equals(proxyPkg)) {
                            throw new IllegalArgumentException(
                                "non-public interfaces from different packages");
                        }
                    }
                }
                //对于公共接口的包名，默认为com.sun.proxy 
                if (proxyPkg == null) {
                    /*如果都是public接口，那么生成的代理类就在com.sun.proxy包下如果报java.io.FileNotFoundException: com\sun\proxy\$Proxy0.class (系统找不到指定的路径。)的错误，就先在你项目中创建com.sun.proxy路径*/           
                    proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
                }
    
                //获取计数，将当前nextUniqueNumber的值以原子的方式的加1，所以第一次生成代理类的名字为$Proxy0.class
                long num = nextUniqueNumber.getAndIncrement();
                //默认情况下，代理类的完全限定名为：com.sun.proxy.$Proxy0，com.sun.proxy.$Proxy1……依次递增 
                String proxyName = proxyPkg + proxyClassNamePrefix + num;
                //这里才是生成代理类字节码的地方           
                byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                    proxyName, interfaces);
                try {
              //根据二进制字节码返回响应的class实例
                    return defineClass0(loader, proxyName,
                                        proxyClassFile, 0, proxyClassFile.length);
                } catch (ClassFormatError e) {
                    throw new IllegalArgumentException(e.toString());
                }
            }
    }

ProxyGenerator是sun.misc包中的类，它没有开源，但是可以反编译来看看：

public static byte[] generateProxyClass(final String var0, Class[] var1) { 
        ProxyGenerator var2 = new ProxyGenerator(var0, var1); 
        //生成代理类字节码文件的真正方法
        final byte[] var3 = var2.generateClassFile(); 
        //保存文件，这里根据参数配置，决定是否把生成的字节码（.class文件）保存到本地磁盘，我们可以通过把相应的class文件保存到本地，再反编译来看看具体的实现，这样更直观 
        if(saveGeneratedFiles) { 
            AccessController.doPrivileged(new PrivilegedAction() { 
                public Void run() { 
                    try { 
                        FileOutputStream var1 = new FileOutputStream(ProxyGenerator.dotToSlash(var0) + ".class"); 
                        var1.write(var3); 
                        var1.close(); 
                        return null; 
                    } catch (IOException var2) { 
                        throw new InternalError("I/O exception saving generated file: " + var2); 
                    } 
                } 
            }); 
        } 
        return var3; 
    }

注意saveGeneratedFiles这个属性的值：

private static final boolean saveGeneratedFiles = ((Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"))).booleanValue();

GetBooleanAction实际上是调用Boolean.getBoolean(propName)来获得的，而Boolean.getBoolean(propName)调用了System.getProperty(name)，所以我们可以设置sun.misc.ProxyGenerator.saveGeneratedFiles这个系统属性为true来把生成的class保存到本地文件来查看。sun.misc.ProxyGenerator.saveGeneratedFiles的值我们上面在测试方法中是手动设置的。

这里要注意，当把这个属性设置为true时，生成的class文件及其所在的路径都需要提前创建，否则会抛出FileNotFoundException异常。即我们要在运行当前main方法的路径下创建com/sun/proxy目录，并创建一个$Proxy0.class文件，才能够正常运行并保存class文件内容。

层层调用后，最终generateClassFile才是真正生成代理类字节码文件的方法：

private byte[] generateClassFile() {
            /addProxyMethod系列方法就是将接口的方法和Object的hashCode,equals,toString方法添加到代理方法容器(proxyMethods),
             其中方法签名作为key,proxyMethod作为value*/
            /*hashCodeMethod方法位于静态代码块中通过Object对象获得，hashCodeMethod=Object.class.getMethod("hashCode",new Class[0]),
             相当于从Object中继承过来了这三个方法equalsMethod,toStringMethod*/   
            this.addProxyMethod(hashCodeMethod, Object.class);   -->
            this.addProxyMethod(equalsMethod, Object.class);
            this.addProxyMethod(toStringMethod, Object.class);
            int var1;
            int var3;
             //获得所有接口中的所有方法，并将方法添加到代理方法中
            for(var1 = 0; var1 < this.interfaces.length; ++var1) {
                Method[] var2 = this.interfaces[var1].getMethods();          
                for(var3 = 0; var3 < var2.length; ++var3) {
                    this.addProxyMethod(var2[var3], this.interfaces[var1]);
                }
            }
    
            Iterator var7 = this.proxyMethods.values().iterator();
            List var8;
            while(var7.hasNext()) {
                var8 = (List)var7.next();
             //验证具有相同方法签名的的方法的返回值类型是否一致，因为不可能有两个方法名相同,参数相同，而返回值却不同的方法
                checkReturnTypes(var8);   
            };
        //接下来就是写代理类文件的步骤了
            Iterator var11
            try {
                 //生成代理类的构造函数
                this.methods.add(this.generateConstructor());
                var7 = this.proxyMethods.values().iterator();
                while(var7.hasNext()) {
                    var8 = (List)var7.next();
                    var11 = var8.iterator();
                    while(var11.hasNext()) {
                        ProxyGenerator.ProxyMethod var4 = (ProxyGenerator.ProxyMethod)var11.next();
                        /将代理字段声明为Method，10为ACC_PRIVATE和ACC_STATAIC的与运算，表示该字段的修饰符为private static
                         所以代理类的字段都是private static Method XXX*/
                        this.fields.add(new ProxyGenerator.FieldInfo(var4.methodFieldName, "Ljava/lang/reflect/Method;", 10));
                        //生成代理类的代理方法
                        this.methods.add(var4.generateMethod());
                    }
                }
                //为代理类生成静态代码块，对一些字段进行初始化
                this.methods.add(this.generateStaticInitializer());
            } catch (IOException var6) {
                throw new InternalError("unexpected I/O Exception");
            }
    
            if(this.methods.size() > '\uffff') {  //代理方法超过65535将抛出异常
                throw new IllegalArgumentException("method limit exceeded");
            } else if(this.fields.size() > '\uffff') {   //代理类的字段超过65535将抛出异常
                throw new IllegalArgumentException("field limit exceeded");
            } else {
             //这里开始就是一些代理类文件的过程，此过程略过
                this.cp.getClass(dotToSlash(this.className));
                this.cp.getClass("java/lang/reflect/Proxy");
                for(var1 = 0; var1 < this.interfaces.length; ++var1) {
                    this.cp.getClass(dotToSlash(this.interfaces[var1].getName()));
                }
                this.cp.setReadOnly();
                ByteArrayOutputStream var9 = new ByteArrayOutputStream();
                DataOutputStream var10 = new DataOutputStream(var9);
                try {
                    var10.writeInt(-889275714);
                    var10.writeShort(0);
                    var10.writeShort(49);
                    this.cp.write(var10);
                    var10.writeShort(49);
                    var10.writeShort(this.cp.getClass(dotToSlash(this.className)));
                    var10.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));
                    var10.writeShort(this.interfaces.length);
                    for(var3 = 0; var3 < this.interfaces.length; ++var3) {
                        var10.writeShort(this.cp.getClass(dotToSlash(this.interfaces[var3].getName())));
                    }
                    var10.writeShort(this.fields.size());
                    var11 = this.fields.iterator();
                    while(var11.hasNext()) {
                        ProxyGenerator.FieldInfo var12 = (ProxyGenerator.FieldInfo)var11.next();
                        var12.write(var10);
                    }
                    var10.writeShort(this.methods.size());
                    var11 = this.methods.iterator();
                    while(var11.hasNext()) {
                        ProxyGenerator.MethodInfo var13 = (ProxyGenerator.MethodInfo)var11.next();
                        var13.write(var10);
                    }
                    var10.writeShort(0);
                    return var9.toByteArray();
                } catch (IOException var5) {
                    throw new InternalError("unexpected I/O Exception");
                }
            }
    }

注意：开头的三个addProxyMethod方法是只将Object的hashcode,equals,toString方法添加到代理方法容器中，代理类除此之外并没有重写其他Object的方法，所以除这三个方法外，代理类调用其他方法的行为与Object调用这些方法的行为一样不通过Invoke。

我们来看看addProxyMethod方法的实现：

private void addProxyMethod(Method var1, Class var2) {
            String var3 = var1.getName();  //方法名
            Class[] var4 = var1.getParameterTypes();   //方法参数类型数组
            Class var5 = var1.getReturnType();    //返回值类型
            Class[] var6 = var1.getExceptionTypes();   //异常类型
            String var7 = var3 + getParameterDescriptors(var4);   //方法签名
            Object var8 = (List)this.proxyMethods.get(var7);   //根据方法签名却获得proxyMethods的Value
            if(var8 != null) {    //处理多个代理接口中重复的方法的情况
                Iterator var9 = ((List)var8).iterator();
                while(var9.hasNext()) {
                    ProxyGenerator.ProxyMethod var10 = (ProxyGenerator.ProxyMethod)var9.next();
                    if(var5 == var10.returnType) {
                        /*归约异常类型以至于让重写的方法抛出合适的异常类型，我认为这里可能是多个接口中有相同的方法，而这些相同的方法抛出的异常类                      型又不同，所以对这些相同方法抛出的异常进行了归约*/
                        ArrayList var11 = new ArrayList();
                        collectCompatibleTypes(var6, var10.exceptionTypes, var11);
                        collectCompatibleTypes(var10.exceptionTypes, var6, var11);
                        var10.exceptionTypes = new Class[var11.size()];
                        //将ArrayList转换为Class对象数组
                        var10.exceptionTypes = (Class[])var11.toArray(var10.exceptionTypes);
                        return;
                    }
                }
            } else {
             //如果var8为空，就创建一个数组，并以方法签名为key,proxymethod对象数组为value添加到proxyMethods
                var8 = new ArrayList(3);
                this.proxyMethods.put(var7, var8);
            }   
            ((List)var8).add(new ProxyGenerator.ProxyMethod(var3, var4, var5, var6, var2, null));
    }

以下就是上面我们测试实例中MyProxy的代理类：

public final class $Proxy0 extends Proxy implements IHello {
           //继承了Proxy类和实现IHello接口
        //变量，都是private static Method  XXX
        private static Method m3; 
        private static Method m1;
        private static Method m0;
        private static Method m2;
    
        //代理类的构造函数，其参数正是是InvocationHandler实例，Proxy.newInstance方法就是通过通过这个构造函数来创建代理实例的
        public $Proxy0(InvocationHandler var1) throws  {
            super(var1);
        }
    
        //接口代理方法
        public final void sayHello() throws  {
            try {
                super.h.invoke(this, m3, (Object[])null);
            } catch (RuntimeException | Error var2) {
                throw var2;
            } catch (Throwable var3) {
                throw new UndeclaredThrowableException(var3);
            }
        }
    
        //以下Object中的三个方法
        public final boolean equals(Object var1) throws  {
            try {
                return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
            } catch (RuntimeException | Error var3) {
                throw var3;
            } catch (Throwable var4) {
                throw new UndeclaredThrowableException(var4);
            }
        }
    
        public final int hashCode() throws  {
            try {
                return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
            } catch (RuntimeException | Error var2) {
                throw var2;
            } catch (Throwable var3) {
                throw new UndeclaredThrowableException(var3);
            }
        }
    
        public final String toString() throws  {
            try {
                return (String)super.h.invoke(this, m2, (Object[])null);
            } catch (RuntimeException | Error var2) {
                throw var2;
            } catch (Throwable var3) {
                throw new UndeclaredThrowableException(var3);
            }
        }
    
        //对变量进行一些初始化工作
        static {
            try {
                m3 = Class.forName("com.proxy.IHello").getMethod("sayHello", new Class[0]);
                m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
                m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
                m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            } catch (NoSuchMethodException var2) {
                throw new NoSuchMethodError(var2.getMessage());
            } catch (ClassNotFoundException var3) {
                throw new NoClassDefFoundError(var3.getMessage());
            }
        }
    }

**我们来总结一下：**

#### **5、动态生成的代理类有如下特性：** ####

> 1).继承了Proxy类，实现了代理的接口，由于java不能多继承，这里已经继承了Proxy类了，不能再继承其他的类，所以JDK的动态代理不支持对实现类的代理，只支持接口的代理。
> 
> 2).重写了Object类的equals、hashCode、toString，它们都只是简单的调用了InvocationHandler的invoke方法，即可以对其进行特殊的操作，也就是说JDK的动态代理除了代理实现接口的方法外，还可以代理上述三个方法,可能的原因有：一是因为这些方法为 public 且非 final 类型，能够被代理类覆盖；二是因为这些方法往往呈现出一个类的某种特征属性，具有一定的区分度，所以为了保证代理类与委托类对外的一致性，这三个方法也应该被分派到委托类执行。当代理的一组接口有重复声明的方法且该方法被调用时，代理类总是从排在最前面的接口中获取方法对象并分派给调用处理器，而无论代理类实例是否正在以该接口（或继承于该接口的某子接口）的形式被外部引用，因为在代理类内部无法区分其当前的被引用类型。
> 
> 3).代理类实现代理接口的sayHello方法中，只是简单的调用了InvocationHandler的invoke方法，我们可以在invoke方法中进行一些特殊操作，甚至不调用实现的方法，直接返回。
> 
> 4）包：如果所代理的接口都是 public 的，那么它将被定义在顶层包（即包路径为空），如果所代理的接口中有非 public 的接口（因为接口不能被定义为 protect 或 private，所以除 public 之外就是默认的 package 访问级别），那么它将被定义在该接口所在包（假设代理了 com.ibm.developerworks 包中的某非 public 接口 A，那么新生成的代理类所在的包就是 com.ibm.developerworks），这样设计的目的是为了最大程度的保证动态代理类不会因为包管理的问题而无法被成功定义并访问；
> 
> 5）类修饰符：该代理类具有 final 和 public 修饰符，意味着它可以被所有的类访问，但是不能被再度继承；
> 
> 6）类名：格式是“$ProxyN”，其中 N 是一个逐一递增的阿拉伯数字，代表 Proxy 类第 N 次生成的动态代理类，值得注意的一点是，并不是每次调用 Proxy 的静态方法创建动态代理类都会使得 N 值增加，原因是如果对同一组接口（包括接口排列的顺序相同）试图重复创建动态代理类，它会很聪明地返回先前已经创建好的代理类的类对象，而不会再尝试去创建一个全新的代理类，这样可以节省不必要的代码重复生成，提高了代理类的创建效率。

#### **6、代理实例的特点：** ####

> 每个实例都会关联一个调用处理器对象，可以通过 Proxy 提供的静态方法 getInvocationHandler 去获得代理类实例的调用处理器对象。在代理类实例上调用其代理的接口中所声明的方法时，这些方法最终都会由调用处理器的 invoke 方法执行.

#### **7、被代理的接口的特点：** ####

> 首先，要注意不能有重复的接口，以避免动态代理类代码生成时的编译错误。其次，这些接口对于类装载器必须可见，否则类装载器将无法链接它们，将会导致类定义失败。再次，需被代理的所有非 public 的接口必须在同一个包中，否则代理类生成也会失败。最后，接口的数目不能超过 65535，这是 JVM 设定的限制。

#### **8、动态代理的异常处理：** ####

> 从调用处理器接口声明的方法中可以看到理论上它能够抛出任何类型的异常，因为所有的异常都继承于 Throwable 接口，但事实是否如此呢？答案是否定的，原因是我们必须遵守一个继承原则：即子类覆盖父类或实现父接口的方法时，抛出的异常必须在原方法支持的异常列表之内。所以虽然调用处理器理论上讲能够，但实际上往往受限制，除非父接口中的方法支持抛 Throwable 异常。那么如果在 invoke 方法中的确产生了接口方法声明中不支持的异常，那将如何呢？放心，Java 动态代理类已经为我们设计好了解决方法：它将会抛出 UndeclaredThrowableException 异常。这个异常是一个 RuntimeException 类型，所以不会引起编译错误。通过该异常的 getCause 方法，还可以获得原来那个不受支持的异常对象，以便于错误诊断。

#### **9、引申:** ####

开头说的spring AOP对于接口的来说就是通过JDK的动态代理来实现的，我们可以推测书spring AOP使用JDK动态代理实现的代码如下：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
        // BeforeAdvice 
        Object retVal = null; 
        try { 
            // AroundAdvice 
            retVal = method.invoke(target, args); 
            // AroundAdvice 
            // AfterReturningAdvice 
        } 
        catch (Throwable e) { 
            // AfterThrowingAdvice 
        } 
        finally { 
            // AfterAdvice 
        } 
        return retVal; 
    }

以上是博主结合日常的学习，从源码的角度剖析了JDK动态代理的实现，之前在对别的博文进行学习的时候发现一篇文章，侧重于从JVM的角度来讲解动态代理实现，讲的深入透彻，值得一看，链接如下：[Java动态代理机制详解（JDK 和CGLIB，Javassist，ASM）][Java_JDK _CGLIB_Javassist_ASM]

[Link 1]: http://blog.csdn.net/lmb55/article/details/50932329
[SouthEast]: /images/20220612/ce86d686d75b4dc7bbb114850cde0c9d.png
[Java_JDK _CGLIB_Javassist_ASM]: http://blog.csdn.net/luanlouis/article/details/24589193