jdk动态代理原理(源码分析)

拼搏现实的明天。 2021-09-03 04:06 359阅读 0赞

JDK动态代理基于拦截器和反射来实现，不需要第三方库支持的，只需要JDK环境就可以进行代理，使用条件：

1.  实现InvocationHandler接口实现代理逻辑；
2.  使用Proxy.newProxyInstance产生代理对象；
3.  被代理的类必须要实现接口；

## jdk动态代理示例： ##

### **1、使用JDK动态代理的五大步骤：** ###

1.  通过实现InvocationHandler接口来自定义自己的InvocationHandler；
2.  通过Proxy.getProxyClass获得动态代理类；
3.  通过反射机制获得代理类的构造方法，方法签名为getConstructor(InvocationHandler.class)；
4.  通过构造函数获得代理对象并将自定义的InvocationHandler实例对象传为参数传入；
5.  通过代理对象调用目标方法；

1）接口：

package cn.nuc.edu.LogTest.proxy;
    public interface IHello {
    	void sayHello();
    }

2）实现类：

package cn.nuc.edu.LogTest.proxy;
    public class Hello implements IHello{
    	@Override
    	public void sayHello() {
    		System.out.println("hello world...");
    	}
    }

3）InvocationHandler接口实现：

package cn.nuc.edu.LogTest.proxy;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    
    public class MyInvocationHandler implements InvocationHandler {
    	private Object target;
    	public MyInvocationHandler(Object target) {
    		this.target = target;
    	}
    
    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
    		System.out.println("before...");
    		Object retureval = method.invoke(target, args);
    		System.out.println("after...");
    		return retureval;
    	}
    }

4）测试：

package cn.nuc.edu.LogTest.proxy;
    import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    
    public class MyProxyTest {
    	public static void main(String...strings) throws Exception {
    		// 1、生成$Proxy0的class文件
            System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
            // 2、获取动态代理类
            Class proxyClazz = Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class);
            // 3、获得代理类的构造函数，并传入参数类型InvocationHandler.class
            Constructor constructor = proxyClazz.getConstructor(InvocationHandler.class);
            // 4、通过构造函数来创建动态代理对象，将自定义的InvocationHandler实例传入
            IHello iHello1 = (IHello) constructor.newInstance(new MyInvocationHandler(new Hello()));
            // 5、通过代理对象调用目标方法
            iHello1.sayHello();
     
            // ==========================第二种=============================
            /**
             * Proxy类中还有个将2~4步骤封装好的简便方法来创建动态代理对象，
             *其方法签名为：newProxyInstance(ClassLoader loader,Class<?>[] instance, InvocationHandler h)
             */
            IHello  iHello2 = (IHello) Proxy.newProxyInstance(IHello.class.getClassLoader(), // 加载接口的类加载器
                    new Class[]{IHello.class}, // 一组接口
                    new MyInvocationHandler(new Hello())); // 自定义的InvocationHandler
            iHello2.sayHello();
    	}
    }

分析：从下面反编译代理类可知，代理类继承Proxy并实现IHello接口的sayHello方法，有一个构造函数且参数为InvocationHandler类型。

所以，我们可以通过Class proxyClazz = Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class);方法获取代理类的Class对象，然后在获取对应的构造函数，进而创建代理类对象。

### **2、jdk动态代理生成.class文件：** ###

**1）方法一：**

配置系统属性sun.misc.ProxyGenerator.saveGeneratedFile为true

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

**2）方法二：**

JDK提供了sun.misc.ProxyGenerator.generateProxyClass(String proxyName,class\[\] interfaces) 底层方法来产生动态代理类的字节码。

package cn.nuc.edu.LogTest.proxy;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import sun.misc.ProxyGenerator;
    
    public class ProxyUtils {
        public static void generateClassFile(Class clazz, String proxyName) {
            //根据类信息和提供的代理类名称，生成字节码  
            byte[] classFile = ProxyGenerator.generateProxyClass(proxyName, clazz.getInterfaces());
            String paths = "D:\\";
            FileOutputStream out = null;
            try {
                out = new FileOutputStream(paths + proxyName + ".class");//保存到硬盘中  
                out.write(classFile);
                out.flush();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

测试：

public class ProxyUtilsTest {
    	public static void main(String...strings) {
    		IHello hello = new Hello();//实现IHello接口
            ProxyUtils.generateClassFile(hello.getClass(), "HelloProxy");  
    	}
    }

反编译查看生成的HelloProxy.class：

import cn.nuc.edu.LogTest.proxy.IHello;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.lang.reflect.UndeclaredThrowableException;
    
    public final class HelloProxy extends Proxy implements IHello {
      private static Method m3;
      private static Method m1;
      private static Method m0;
      private static Method m2;
      static {
        try {
          m3 = Class.forName("cn.nuc.edu.LogTest.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]);
          return;
        } catch (NoSuchMethodException localNoSuchMethodException) {
          throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
        } catch (ClassNotFoundException localClassNotFoundException) {
          throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
        }
      }
      public HelloProxy(InvocationHandler paramInvocationHandler) throws  {
        super(paramInvocationHandler);
      }
      
      public final void sayHello() throws  {
        try {
          this.h.invoke(this, m3, null);
          return;
        } catch (Error|RuntimeException localError) {
          throw localError;
        } catch (Throwable localThrowable) {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }
      
      public final boolean equals(Object paramObject) throws {
        try {
          return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
        } catch (Error|RuntimeException localError) {
          throw localError;
        } catch (Throwable localThrowable) {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }
      public final int hashCode() throws  {
        try {
          return ((Integer)this.h.invoke(this, m0, null)).intValue();
        } catch (Error|RuntimeException localError) {
          throw localError;
        } catch (Throwable localThrowable) {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }
      public final String toString() throws  {
        try {
          return (String)this.h.invoke(this, m2, null);
        } catch (Error|RuntimeException localError) {
          throw localError;
        } catch (Throwable localThrowable) {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }
    }

## 源码分析 ##

**1、以Proxy.newProxyInstance()方法为切入点来剖析代理类的生成及代理方法的调用：**

@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException {
        if (h == null) {
            throw new NullPointerException();
        }
        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
        //生成代理类Class对象
        Class<?> cl = getProxyClass0(loader, intfs);
        //创建代理类的对象
        try {
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            return newInstance(cons, ih);
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString());
        }
    }

该方法完成以下三步：

1.  生成代理类：Class<?> cl = getProxyClass0(loader, intfs);
2.  获取构造器：final Constructor<?> cons = cl.getConstructor(constructorParams);
3.  生成代理对象：cons.newInstance(new Object\[\]\{h\});

可以看出来，以上三步最关键的方法是getProxyClass0，获取代理类的Class对象。

2）getProxyClass0方法：

private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
        if (interfaces.length > 65535) {//接口数不得超过65535个
            throw new IllegalArgumentException("interface limit exceeded");
        }
        
        //如果缓存中有代理类了直接返回，否则将由代理类工厂ProxyClassFactory创建代理类
        return proxyClassCache.get(loader, interfaces);
    }

3）get方法：

public V get(K key, P parameter) {//key是ClassLoader，parameter是接口数组，
        // 检查指定类型的对象引用不为空null。当参数为null时，抛出空指针异常。
        Objects.requireNonNull(parameter);
        //清除已经被GC回收的弱引用
        expungeStaleEntries();
        //将ClassLoader包装成CacheKey, 作为一级缓存的key
        Object cacheKey = CacheKey.valueOf(key, refQueue);
        // lazily install 二级缓存
        ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
        if (valuesMap == null) {
            ConcurrentMap<Object, Supplier<V>> oldValuesMap
                = map.putIfAbsent(cacheKey,
                                  valuesMap = new ConcurrentHashMap<>());
            if (oldValuesMap != null) {
                valuesMap = oldValuesMap;
            }
        }
        //根据代理类实现的接口数组来生成二级缓存key
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
        Supplier<V> supplier = valuesMap.get(subKey);
        Factory factory = null;
        while (true) {// 这个循环提供了轮询机制, 如果条件为假就继续重试直到条件为真为止
            if (supplier != null) {
                // supplier might be a Factory or a CacheValue<V> instance
                V value = supplier.get();
                if (value != null) {
                    return value;
                }
            }
            // lazily construct a Factory
            if (factory == null) {
                factory = new Factory(key, parameter, subKey, valuesMap);
            }
    
            if (supplier == null) {
                supplier = valuesMap.putIfAbsent(subKey, factory);
                if (supplier == null) {
                    // successfully installed Factory
                    supplier = factory;
                }
                // else retry with winning supplier
            } else {// 期间可能其他线程修改了值, 那么就将原先的值替换
                if (valuesMap.replace(subKey, supplier, factory)) {
                    // successfully replaced
                    // cleared CacheEntry / unsuccessful Factory
                    // with our Factory
                    supplier = factory;
                } else {
                    // retry with current supplier
                    supplier = valuesMap.get(subKey);
                }
            }
        }
    }

4）apply方法：

public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
        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");
            }
            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());
            }
        }
        String proxyPkg = null;     // 代理类的全限定名
        //验证所有非公共的接口在同一个包内
        for (Class<?> intf : 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");
                }
            }
        }
        if (proxyPkg == null) {
            // if no non-public proxy interfaces, use com.sun.proxy package
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
        }
        //Choose a name for the proxy class to generate.
        long num = nextUniqueNumber.getAndIncrement();
        String proxyName = proxyPkg + proxyClassNamePrefix + num;
        //Generate the specified proxy class.
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
        try {
            return defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);
        } catch (ClassFormatError e) {
            throw new IllegalArgumentException(e.toString());
        }
    }

5）ProxyGenerator.generateProxyClass()方法：

private byte[] generateClassFile() {
          //Step 1:Assemble ProxyMethod objects for all methods to generate proxy dispatching code for.
          this.addProxyMethod(hashCodeMethod, Object.class);
          this.addProxyMethod(equalsMethod, Object.class);
          this.addProxyMethod(toStringMethod, Object.class);
    
          // 获得所有接口中的所有方法，并将方法添加到代理方法中
          for (Class<?> intf : interfaces) {
              for (Method m : intf.getMethods()) {
                  addProxyMethod(m, intf);
              }
          }
    
          //Step 2:生成字段信息和方法信息
          try {
              methods.add(generateConstructor()); // 生成代理类的构造函数
              for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
                  for (ProxyMethod pm : sigmethods) {
                      // add static field for method's Method object
                      fields.add(new FieldInfo(pm.methodFieldName,
                              "Ljava/lang/reflect/Method;",
                              ACC_PRIVATE | ACC_STATIC));
    	 	          // 生成代理类的代理方法
                      methods.add(pm.generateMethod());
                  }
              }
              // 为代理类生成静态代码块，对一些字段进行初始化
              methods.add(generateStaticInitializer());
          } catch (IOException e) {
              throw new InternalError("unexpected I/O Exception", e);
          }
          if (methods.size() > 65535) {
              throw new IllegalArgumentException("method limit exceeded");
          }
          if (fields.size() > 65535) {
              throw new IllegalArgumentException("field limit exceeded");
          }
          //Step 3: 编写最终类文件
          //在开始编写最终类文件之前，确保为下面的项目保留常量池索引。
          cp.getClass(dotToSlash(className));
          cp.getClass(superclassName);
          for (Class<?> intf: interfaces) {
              cp.getClass(dotToSlash(intf.getName()));
          }
          
          /*
           * Disallow new constant pool additions beyond this point, since we are about to write the final constant pool table.
           * 设置只读，在这之前不允许在常量池中增加信息，因为要写常量池表
           */
          cp.setReadOnly();
          
          ByteArrayOutputStream bout = new ByteArrayOutputStream();
          DataOutputStream dout = new DataOutputStream(bout);
          
          try {
              dout.writeInt(0xCAFEBABE);// u4 magic;
              dout.writeShort(CLASSFILE_MINOR_VERSION);// u2 次要版本;
              dout.writeShort(CLASSFILE_MAJOR_VERSION);// u2 主版本
              cp.write(dout);             // (write constant pool)
              dout.writeShort(accessFlags);// u2 访问标识;
              dout.writeShort(cp.getClass(dotToSlash(className)));// u2 本类名;
              dout.writeShort(cp.getClass(superclassName));// u2 父类名;
              dout.writeShort(interfaces.length);// u2 接口;
              // u2 interfaces[interfaces_count];
              for (Class<?> intf : interfaces) {
                  dout.writeShort(cp.getClass(
                          dotToSlash(intf.getName())));
              }
              dout.writeShort(fields.size());// u2 字段;
              // field_info fields[fields_count];
              for (FieldInfo f : fields) {
                  f.write(dout);
              }
              dout.writeShort(methods.size());// u2 方法;
              // method_info methods[methods_count];
              for (MethodInfo m : methods) {
                  m.write(dout);
              }
              // u2 类文件属性：对于代理类来说没有类文件属性;
              dout.writeShort(0); // (no ClassFile attributes for proxy classes)
          
          } catch (IOException e) {
              throw new InternalError("unexpected I/O Exception", e);
          }
          
          return bout.toByteArray();
       }

**2、分析：**

从反编译后的代理类源码看：$Proxy0类继承了Proxy类，同时实现了IHello接口，即代理类接口，所以才能强制将代理对象转换为IHello接口，然后调用$Proxy0中的sayHello()方法。

$Proxy0中sayHello()源码：

public final void sayHello() throws  {
        try {
          this.h.invoke(this, m3, null);
          return;
        } catch (Error|RuntimeException localError) {
          throw localError;
        } catch (Throwable localThrowable) {
          throw new UndeclaredThrowableException(localThrowable);
        }
    }

*  this就是$Proxy0对象；
 *  m3就是m3 = Class.forName("com.jpeony.spring.proxy.jdk.IHello").getMethod("sayHello", new Class\[0\]);即是通过全路径名，反射获取的目标对象中的真实方法加参数
 *  h就是Proxy类中的变量protected InvocationHandler h;

所以成功的调到了InvocationHandler中的invoke()方法，但是invoke()方法在我们自定义的MyInvocationHandler中实现：

@Override
    public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
    		System.out.println("before...");
    		Object retureval = method.invoke(target, args);
    		System.out.println("after...");
    		return retureval;
    }

绕了半天，终于调用到了MyInvocationHandler中的invoke()方法，从上面的this.h.invoke(this, m3, null); 可以看出，MyInvocationHandler中invoke第一个参数为$Proxy0（代理对象），第二个参数为目标类的真实方法，第三个参数为目标方法参数，因为sayHello()没有参数，所以是null。

到这里，我们真正的实现了通过代理调用目标对象的完全分析。

参考：

[https://www.cnblogs.com/flyingeagle/articles/7103190.html][https_www.cnblogs.com_flyingeagle_articles_7103190.html]

[https://blog.csdn.net/yhl\_jxy/article/details/80586785][https_blog.csdn.net_yhl_jxy_article_details_80586785]

[https_www.cnblogs.com_flyingeagle_articles_7103190.html]: https://www.cnblogs.com/flyingeagle/articles/7103190.html
[https_blog.csdn.net_yhl_jxy_article_details_80586785]: https://blog.csdn.net/yhl_jxy/article/details/80586785