[@徐雷frank][¥20]Java 里的反射机制-问答-阿里云开发者社区-阿里云

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

在默认情况下，方法的反射调用为委派实现，委派给本地实现来进行方法调用。在调用超过 15 次之后，委派实现便会将委派对象切换至动态实现。这个动态的字节码是在Java运行过程中通过ASM自动生成的，它将直接使用 invoke 指令来调用目标方法。

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

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

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

我们首先来观察一下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会利用已经生成的字节码来进行方法调用，所以这无疑就会增速很多！