漫谈Java反射

序言

看试手，补天裂。

今天来总结一下Java反射，在它面前，任何事物没有任何隐私。

什么是Java反射？

将类的各个组成部分封装为其他对象，这就是反射机制。

Java中的反射机制是指在运行状态中，对于任意一个类都能够知道这个类所有的属性和方法；并且对于任意一个对象，都能够调用它的任意一个方法；这种动态获取信息以及动态调用对象方法的功能成为Java语言的反射机制。

让Java可以在运行时，根据传入的类名字符串，去执行这个类存在的方法。

举个例子，Java代码在计算机中经历的三个阶段：

• source源代码阶段：此时刚刚编译为字节码，仍然保存在硬盘上。

• Class类对象阶段：类加载器把Person.class字节码加载进内存。

  对于java来说，万物皆对象，那么这时内存里会有一个Person这个类的类对象，也就是Class类对象，这个东西就很抽象。

  在Java里面有个类叫做Class，它是来描述所有字节码物理文件的一些共同特征和行为。例如成员变量，构造方法，普通的成员方法。

  Class类对象会对重点内容进行封装成成员变量：

  成员变量 ——-> Field对象，Field[] fields

  构造方法 ——-> Constructor对象，Constructor[] cons

  成员方法 ——-> Method对象，Method[] methods

• 运行时阶段：这个时候类对象已经实例化成为了一个对象

好处：

1. 可以在程序运行过程中，操作对象。例如：获取，设置
2. 可以降低程序耦合性，提高程序的扩展性

如何获取Class类对象？

字节码文件阶段

Class.forname(“全类名”)//包名.类名

将字节码文件加载进内存 返回Class类对象

内存阶段

类名.class

当class字节码加载进内存，那么这个Class类对象就有一个类名属性，可以用来索引

运行时阶段

对象.getClass()

所有对象的父类都是Object类，这个类有自己的getClass方法，所有对象都可以拿来用

注意⚠️

类名.class 最安全 性能最好

Class.forName() 属于动态加载类。将字节码文件加载进内存，参数需要类的全限定名

使用类名.class来创建Class对象的引用时，不会自动初始化该Class对象

使用Class.forName()会自动初始化该Class对象

Class.forName() 方法 当类加载进了内存，只有静态初始块得到了执行。

getDeclaredxxx 不能获取父类的方法

实例demo

字节码阶段

//Class.forName("全类名")
Class cls1 = Class.forName("domain.Person");
System.out.println(cls1);

内存阶段

//类名.class属性
Class cls2 = Person.class;
System.out.println(cls2);

运行时阶段

//对象.getClass()方法
Person p = new Person();
Class cls3 = p.getClass();
System.out.println(cls3);

小细节

//用==去比较三个class类对象，==比较的是对象的内存地址，如果内存地址相同，那么就是同一个对象
System.out.println(cls1 == cls2);//true
System.out.println(cls1 == cls3);//true
//结论：同一个字节码文件（xx.class）在一次程序运行的过程中，只会被加载一次
//不论是哪种方式获取的Class类对象，都是同一个。

实例对照

下面看一个demo：

public class Person {
    private String name;
    private int age;
  	//public String a;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
  	public void eat(){
        System.out.println("eat...");
    }
  	public void eat(String food){
        System.out.println("eat..."+food);
    }
}

获取Fields

获取成员变量们：

• Fields[] getFields()：只能获取所有public修饰的成员变量
• Fields getField(String name)：获取特定成员变量
• Fields[] getDeclaredFields()：获取所有的成员变量，【不考虑】修饰符，不考虑继承
• Fields getDeclaredField(String name)：获取特定的成员变量，【不考虑】修饰符，不考虑继承

Class personClass = Person.class;
//Fields[] getFields()：只会获取全部的【public修饰】的成员变量
Field[] fields = personClass.getFields();
for (Field field : fields) {
    //由于都是private，什么都不输出
    System.out.println(field);
}

//这里新增测试字段 public a
//public String a;
Class personClass = Person.class;
Field a = personClass.getField("a");
//获取成员变量a的值
Person p = new Person();
Object value = a.get(p);
System.out.println(value);//null
//设置a的值
a.set(p,"张三")；
System.out.println(p);//Person{name='null',age=0,a='张三'}

//这里新增测试字段private d
//private String d
Class personClass = Person.class;
Field[] declaredFields = personClass.getDeclaredFields();
// 获取所有的成员变量，不考虑修饰符，这个方法超级暴力
for (Field declaredField : declaredFields) {
    //由于都是private，什么都不输出
    System.out.println(declaredField);
}

Class personClass = Person.class;
Person p = new Person();
Field d = personClass.getDeclaredField("d");
//当访问private时，忽略访问权限符的安全检查
//暴力反射
d.setAccessible(true);
Object value= d.get(p);
System.out.println(value);//null,因为初始化，还没有设置值

获取Constructor

获取构造方法们：

Constructor[] getConstructors()

Constructor getConstructor(类 <?> … parameterTypes)

Constructor getDeclaredConstructors()

Constructor getDeclaredConstructor(类 <?> … parameterTypes)

Class personClass = Person.class;
Constructor constructor = personClass.getConstructor(String.class,int.class);//每一个构造方法的参数种类不一样，这一步是获取构造方法
System.out.println(constructor);
//所以可以执行构造函数，进而创建对象，[构造器.newInstance]
Object person = constructor.newInstance("张三", 23);//传递对应的参数值
System.out.println(person);//Person{name=‘张三‘，age=’23‘}

Class personClass = Person.class;
//对于无参的构造方法，可以直接使用Class类对象的newInstance方法
Object o = personClass.newInstance();
System.out.println(o);

获取Methods

获取成员方法们：

Method[] getMethods()//获取所有【public】修饰的方法，父类Object的方法也能看到

Method getMethod(String name，类 <?> … parameterTypes)

Method[] getDeclaredMethods()//获取所有声明方法 不考虑修饰符 不考虑继承的方法

Method getDeclaredMethod(String name，类 <?> … parameterTypes) 不考虑修饰符 不考虑继承的方法

Class personClass = Person.class;
//获取制定名称的方法
Method eat_Method = personClass.getMethod("eat");
//进而执行方法,【invoke】，它需要一个真实的对象，以及方法的实际参数列表
Person pp = new Person();
//因为是空参方法，所以直接放进来一个对象就行
//执行方法，eat...
eat_Method.invoke(pp);

Class personClass = Person.class;
Method eat_Method2 = personClass.getMethod("eat",String.class);//eat方法重载，eat方法的需要传入的参数是String类型
eat_Method2.invoke(pp,"jiaozi");//吃饺子

Class personClass = Person.class;
Method[] methods = personClass.getMethods();//获取所有public方法名
//获取类名
String className = personClass.getName;//获取类名
System.out.println(className);//包名.类名
for (Method method : methods) {
    //也支持暴力反射：method.setAccessible(true);
    System.out.println(method);
    //获取所有方法名
    String methodname = method.getName();
    System.out.println(methodname);

灵魂体现

这里引入一个实际利用中的小demo：

public void execute(String className, String methodName) throws Exception {
    Class clazz = Class.forName(className);    
    clazz.getMethod(methodName).invoke(clazz.newInstance()); 
}

这里分步解读：

1. 首先两个参数：className、methodName分别代表了传入的类名和方法名。
2. 首先Class clazz = Class.forName(className);这里的意思是在字节码层面，先获取你的Class类对象clazz。
3. 接下来clazz.getMethod(methodName).invoke(clazz.newInstance());这里的含义可以分步解读：
   1. clazz.getMethod(methodName)这里我先根据传进来的方法名methodName获取你的Method对象;
   2. 接下来.invoke(clazz.newInstance())这个含义是对于我获取的method方法对象，我要执行这个方法，那么问题来了，我如何才能执行这个方法呢？？？
   3. 这里我先clazz.newInstance()，这一手的含义是我要先生成一个指定类的对象，那么如何生成呢？之前我已经获取了Class类对象，那么就可以用这个类对象来生成这个类的实例化对象
   4. clazz.newInstance()这样就可以生成一个实例化对象了
   5. 那么有了类的实例化对象之后，直接放入invoke参数里面，就可以凭借我们之前的Method对象来执行这个特殊的className方法了!

说了这么多嗷，我分步拆开来写一下，会更清晰一些：

public void execute(String className, String methodName) throws Exception {
  		//首先找到类对象
  		Class clazz = Class.forName(className);
  		//根据类对象找到Method方法对象
      Method mtd = clazz.getMethod(methodName);
  		//动态生成类实例化对象obj
      Object obj = clazz.newInstance();
  		//调用类中方法mtd
      mtd.invoke(obj); 
  }

以下一步步使用反射机制实现Runtime.getRuntime().exec("calc.exe");这个语句

• getRuntime()：其实就是Runtime类获取对象的方式，等于new一个Runtime类。之所以封装成一个函数是为了不调用一次建立一个对象，只获取一个对象来执行操作。
• exec()：调用exec函数
• calc.exe：调用计算器程序

类的初始化

这里我再写一个小demo：

package domain;

public class TrainPrint {
    //初始块
    {
        System.out.printf("Empty block initial %s\n", this.getClass());
    }
    //静态初始块
    static {
        System.out.printf("Static initial %s\n", TrainPrint.class);
    }
    //构造函数
    public TrainPrint() {
        System.out.printf("Initial %s\n", this.getClass());
    }
}

首先我写一个测试类，对于这个测试类，它有初始块，静态初始块，构造函数。

那么下面我来获取它的Class对象，想看看当这个TrainPrint测试类加载进内存之后，哪些部分执行了，好主意，说写就写：

首先类的初始化:

package reflect;

import java.io.IOException;
import domain.TrainPrint;

public class initTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Class.forName("domain.TrainPrint");
    }
}

执行结果：Static initial class domain.TrainPrint

这说明当类加载进了内存，只有静态初始块得到了执行。

那么类的实例化呢:

package reflect;

import java.io.IOException;
import domain.TrainPrint;

public class initTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        TrainPrint test= new TrainPrint();
    }
}

执行结果：

Static initial class domain.TrainPrint
Empty block initial class domain.TrainPrint
Initial class domain.TrainPrint

这也暴露了顺序：静态初始块->初始块->构造函数

补充：

具有父类的类的实例化：父类静态初始块->子类静态初始块->父类初始块->父类构造函数->子类初始块->子类构造函数

以上对于类初始化的说明其实就是说，单独一个Class.forName()，在类静态初始块可控的情况下，可以执行恶意代码。

调用内部类

Java的普通类 C1 中支持编写内部类 C2 ，而在编译的时候，会生成两个文件： C1.class 和 C1$C2.class，可以把他们看作两个无关的类。

Class.forName("C1$C2")可以调用这个内部类。

我们可以通过Class.forName("java.lang.Runtime")来获取类（java.lang.Runtime是Runtime类的完整路径）

getMethod

Java中支持类的重载，我们不能仅通过函数名来确定一个函数。所以，在调用 getMethod 的时候，我们需要传给他你需要获取的函数的参数类型列表，如下：
Class.forName("java.lang.Runtime").getMethod("exec", String.class)

invoke

invoke方法位于Method类下，其作用是传入参数，执行方法，
public Object invoke(Object obj, Object... args)
它的第一个参数是执行method的实例化对象：

• 如果这个方法是一个普通方法，那么第一个参数是类对象。
• 如果这个方法是一个静态方法，那么第一个参数是类（之后会提到，这里其实不用那么死板，null也行），它接下来的参数才是需要传入的参数。

由于我们的exec函数是一个普通方法，需要传入类对象，即invoke(类对象，exec方法传入的参数) 。
之前说到Runtime的类对象不能通过newInstance()来获取对象（class.newInstance等于new class）,是因为Runtime的类构造函数是一个private构造函数，只能通过getRuntime方法返回一个对象。

获取类对象：

(由于getRuntime是一个静态方法，invoke传入Runtime类，进行调用)

`invoke(Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"))，"calc.exe")`

合并：

```java
Class.forName("java.lang.Runtime").getMethod("exec", String.class).
                invoke(
                        Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(
                                Class.forName("java.lang.Runtime")),"/Applications/Calculator.app/Contents/MacOS/Calculator");

再简化一下：

Class clazz = Class.forName("java.lang.Runtime"); 
clazz.getMethod("exec", String.class).invoke(clazz.getMethod("getRuntime").invoke(clazz), "/Applications/Calculator.app/Contents/MacOS/Calculator");

详细解读，这里是一个疯狂套娃的过程：

1. 首先先要找到类对象，clazz，不多说了
2. 接下来我要告诉这个类对象我要执行的方法是exec，这个exec方法接受的参数类型是String类型，当然就是恶意命令字符串
3. 那么我们的invoke函数需要的操作就是invoke(类对象，exec方法等待接收的参数)，那么问题来了：Runtime类不允许newInstance()来实例化对象！！！但是他允许通过getRuntime方法返回一个对象，那么我就用getRuntime方法来返回一个对象！
4. 现在开始疯狂套娃！
5. 首先既然你不允许instance，那么我就在那个类对象的位置“套”出来一个对象！思路其实就是既然我没办法给你在那个位置“放”上一个实例化对象，那么我就在你的位置上使用反射invoke执行getRuntime方法，不就可以了么！
6. 那么就有了简化版代码！
7. 这里仔细看，可以看到，其实getRuntime方法它也是一个无参构造方法！

指定的构造方法生成类的实例

继续举一个演化成反射机制的执行命令payload的例子：

List<String> paramList = new ArrayList<>();
paramList.add("/Applications/Calculator.app/Contents/MacOS/Calculator");
ProcessBuilder pb = new ProcessBuilder(paramList);
pb.start();

可见，其构造函数是写入了一个字符串，不是无参构造方法，接下来我们会一步步进行转化。

ProcessBuilder有两个构造函数：

• public ProcessBuilder(List command)
• public ProcessBuilder(String... command)(此处，String...这种语法表示String参数数量是可变的，与String[]一样)

getConsturctor()函数可以选定指定接口格式的构造函数(由于构造函数也可以根据参数来进行重载)，getConsturctor(参数类型)

选定后我们可以通过newInstance(),并传入构造函数的参数执行构造函数，即newInstance(传入的构造函数参数)。

start函数不是一个静态函数,需要传入类的实例，所以这里可以继续使用反射：

Class clazz = Class.forName("java.lang.ProcessBuilder"); 
clazz.getMethod("start").invoke(clazz.getConstructor(List.class).newInstance(Arrays.asList("/Applications/Calculator.app/Contents/MacOS/Calculator")));

这里还有一种方式：

//这个可以传入多个字符串
ProcessBuilder pb = new ProcessBuilder("/Applications/Calculator.app/Contents/MacOS/Calculator");
pb.start();

那么payload就这样写吧：

Class clazz = Class.forName("java.lang.ProcessBuilder"); 
((ProcessBuilder)clazz.getConstructor(String[].class).newInstance(new String[]{"/Applications/Calculator.app/Contents/MacOS/Calculator"})).start();

但是实际上我们这样调用是会报错的，因为newInstance函数接受参数是一个Object..也就是Object数组，它会完美契合我们提供的String[]，剥去一层数组。

那就再套一层：

Class clazz = Class.forName("java.lang.ProcessBuilder"); 
((ProcessBuilder)clazz.getConstructor(String[].class).newInstance(new String[][]{{"/Applications/Calculator.app/Contents/MacOS/Calculator"}})).start();

执行私有方法

以上都是方法或构造方法是public函数，但是如果是私有方法，该如何调用？
之前用的都是getMethod、getConstructor，接下来需要使用getDeclaredMethod、getDeclaredConstructor：

• getMethod等方法获取的是当前类中所有公共方法，包括从父类继承的方法
• getDeclared等方法获取的是当前类中“声明”的方法，是实在写在这个类里的，包括私有的方法，但从父类里继承来的就不包含了

之前说到Runtime的构造方式是一个私有方法，从而不能直接调用，那么接下来我就来调用Runtime的构造方法来获取一个实例来执行计算器弹出：

Class clazz = Class.forName("java.lang.Runtime"); 
Constructor m = clazz.getDeclaredConstructor(); 
m.setAccessible(true); //暴力反射
clazz.getMethod("exec", String.class).invoke(m.newInstance(), "/Applications/Calculator.app/Contents/MacOS/Calculator");

在获取到私有方法后，通过setAccessible(true)可以打破私有方法访问限制，从而进行调用。

从Commons-collections收获的一点反思

对于正常的反射模板：

Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"))

但其实我们很容易忽略反射机制中调用的函数实际上可以在两个不同的class中调用，就像好比有一个函数可以在两个class中调用。

在Commons-Collections的环境中，我们是没法得到Class.forName("java.lang.Runtime").getMethod(...)的，但是可以得到Class.forName("java.lang.Class").getMethod(...)。

可以理解为我们可以抓到Runtime的父类，那么就可以得到以下途径进行变形：

• 用反射机制去调用反射机制中使用的函数getMethod
• 使用invoke传入的obj去指定getMethod的当前的调用环境（在实际代码执行中是this变量的区别）

继续看一下Class类中getMethod方法的接口：

@CallerSensitive
public Method getMethod(String name, Class<?>... parameterTypes)////<?>... 表示任意类型任意数量的Class数组
    throws NoSuchMethodException, SecurityException {
    checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
    Method method = getMethod0(name, parameterTypes, true);
    if (method == null) {
        throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
    }
    return method;
}

那么我们传数组，来拿到getmethod这个方法不就行了么：

Method method1= Class.forName("java.lang.Class")
        .getMethod("getMethod", new Class[] {String.class, Class[].class });//根据getMethod方法接口进行封装

以下套娃警告！

这里的Class类，它有所有方法，我们就是先拿到getmethod这个方法，这里是为什么呢？因为对于想用反射来调用方法其他类的方法，你必须会用到getmethod方法（忘了的向上翻模板），这里就相当于我先把梯子拿到！

那么有了getmethod方法之后，我需要一个obj对象来调用呀，这个obj其实就是java.lang.Runtime。之前也说了，这个对象很有脾气，需要执行这个类下面的Runtime方法，才能实例化一个Runtime对象。

结合上面刚刚获取的getmethod梯子方法，继续写吧：

//以下语句执行结果等同于Class.forName("java.lang.Runtime").getMethod(getRunime)
method1.invoke(Class.forName("java.lang.Runtime"),"getRuntime",new Class[0]);
//用于对比：以下语句等同于Class.forName("java.lang.Class").getMethod(getRunime)
//method1.invoke(Class.forName("java.lang.Class"),"getRuntime",new Class[0]);

合起来就是：

// 1.正常的反射调用
Class.forName("java.lang.Runtime").getMethod("getRuntime")
// 2.经过变形的反射调用，需要绕一圈
Class.forName("java.lang.Class")
    .getMethod("getMethod", new Class[] {String.class, Class[].class })//得到getMethod方法
   .invoke(Class.forName("java.lang.Runtime"),"getRuntime",new Class[0]);//new Class[0]其实就是占位

new Class[0]其实就是占位，因为阅读源码能看到invoke方法参数规范，是硬性标准需要两个参数的，第二个是一个Object类的数组：

@CallerSensitive
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);
}

所以现在我们只是以Class.forName("java.lang.Class")开头获取到了Runtime类下的getRuntime方法。还没有执行。

神奇的invoke参数

自己写完总觉得invoke参数奇奇怪怪的，淦，研究一下。

invoke有一个非常神奇的特性，它不会那么严格地校验obj。回顾之前总结的invoke传参规则：

它的第一个参数是执行method的对象obj：

• 如果这个方法是一个普通方法，那么第一个参数是类对象
• 如果这个方法是一个静态方法，那么第一个参数是类
  它接下来的参数才是需要传入的参数。

但是，传入的第一个参数其实不一定要是正确的类或者类对象!

下面一个小例子：

//main函数
Class.forName("a").getMethod("print").invoke(null);
//内部类：
class a{
    public static void print(){
        System.out.println(1);
    }
}

按照规则，print函数是一个静态方法，实际上我们应该invoke传入一个a的类。但是以上代码的执行结果却是成功的：

但是如果print方法不是静态防范时就会执行失败：

这是因为invoke函数null抛出报错的机制导致的：

* @exception NullPointerException      
* if the specified object is null and the method is an instance method. //obj为null，并且method是一个实例method
*/
@CallerSensitive
public Object invoke(Object obj, Object... args){
}

当method是一个普通函数时，传入obj不能为null，并且其类对象要与方法匹配；但是当method是一个静态函数时，就很随便了(可能是因为压根不会被用到吧)。

这里我迷茫了好久，知道我看到这样一句话才弄懂：

类实例是其他类的实例，类实际上是Class.class这个类的实例。
这边之前的疑问是，getMethod不是静态方法而invoke中传入的是类而不是类实例。
实际上因为getMethod本来就是class类中的方法，而Class.forName("java.lang.Runtime")获取到的class类的实例
我们调用getMethod传入的不是之前的模糊类的概念，而是class类的实例（类实例），所以这里是没毛病的调用class类下的非静态方法，传入class类实例。

回来继续构造调用

上面我们只是获取到了getRuntime方法，我们还没有调用这个方法获取其Runtime对象

//普通调用形式
Runtime.getRuntime()
// 反射调用
Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"))
// 经过变形的反射调用
Method method = (Method) Class.forName("java.lang.Class")
                .getMethod("getMethod", new Class[] {String.class, Class[].class })//得到getMethod方法，这个方法需要两个型参，这里要列好，分别是String和Class
  .invoke(Class.forName("java.lang.Runtime"),"getRuntime",new Class[0]);//调用getMethod方法，得到getRuntime方法
//以上等于执行Class.forName("java.lang.Runtime").getMethod("getRuntime")
//调用Runtime.getRuntime函数，传入的obj根据上面的分析可以随便写
method.invoke(Class.forName("java.lang.Runtime"),new Object[0]);
method.invoke(null,new Object[0]);
method.invoke(Class.forName("java.lang.String"),new Object[0]);

搞懂invoke函数

直接上源码：

package java.lang.reflect;
public final class Method extends AccessibleObject implements GenericDeclaration,Member...
public Object invoke(Object obj, Object... args)
        throws IllegalAccessException, IllegalArgumentException,
           InvocationTargetException
{
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass(1);

                checkAccess(caller, clazz, obj, modifiers);
            }
        }
        MethodAccessor ma = methodAccessor;             // read volatile
        if (ma == null) {
            ma = acquireMethodAccessor();
        }
        return ma.invoke(obj, args);
}

override参数

它是父类AccessibleObject的一个属性，AccessibleObject这个类有三个子类：构造函数、属性、方法。

override这个值默认是false，但是我们可以通过method.setAccessible(true)来改掉它的值。

Reflection.quickCheckMemberAccess(clazz, modifiers)

如果是override是默认值false，那么继续往下走。

我们这里假设：m.invoke(obj,args)

参数：

• clazz：m所属类的Class对象

• args：m的所需参数

这里quickCheckMemberAccess先检查Class对象是不是public的。

• 如果是public,那么就跳出本方法；

• 如果不是public,那继续来到Reflection.getCallerClass(1);

  这是一个native方法，返回的是获取调用这个方法的Class对象，赋值给caller

  public static native Class<?> getCallerClass();

checkAccess

然后通过checkAccess(checkAccess(caller, clazz, obj, modifiers)做一次快速的权限校验

不难看出，还进行了一个很简单的缓冲机制，只适用于一个类的重复调用。

MethodAccessor ma = methodAccessor;

接下来是重头戏：

MethodAccessor ma = methodAccessor;             // read volatile
if (ma == null) {
	ma = acquireMethodAccessor();
}
return ma.invoke(obj, args);

首先要了解Method对象的基本构成，每个Java方法有且只有一个Method对象作为root，它相当于根对象，对用户不可见。当我们创建Method对象时，我们代码中获得的Method对象都相当于它的副本（或引用）。root对象持有一个MethodAccessor对象，所以所有获取到的Method对象都共享这一个MethodAccessor对象，因此必须保证它在内存中的可见性。
当第一次调用一个Java方法对应的Method对象的invoke()方法之前，实现调用逻辑的MethodAccessor对象还没有创建(第一次调用，methodAccessor属性为null)，所以通过reflectionFactory创建MethodAccessor并更新给root，然后调用MethodAccessor.invoke()完成反射调用。

具体细看，可以看到invoke方法实际是委派给了MethodAccessor类型的ma对象来处理。MethodAccessor是一个接口，主要有两个实现类。

一个委派实现(DelegatingMethodAccessorImpl)，一个本地实现(NativeMethodAccessorImpl)。这里调用的委派实现主要是为了在本地实现和动态实现之间做切换。考虑到许多反射调用仅会执行一次，Java虚拟机设置了一个阈值15(是从0开始计算,>15)：

• 当某个反射调用的调用次数<=15 时，采用本地实现；
• 当大于15时，便开始动态生成字节码，并将委派实现的委派对象切换至动态实现。这个过程我们称之为Infation。

这里我们以NativeMethodAccessorImpl本地实现为例：

每次调用其invoke时会做一个累加，判断是否到达阙值，如果没有则调用native的invoke0方法，当超过时则调用MethodAccessorGenerator.generateMethod()，并将其设置到DelegatingMethodAccessorImpl的delegate，这样下次就会直接调用到动态实现的位置。

m.invoke(o，args)

invoke0参数：

• this.method 就是m
• var1就是o，如果m是静态方法的话，这里写null也可以
• var2就是args参数

我们重点分析一下invoke0这个native方法：

JNIEXPORT jobject JNICALL Java_sun_reflect_NativeMethodAccessorImpl_invoke0
(JNIEnv *env, jclass unused, jobject m, jobject obj, jobjectArray args)
{
    return JVM_InvokeMethod(env, m, obj, args);
}

借用ruilin的图，继续看JVM_InvokeMethod方法：

发现提到了oop，简单写一下oop-klass理解：

JVM就是用这种方式，将一个对象的数据和对象模型进行分离。普遍意义上来说，我们说持有一个对象的引用，指的是图中的handle(存放在栈区)，它是oop(存放在堆区)的一个封装。

关键点是：

oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);

跟进hotspot/src/share/vm/runtime/reflection.cpp

Reflection::invoke_method()中接受的method_mirror(oop)就是我们要反射调用的方法。然后代码调用了Reflection::invoke()，跟进之后最终到JavaCalls::call()执行

最后的os_exception_wrapper其实就是调用了call_help，也就是说本地实现的反射最终的方法执行是通过JavaCalls::call_helper方法来完成的。

总结

反射，永远滴神！