作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO

联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬

我之前对反射的理解未必精确却代表了自己当时所能理解的限度...每写完一篇文章，我都能感受到原本一个个孤立的知识由点到线，由线到面，最终拔地而起变成一个个立体的概念，让我有机会站在更高的地方去环视周围这个广袤无垠的程序世界。

这感觉，会上瘾。

由于反射本身确实抽象（说是Java中最抽象的概念也不为过），所以我当初写作时也用了大量的比喻。但是比喻有时会让答案偏离得更远。前阵子看了些讲设计模式的文章，把比喻都用坏了。有时理解比喻，竟然要比理解设计模式本身还费劲...那就南辕北辙了。所以，这一次能不用比喻就尽量不用，争取用最实在的代码去解释。

---

JVM是如何构建一个实例的

本文涉及的名词及其对应关系

• 内存：即JVM内存，栈、堆、方法区啥的都是JVM内存（不考虑JDK1.8元空间的区别）
• .class文件：就是所谓的字节码文件，这里称.class文件，直观些

假设main方法中有以下代码：

Person p = new Person();

很多初学者会以为整个创建对象的过程是下面这样的：

javac Person.java

java Person

不能说错，但是粗糙了一点。

稍微细致一点的过程可以是下面这样的：

通过new创建实例和反射创建实例，都绕不开Class对象。

.class文件

有人用编辑器打开.class文件看过吗？

比如我现在写一个类：

用vim命令打开.class文件，以16进制显示就是下面这副鬼样子：

在计算机中，任何东西底层保存的形式都是0101代码。

.java源码是给人类读的，而.class字节码是给计算机读的。根据不同的解读规则，可以产生不同的意思。就好比“这周日你有空吗”，合适的断句很重要。

同样的，JVM对.class文件也有一套自己的读取规则，不需要我们操心。总之，0101代码在它眼里的样子，和我们眼中的英文源码是一样的。

类加载器

在上一小节中，我们了解到.class文件是由类加载器加载的。由于本文是介绍反射的，所以关于类加载器就不做太细节的介绍，ClassLoader类负责加载类，它的核心方法是loadClass()，传入需要加载的类名，它会帮你加载：

protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    synchronized (getClassLoadingLock(name)) {
        // 首先，检查是否已经加载该类
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                // 如果尚未加载，则遵循父优先的等级加载机制（所谓双亲委派机制）
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // ClassNotFoundException thrown if class not found
                // from the non-null parent class loader
            }

            if (c == null) {
                // 模板方法模式：如果还是没有加载成功，调用findClass()
                long t1 = System.nanoTime();
                c = findClass(name);

                // this is the defining class loader; record the stats
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

// 子类应该重写该方法
protected Class<?> findClass(String name) throws ClassNotFoundException {
    throw new ClassNotFoundException(name);
}

加载.class文件大致可以分为3个步骤：

1. 检查是否已经加载，有就直接返回，避免重复加载
2. 当前缓存中确实没有该类，那么遵循父优先加载机制（双亲委派机制），加载.class文件
3. 上面两步都失败了，调用findClass()方法加载

需要注意的是，ClassLoader类本身是抽象类，而抽象类是无法通过new创建对象的，所以它并没有实现最核心的findClass()方法，直接抛了异常。此处又是应用了模板方法模式，具体的findClass()方法丢给子类实现。

所以正确的做法是，子类重写覆盖findClass()，在里面写自定义的加载逻辑。比如：

@Override
public Class<?> findClass(String name) throws ClassNotFoundException {
	try {
		/*自己另外写一个getClassData()
                  通过IO流从指定位置读取xxx.class文件得到字节数组*/
		byte[] datas = getClassData(name);
		if(datas == null) {
			throw new ClassNotFoundException("类没有找到：" + name);
		}
		//调用类加载器本身的defineClass()方法，由字节码得到Class对象
		return defineClass(name, datas, 0, datas.length);
	} catch (IOException e) {
		e.printStackTrace();
		throw new ClassNotFoundException("类找不到：" + name);
	}
}

defineClass()是父类ClassLoader里定义的方法，目的是根据.class文件的字节数组byte[] b造出一个对应的Class对象。我们无法得知具体是如何实现的，因为最终它会调用一个native方法：

这里模板方法模式有点绕，我画一张图解释一下：

反正，目前我们关于类加载只需知道以下信息：

Class类

现在，.class文件已经被类加载器加载到内存中，并且JVM根据其字节数组创建了对应的Class对象。

接下来，我们来研究一下Class对象，我们将在这一小节一步步分析Class类的结构。

但是，在看源码之前，我想问问聪明的各位，如果你是JDK源码设计者，你会如何设计Class类？

假设现在有个BaseDto类：

上面类至少包括以下信息（按顺序）：

• 权限修饰符
• 类名
• 参数化类型（泛型信息）
• 接口
• 注解
• 字段（重点）
• 构造器（重点）
• 方法（重点）

最终这些信息在.class文件中都会以0101表示：

整个.class文件最终都成为字节数组byte[] b，里面的构造器、方法等各个“组件”，其实也是字节。

既然Class要描述.class文件，我猜Class类的字段至少是这样的：

好了，看一下源码是不是如我所料。

还真是！

字段、方法、构造器对象：

注解数据

泛型信息

等等。

而且，针对字段、方法、构造器，因为这三个部分信息量太大了，JDK单独写了三个类：Field、Method、Constructor。我们挑Method类看一下：

也就是说，Class类确实按我们所猜想的设置了很多字段来描述.class文件的结构，比如类名、注解、实现的接口等，但对于字段、方法、构造器等结构，由于细节其实非常多，每一个单独拎出来都能扯很久，为了更详细地描述这些重要信息，JDK单独写了三个类Field、Method、Constructor，每个类里面都有更加详细的对应关系。

而Class类持有这三个对象数组的引用即可（因为一个类可能有多个方法，所以Class要用Method[] methods保存）。

最终，原本UserController类中所有信息，都被“解构”后保存在Class类中。其中，字段、方法、构造器又用Field、Method等对象单独表示。

大概了解完Class类的字段后，我们来看看Class类的方法。

• 构造器

可以发现，Class类的构造器是私有的，我们无法手动new一个Class对象，只能由JVM创建。JVM在构造Class对象时，需要传入一个类加载器，然后才有我们上面分析的一连串加载、创建过程。

• Class.forName()方法

反正还是类加载器去搞呗。

• newInstance()

也就是说，newInstance()底层就是调用无参构造对象的newInstance()。

所以，本质上Class对象要想创建实例，其实都是通过构造器对象。如果没有空参构造对象，就无法使用clazz.newInstance()，必须要获取其他有参的构造对象然后调用对应的Constructor#newInstance(xxx)。

反射API

没啥好说的，在日常开发中反射最终目的主要两个：

• 创建实例
• 反射调用方法

创建实例

创建实例的难点在于，很多人不知道clazz.newInstance()底层还是调用Contructor对象的newInstance()，所以，要想调用clazz.newInstance()，必须保证编写类的时候有个无参构造，否则就要先获取对应的Constructor。

反射调用方法

讲完反射如何创建实例，我们再聊聊第二点：反射调用方法。难点有两个，初学者可能会不理解。

先来理清楚Class、Field、Method、Constructor四个对象的关系：

上面讲过了，Field、Method、Constructor对象内部有对字段、方法、构造器更详细的描述：

OK，理清关系后我们正式来研究如何利用反射调用方法。

• 难点一：为什么根据Class对象获取Method时，需要传入方法名+参数的Class类型？

也就是Class#getMethod()为什么需要methodName和ParameterType？

这是因为.class文件中通常有不止一个方法，比如：

所以必须传入name，以明确本次需要调用的方法，得到该方法对应的Method对象。

OK，明白了。但是参数parameterTypes为什么要用Class类型，像调用普通方法那样直接传变量名不行吗，比如getUserByName(username)。

答案是：JVM判定方法重载的依据是参数列表，包括参数类型及参数个数，但不包括变量名：

User getUser(String userName, int age); User getUser(String mingzi, int nianling);

仅仅是变量名不同不叫重载，本质是同一个方法。

你可能还不死心，可能会追问：变量名不行，那我能不能传String, int。

不好意思，这些都是基本类型和引用类型，类型不能用来传递（你见过方法传参传一个String、Int的吗）。我们能传递的要么值，要么对象（引用）。而String.class, int.class是对象，且是Class对象。

从方法设计的角度，方法对应Method，方法的参数对应String.class、int.class才是对等的。

实际上，调用Class对象的getMethod()方法时，内部会循环遍历所有Method，然后根据方法名methodName和参数类型parameterType匹配唯一的Method返回：

• 难点二：调用method.invoke(obj, args)时为什么要传入一个目标对象？

上面分析过，.class文件通过IO被加载到内存后，JDK创造了至少四个对象：Class、Field、Method、Constructor，这些对象其实都是0101010的抽象表示。

以Method对象为例，它到底是什么，怎么来的？

我们上面已经分析过，Method对象有好多字段，比如name（方法名），returnType（返回值类型）等。也就是说我们在.java文件中写的方法，被“解构”为一个个Method对象，即对象本身是一个方法的映射，一个方法对应一个Method对象。

我在专栏的另一篇文章中讲过，对象的本质就是用来存储数据的，而方法作为一种行为描述，是所有对象共有的，不属于某个对象独有。比如现有两个Person实例：

Person p1 = new Person();
Person p2 = new Person();

对象 p1保存了"hst"和18，p2保存了"cxy"和20，但是不管是p1还是p2，都会有changeUser()，而每个对象里面写一份太浪费。既然是共性行为，可以抽取出来，放在方法区共用。但这又产生了一个棘手的问题，方法是共用的，JVM如何保证p1调用changeUser()时，changeUser()不会跑去把p2的数据改掉呢？

所以JVM设置了一种隐性机制，每次对象调用方法时，都会隐性传递当前调用该方法的对象参数，方法可以根据这个对象参数知道当前调用本方法的是哪个对象！

同样的，在反射调用方法时，本质还是希望方法处理数据，所以必须告诉它去处理哪个对象的数据。

大家仔细看，就会更加理解什么是反射：

• 黑色细线是正向方法调用
• 绿色粗线是反射方法调用

重新理解反射

最好把Class/Method/Field等理解为方法执行指令，它更像是一个方法执行器，必须告诉它要执行的对象（数据）。当然，如果是invoke一个静态方法，不需要传入具体的对象，因为静态方法是属于类的。

大家有没有看过成龙的《醉拳》，酒鬼师傅为了教成龙功夫，用两根竹竿拴住他的双手，操作他做出各种招式。Method也是如此，原本是对象自己调用方法，现在则是反射调用方法。但前提是，必须要有对象。

这里的成龙就是Object对象，师傅就是Class/Method/Field，竹竿就是反射工具，整个行为就是反射！这些动作，成龙本人当然可以做（正向自发），但现在则是由师傅引导他做（反向被动）。

至于很多人会疑惑的为啥反射需要我们传入Object，有了Object不就可以自己调用了吗？这纯属学习学糊涂了...

没有成龙这个具体的人，师傅的着力点就没了，就是对空气瞎比划，恐怖不恐怖啊。一个招式，肯定要有具体的发力者的。

至于有了Object为啥不直接调用Object？这是因为你看的角度不对。现在你要做的是，在还不知道是哪位徒弟、甚至没有徒弟的时候，师傅就要先准备好这一套训练方法。后面如果有人要学醉拳，直接套上就可以了。也就是说，反射是一种面向未来的通用处理方式，未来虽未来，但我的代码已经存在！

作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO

进群，大家一起学习，一起进步，一起对抗互联网寒冬