动态代理原理（动态代理原理怎么理解）

2023-03-23 11:07:56 分类：java 阅读()

　　本篇文章为你整理了动态代理原理（动态代理原理怎么理解）的详细内容，包含有mybatis动态代理原理 动态代理原理怎么理解 动态代理原理详解 动态代理原理是什么 动态代理原理，希望能帮助你了解 动态代理原理。

　　java.lang.reflect.Proxy是整个jdk中实现动态代理的核心 类，本文主要介绍Proxy类的实现，关于Proxy类的使用请自行查阅其他资料。

　　Field

　　
constructorParams：构造函数的参数，用于代理类的核心的逻辑实现，关于InvocationHandler这个接口的介绍不是本文的重点，此处不做介绍。

　　


private static final Class ? [] constructorParams =
 { InvocationHandler.class };

 

　　
proxyClassCache： 代理类的缓存，此类是一个二级缓存的实现，利用WeakReference的特性，当内存占用过高的时候会JVM自动进行回收缓存中的数据。

　　


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

 

　　
KeyFactory：顾名思义，缓存代理的key的工厂实现，此类仅一个方法，实现了BiFunction接口，具体代码如下

　　


private static final class KeyFactory
 implements BiFunction ClassLoader, Class ? [], Object 
{
 @Override
 public Object apply(ClassLoader classLoader, Class ? [] interfaces) {
 switch (interfaces.length) {
 case 1: return new Key1(interfaces[0]); // the most frequent
 case 2: return new Key2(interfaces[0], interfaces[1]);
 case 0: return key0;
 default: return new KeyX(interfaces);
 }
 }
}

 

　　由以上代码可见，该类的实现分为委托给了Key0,Key1,Key2,KeyX这四个类实现，其中key0是一个Object，其他的类Key1,Key2,KeyX则是分别用不同的实现对hashcode和equals方法进行了不同的实现，大同小异。这里则分别简单的做一下解释。

　　

private static final class Key1 extends WeakReference Class ? {
 private final int hash;
​
 Key1(Class ? intf) {
 super(intf);
 this.hash = intf.hashCode();
 }
​
 @Override
 public int hashCode() {
 return hash;
 }
​
 @Override
 public boolean equals(Object obj) {
 Class ? intf;
 return this == obj 
 obj != null 
 obj.getClass() == Key1.class 
 (intf = get()) != null 
 intf == ((Key1) obj).get();
 }
}

 

　　

private static final class Key2 extends WeakReference Class ? {
 private final int hash;
 private final WeakReference Class ? ref2;
​
 Key2(Class ? intf1, Class ? intf2) {
 super(intf1);
 hash = 31 * intf1.hashCode() + intf2.hashCode();
 ref2 = new WeakReference Class ? (intf2);
 }
​
 @Override
 public int hashCode() {
 return hash;
 }
​
 @Override
 public boolean equals(Object obj) {
 Class ? intf1, intf2;
 return this == obj 
 obj != null 
 obj.getClass() == Key2.class 
 (intf1 = get()) != null 
 intf1 == ((Key2) obj).get() 
 (intf2 = ref2.get()) != null 
 intf2 == ((Key2) obj).ref2.get();
 }
}

 

　　

private static final class KeyX {
 private final int hash;
 private final WeakReference Class ? [] refs;
​
 @SuppressWarnings("unchecked")
 KeyX(Class ? [] interfaces) {
 hash = Arrays.hashCode(interfaces);
 refs = (WeakReference Class ? [])new WeakReference ? [interfaces.length];
 for (int i = 0; i interfaces.length; i++) {
 refs[i] = new WeakReference (interfaces[i]);
 }
 }
​
 @Override
 public int hashCode() {
 return hash;
 }
​
 @Override
 public boolean equals(Object obj) {
 return this == obj 
 obj != null 
 obj.getClass() == KeyX.class 
 equals(refs, ((KeyX) obj).refs);
 }
​
 private static boolean equals(WeakReference Class ? [] refs1,
 WeakReference Class ? [] refs2) {
 if (refs1.length != refs2.length) {
 return false;
 }
 for (int i = 0; i refs1.length; i++) {
 Class ? intf = refs1[i].get();
 if (intf == null intf != refs2[i].get()) {
 return false;
 }
 }
 return true;
 }
}

 

　　
ProxyClassFactory： 顾名思义， 代理类的生产工厂类，用于生成代理类，此类也是实现了BiFunction,技能一个apply方法，最终根据ClassLoader,Interface,proxyName参数调用java.lang.reflect.Proxy#defineClass0这个本地方法生成代理类。

　　


private static final class ProxyClassFactory
 implements BiFunction ClassLoader, Class ? [], Class ? 
{
 // 代理类名称的前缀，我们看到的代理类的名称都有这个前缀就是这个原因
 private static final String proxyClassNamePrefix = "$Proxy";
​
 // 用于生成代理类名称的唯一的序号
 private static final AtomicLong nextUniqueNumber = new AtomicLong();
​
 @Override
 public Class ? apply(ClassLoader loader, Class ? [] interfaces) {
​
 Map Class ? , Boolean interfaceSet = new IdentityHashMap (interfaces.length);
 for (Class ? intf : interfaces) {
 /*
 * 验证类加载器是否将此接口的名称解析为同一类对象
 */
 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; 
 //代理类的访问修饰符
 int accessFlags = Modifier.PUBLIC Modifier.FINAL;
​
 /*
 * 记录非public的代理接口的包，以至于代理类的定义是相同的包，验证所有的非public的代理接口在相同的包中。
 */
 for (Class ? intf : interfaces) {
 int flags = intf.getModifiers();
 if (!Modifier.isPublic(flags)) {
 accessFlags = Modifier.FINAL;
 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) {
 //如果没有非public的代理接口，则用com.sun.proxy这个包
 proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
 }
​
 /*
 * 为生成的代理类选择一个名称
 */
 long num = nextUniqueNumber.getAndIncrement();
 //代理类名称
 String proxyName = proxyPkg + proxyClassNamePrefix + num;
​
 /*
 * 生成代理类
 */
 byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
 proxyName, interfaces, accessFlags);
 try {
 return defineClass0(loader, proxyName,
 proxyClassFile, 0, proxyClassFile.length);
 } catch (ClassFormatError e) {
 /*
 * 如果出现了ClassFormatError则意味着提供给代理类创建的参数还有其他一些无效方面或者生成代理的代码有bug。（例如超出虚拟机限制）
 */
 throw new IllegalArgumentException(e.toString());
 }
 }
}
​
/**
*生成代理类的本地方法
*/
private static native Class ? defineClass0(ClassLoader loader, String name,
 byte[] b, int off, int len);

 

　　
newProxyInstance： 返回一个指定接口的代理类的实例，将该代理类调度到指定的处理方法。

　　arguments:

　　
InvocationHandler： 处理被代理类的方法，每一个被代理的类都将由指定的InvocationHandler处理。

　　


public static Object newProxyInstance(ClassLoader loader,
 Class ? [] interfaces,
 InvocationHandler h)
 throws IllegalArgumentException
{
 Objects.requireNonNull(h);
​
 final Class ? [] intfs = interfaces.clone();
 final SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
 checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
 }
​
 /*
 * 根据类加载器和代理类实现的接口查找或者生成代理类
 */
 Class ? cl = getProxyClass0(loader, intfs);
​
 try {
 if (sm != null) {
 checkNewProxyPermission(Reflection.getCallerClass(), cl);
 }
 //获取构造函数
 final Constructor ? cons = cl.getConstructor(constructorParams);
 //处理程序
 final InvocationHandler ih = h;
 //访问修饰符不是public则利用AccessController做权限控制，设置可访问
 if (!Modifier.isPublic(cl.getModifiers())) {
 AccessController.doPrivileged(new PrivilegedAction Void () {
 public Void run() {
 cons.setAccessible(true);
 return null;
 }
 });
 }
 //使用构造器反射创建代理类的实例
 return cons.newInstance(new Object[]{h});
 } catch (IllegalAccessExceptionInstantiationException e) {
 throw new InternalError(e.toString(), e);
 } catch (InvocationTargetException e) {
 Throwable t = e.getCause();
 if (t instanceof RuntimeException) {
 throw (RuntimeException) t;
 } else {
 throw new InternalError(t.toString(), t);
 }
 } catch (NoSuchMethodException e) {
 throw new InternalError(e.toString(), e);
 }
}

 

　　
我们带着以上几个疑问深入深入探讨一下其中的原理。

　　 1：代理类defineClass0方法是如何生成的？这个问题已经超纲了，仅能结合已有的只是浅显的说一下（好像又没说）。我们都知道Java是通过虚拟机编译.java文件生成.class文件，而defineClass0方法就是通过模拟JVM编译Java文件的过程生成class文件的过程，这个过程包括编译原理，虚拟机的一些底层原理，已经不再本文的探讨范文之内了，也希望有了解的朋友科普一下，在此表示感谢！

　　 2：如何使用代理类，我们在使用newProxyInstance方法创建代理类的时候传入了一个InvocationHandler参数，这个接口里面有一个方法就是用来处理代理类的方法的，该类仅有一个invoke方法，可以通过反射去调用代理了的原有的逻辑，并在处理原有的逻辑的基础上增加一些额外的逻辑，方法原型如下。

　　

public Object invoke(Object proxy, Method method, Object[] args)
 throws Throwable;

 

　　 3：getProxyClass0是如何创建实例的,此方法没有什么特别的逻辑，仅做了一下简单的校验，然后就调用了proxyClassCache的get方法或者代理类对象，是不是感觉上面的KeyFactory和ProxyClassFactory没有用到呢？这个时候我们就需要重新看一下Field里面的proxyClassCache初始化的时候传入了keyFactory和ProxyClassFactory具体的逻辑都在该类的get方法里面了。具体的实现逻辑请参照WeakCache，为了文章的专一性，本文就不再对WeakCache做介绍了，后面会有一篇专门的文章介绍WeakCache。

　　

private static Class ? getProxyClass0(ClassLoader loader,
 Class ? ... interfaces) {
 if (interfaces.length 65535) {
 throw new IllegalArgumentException("interface limit exceeded");
 }
 //假如代理类已经在被给的ClassLoader和代理类实现的接口已存在，那就简单的返回缓存的副本，否则的话，就通过ProxyClassFactory创建一个新的代理类
 return proxyClassCache.get(loader, interfaces);
}

 

　　到此为止，我们已经把Proxy中如何创建代理类的过程和原理有了完整的了解，当然还一些不完整的地方和不恰当的地方希望热心的朋友指出和补充。

　　

　　以上就是动态代理原理（动态代理原理怎么理解）的详细内容，想要了解更多 动态代理原理的内容，请持续关注盛行IT软件开发工作室。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

标签： java

相关文章阅读

  • java Springboot集成mybatis-plus的方法是什么
  • 浅谈几种Java自定义异常处理方式
  • Java Map所有的值转为String类型
  • java代码中格式化金额 java格式化小数
  • java计算器源代码资源 java计算器简单代码
  • 【java】（一）SpringBoot 源码解析——SpringApplication 初始化（）
  • Spring学习笔记（spring教程 csdn）
  • HDFS Architecture Guide（）
  • 哈工大软件构造Lab3（2022）（哈工大软件构造lab3）
  • nginx基础（nginx基础教程）
  • Java 中HashMap详解(含HashTable, ConcurrentHashMap)（java hashmap使用方法）
  • Java 线程池之Jetty 线程池学习总结（java线程池的使用方法）
  • java线程基础（java 线程教程）
  • 聊聊 Netty 那些事儿之 Reactor 在 Netty 中的实现(创建篇)（）
  • nginx（nginx负载均衡）
    • 留言与评论（共有 条评论）
       
    验证码：