资讯专栏INFORMATION COLUMN

JDK动态代理

wangbjun / 580人阅读

摘要:用户在调用被动态代理过的对象的方法时,调用的请求会被自动发给代理对象实现了接口的方法,由方法来实现对请求的统一处理。动态代理实现切面代替该语句块一定会在前面执行。

用户在调用被动态代理过的对象的方法时,调用的请求会被自动发给代理对象(实现了InvocationHandler接口)的invoke()方法,由invoke()方法来实现对请求的统一处理。

源码分析

Java.lang.reflect.Proxy

public class Proxy implements java.io.Serializable {
private static final Class[] constructorParams =  { InvocationHandler.class };
private static final WeakCache[], Class>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
......

    @CallerSensitive
    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
        Class cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            //getConstructor(InvocationHandler.class) 获取代理类的构造器
            final Constructor cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            //代理类实例化返回
            return cons.newInstance(new Object[]{h});
        }  
    ......
}

 

private static Class getProxyClass0(ClassLoader loader, Class... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        // key为WeakReference,若缓存中存在相同key,则返回ProxyClass,若不存在,则用ProxyClassFactory创建ProxyClass。
        return proxyClassCache.get(loader, interfaces);  //java.lang.reflect.WeakCache 这个内核分析?
    }
......
 }
private static final class ProxyClassFactory implements BiFunction[], Class> {
        // 所有代理类ProxyClass名字的前缀 
        private static final String proxyClassNamePrefix = "$Proxy";

        // 用计数器生成代理类ProxyClass的名字
        private static final AtomicLong nextUniqueNumber = new AtomicLong();

        @Override
        public Class apply(ClassLoader loader, Class[] interfaces) {

            Map, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
//对每一个interface Class进行验证
            for (Class intf : interfaces) {
                /*
                 * Verify that the class loader resolves the name of this
                 * interface to the same Class object.
                 */
                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");
                }
                /*
                 * Verify that the Class object actually represents an
                 * interface.
                 */
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
                /*
                 * Verify that this interface is not a duplicate.
  * 用IdentityHashMap来验证interface Class的唯一性,因为IdentityHashMap的key比较是==,即比较内存地址。
                 */
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }

            String proxyPkg = null;      
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

            // 对于非公共接口,ProxyClass的包名设置为接口的包名    
            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");
                    }
                }
            }

            // 对于公共接口,ProxyClass的包名为com.sun.proxy  
            if (proxyPkg == null) {
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            long num = nextUniqueNumber.getAndIncrement();
            //ProxyClass的完全限定名
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            //由c++写的ProxyGenerator生成代理类的二进制字节码
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                // 根据二进制字节码返回相应的ProxyClass  
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {               
                throw new IllegalArgumentException(e.toString());
            }
        }
}
$Proxy.class

以下是反编译$Proxy0.class:

public final class $Proxy0 extends Proxy implements MyInterface1{  
  private static Method m1;  
  private static Method m3;  
  private static Method m0;  
  private static Method m2;  
 
  public $Proxy0(InvocationHandler paramInvocationHandler) {  
    super(paramInvocationHandler);  
  }  
  
  public final boolean equals(Object paramObject) {  
    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 void sayHello(String paramString) {  
    try {  
      this.h.invoke(this, m3, new Object[] { paramString });  
      return;  
    }  
    catch (Error|RuntimeException localError) {  
      throw localError;  
    }  
   catch (Throwable localThrowable) {  
      throw new UndeclaredThrowableException(localThrowable);  
    }  
  }  

  
  public final int hashCode() {  
    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() {  
    try {  
        return (String)this.h.invoke(this, m2, null);  
    }  
    catch (Error|RuntimeException localError) {  
      throw localError;  
    }  
    catch (Throwable localThrowable) {  
      throw new UndeclaredThrowableException(localThrowable);  
    }  
  }  
  
  static {  
    try {  
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });  
      m3 = Class.forName("com.mikan.proxy.MyInterface1").getMethod("sayHello", new Class[] { Class.forName("java.lang.String") });  
      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());  
    }  
  }  
} 

 

$Proxy0.class的总结:

对于要代理没有接口的类,则必须继承该没有接口的类,从而覆盖其方法,但由于java不能多继承,这里代理类已经继承了Proxy类了,不能再继承其他的类,所以JDK的动态代理不支持对实现类的代理,只支持接口的代理。

构造方法的入参为InvocationHandler,这说明该代理类是实现了InvocationHandler接口的类的代理类,而InvocationHandler实现类再代理真正的实体类

静态代码块会初始化真正实体类的Method对象,以及Object类的equals、hashCode、toString的Method对象

总结:
Proxy 会从内部类WeakCache中根据ClassLoader 和interfaces获取ProxyClass(若缓存中存在相同key,则返回ProxyClass,若不存在,则用ProxyClassFactory创建ProxyClass(由ProxyGenerator生成二进制码,再将写成*.class文件))。

AOP JDK动态代理实现

切面InvocationHandler:

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
    // BeforeAdvice  
    Object retVal = null;  
    try {  
        retVal = method.invoke(target, args);  // AroundAdvice 代替该语句      
        // AfterReturningAdvice  
    }  
    catch (Throwable e) {  
        // AfterThrowingAdvice  
    }  
    finally {  
        //finally块一定会在return前面执行。
        // AfterAdvice  
    }  
    return retVal;  
}  

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/67267.html

相关文章

  • Java中的动态代理

    摘要:要明白,动态代理类的存在意义是为了拦截方法并修改逻辑而动态代理的局限性之一就是只能拦截接口所声明的方法。因为动态代理类是继承自业务类,所以该类和方法不能声明成无法继承或重写。者最终都是生成了一个新的动态代理类对象。 动态代理 1、先谈静态代理 对于静态代理,我们已经很熟悉了。我们拥有一个抽象类,真实类继承自抽象类并重写其业务方法,代理类持有真实类的对象实例,在重写业务方法中通过调用真实...

    CastlePeaK 评论0 收藏0
  • Java设计模式综合运用(动态代理+Spring AOP)

    摘要:动态代理的核心是接口和类。以上结果说明它生成的代理类为,说明是代理。测试前提实现接口测试类使用接口方式注入代理方式必须以接口方式注入测试配置为,运行结果如下实际校验逻辑。。。。 本文也同步发布至简书,地址:https://www.jianshu.com/p/f70... AOP设计模式通常运用在日志,校验等业务场景,本文将简单介绍基于Spring的AOP代理模式的运用。 1. 代理模...

    王晗 评论0 收藏0
  • Java动态代理 jdk和cglib的实现比较

    摘要:与静态代理对比,动态代理是在动态生成代理类,由代理类完成对具体方法的封装,实现的功能。本文将分析中两种动态代理的实现方式,和,比较它们的异同。那如何动态编译呢你可以使用,这是一个封装了的库,帮助你方便地实现动态编译源代码。 发现Java面试很喜欢问Spring AOP怎么实现的之类的问题,所以写一篇文章来整理一下。关于AOP和代理模式的概念这里并不做赘述,而是直奔主题,即AOP的实现方...

    h9911 评论0 收藏0
  • 吃透动态代理,解密spring AOP源码(四)

    摘要:值得一提的是由于采用动态创建子类的方式生成代理对象,所以不能对目标类中的方法进行代理。动态代理中生成的代理类是子类,调试的时候可以看到,打开源码可看到实现了和也就实现方法。 前面讲到了动态代理的底层原理,接下来我们来看一下aop的动态代理.Spring AOP使用了两种代理机制:一种是基于JDK的动态代理,一种是基于CGLib的动态代理. ①JDK动态代理:使用JDK创建代理有一个限制...

    Codeing_ls 评论0 收藏0
  • JDK动态代理

    摘要:实际开发中的,通用异常处理,通用日志处理,事物处理都可以用到动态代理。四总结优点动态代理类简化了代码编程工作,提高了软件的可扩展性。 JDK的动态代理 一、静态代理 了解动态代理前,有必要先讲解下静态代理。 举个例子:银行开通了短信业务,在你取钱,存钱,转账后都会 给你发送短信,我们来模拟下业务场景。 静态代理的实现 下面来模拟下业务代码 1.定义IBankCardService接口 ...

    desdik 评论0 收藏0
  • JDK动态代理

    摘要:动态代理是包提供的方式,它必须借助一个接口才能产生代理对象,所以要预先定义接口。第步,建立代理对象和真实对象的关系。第个是把生成的动态代理对象下挂在哪些接口下,这个写法就是放在实现的接口下。 JDK动态代理是java.lang.reflect.*包提供的方式,它必须借助一个接口才能产生代理对象,所以要预先定义接口。 1. 接口 public interface Hello { ...

    qujian 评论0 收藏0

发表评论

0条评论

wangbjun

|高级讲师

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<