开发者社区> 问答> 正文

[@徐雷frank][¥20]Java 里的反射机制

brian_106 2018-11-06 22:56:08 21635

Java的反射实现是委派实现还是动态实现?委派实现和动态实现是按照什么机制去识别实现的?即什么情况下用委派实现,什么情况下动态实现?

分享到
取消 提交回答
全部回答(9)
  • 徐雷frank
    2019-07-17 23:12:34
    已采纳

    1.Java的反射机制应该都是运行时动态实现的,动态通过元数据获取类型信息,创建对象,实现调用。
    2.动态反射需要知道类名或者非法名关键字,中间够基于哈希搜索,快速定位类型或者非法信息。
    3.Java的反射机制现在应用比较多的是动态代理proxy,主要是在RPC和AOP领域。
    4.委派,你说的意思应该是delegate,也叫委托,一种设计模式,委派方式委派其他对象干活,这个工作自己不了。
    5.动态代理模式,支持的功能几乎和被代理对象一样。
    6.当有严格要求需要代理和被代理类方法一致,例如RPC或者AOP中,基于接口约束,使用反射的动态代理比较好。
    当有特殊的封装,比如要调用一个加密或者日志对象完成其他工作,不需要接口约束,可以使用委托,委托内部可以反射创建对象。

    1 0
  • 游客fhmxaonf47fes
    2019-07-17 23:12:34

    java的反射机制在底层是基于虚拟机实现的。一般是运行时根据当时的context(主要是class loader)动态分析与计算出具体被反射的结果。这种时候的context class loader 多半是双亲委派加载方案。

    0 0
  • itxiaowang
    2019-07-17 23:12:34

    java的反射机制在底层是基于虚拟机实现的。一般是运行时根据当时的context(主要是class loader)动态分析与计算出具体被反射的结果。这种时候的context class loader 多半是双亲委派加载方案。

    0 0
  • galaxystar
    2019-07-17 23:12:34

    反射不分委派不委派吧,反射就是通过动态获取class字节码信息去执行

    0 0
  • 天雷henry
    2019-07-17 23:12:34

    我们首先来观察一下Method.invoke()方法。相关源代码在java.lang.reflect包下的Method类中。
    public Object invoke(Object obj, Object... args)

        throws IllegalAccessException, IllegalArgumentException,
           InvocationTargetException
    {
        // 权限检查,忽略 ...
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, obj, modifiers);
            }
        }
        // 看这里 ...
        MethodAccessor ma = methodAccessor; // read volatile
        if (ma == null) {
            ma = acquireMethodAccessor();
        }
        return ma.invoke(obj, args);
    }
    

    可以看到,这里讲方法的调用,委派给了MethodAccessor类型的ma对象来处理。它是一个接口,有两个实现类。一个委派实现(DelegatingMethodAccessorImpl),一个本地实现(NativeMethodAccessorImpl)。每一个Method实例的第一次调用,都会使用委派实现!,但是委派实现最终委派的实现确实本地实现。下面通过里一个例子观察一下:

    public class HowReflect {

    public static void targetMethod(int i) {
        // 打印调用栈
        new Exception("version " + i)
                .printStackTrace();
    }
    
    public static void main(String[] args) throws Exception {
        Class<?> howReflect = Class.forName("com.ynwa.jvm.HowReflect");
        Method method = howReflect.getMethod("targetMethod", int.class);
        // 执行方法
        method.invoke(null, 0);
    }

    }

    上面的代码运行结果为:
    java.lang.Exception: 版本 0

    at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:13)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    // 4 委派实现又委派给了本地实现
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    // 3 生成委派实现
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    // 2 反射调用方法
    at java.lang.reflect.Method.invoke(Method.java:498)
    // 1 执行main方法
    at com.ynwa.jvm.HowReflect.main(HowReflect.java:21)
    

    上面在结果打印的调用栈中,注释的第3步个第4步,可以看到先用的委派实现,委派实现又委派了本地实现!
    那么问题来了!既然最终要用本地实现,那么为什么中间要加一层委派实现?,那么继续向下看。
    其实这是因为除了以上两种以外,还有一种动态实现,而所谓的委派实现,只不过是为了能够在本地实现和动态实现之间做切换。动态实现是一种字节码技术。
    但是如果只调用一次的话,本地实现要比动态实现块一点儿,这是因为动态实现操作字节码要慢一些。JVM会认为你每次只会很少的进行方法调用(或者说只调用一次),所以它设定了一个阀值:16,如果调用15此以上,也就是说第17次开始,使用动态实现。使用本地实现的时候,因为要经过Java -> c++ -> Java的过程。第17次开始,JVM会利用已经生成的字节码来进行方法调用,所以这无疑就会增速很多!

    0 0
  • 双持
    2019-07-17 23:12:34

    学习了

    0 0
滑动查看更多