目录

何为反射？

反射(Reflection)，是指Java程序具有 在运行期 分析类以及修改其本身状态或行为的能力 。

通俗点说 就是 通过反射我们可以 动态地 获取一个类的所有属性和方法，还可以操作这些方法和属性。

实例的创建

一般我们创建一个对象实例 Person zhang = new Person();

虽然是简简单单一句，但JVM内部的实现过程是复杂的：

将硬盘上指定位置的Person.class文件加载进内存执行main方法时，在栈内存中开辟了main方法的空间（压栈-进栈），然后在main方法的栈区分配了一个变量zhang。执行new，在堆内存中开辟一个 实体类的 空间，分配了一个内存首地址值调用该实体类对应的构造函数，进行初始化（如果没有构造函数，Java会补上一个默认构造函数）。将实体类的 首地址赋值给zhang，变量zhang就引用了该实体。（指向了该对象）

其中上图步骤1 Classloader(类加载器) 将class文件加载到内存中具体分为3个阶段：加载、连接、初始化

而又在 加载阶段，类加载器 会 将类对应的.class文件中的二进制字节流读入到内存中，将这个字节流转化为方法区的运行时数据结构，然后在堆区创建一个**java.lang.Class 对象**（类相关的信息），作为对方法区中这些数据的访问入口

然后再通过 类的实例 来执操作 类的方法和属性 ，比如 zhang.eat(), zhang.getHeight() 等等

如果我们使用反射的话，我们需要拿到该类Person的Class对象，再通过Class对象来操作 类的方法和属性或者创建类的实例

Class personClass = Person.class;//这边只是举一个例子，获取class对象的多种方式，本文后面再慢慢道来Object person = personClass.newInstance();

我们可以发现 通过new创建类的实例和反射创建类的实例，都绕不开.class文件 和 Class类的。

.class文件

首先我们得先了解一下 什么是.class文件

举个简单的例子，创建一个Person类：

public class Person {    /**     * 状态 or 属性     */    String name;//姓名    String sex;//性别    int height;//身高    int weight;//体重        /**     * 行为     */    public void sleep(){    	System.out.println(this.name+"--"+ "睡觉");	}    public void eat(){        System.out.println("吃饭");    }    public void Dance(){        System.out.println("跳舞");    }}

我们执行javac命令，编译生成Person.class文件

然后我们通过vim 16进制 打开它

#打开file文件vim Person.class #在命令模式下输入.. 以16进制显示 :%!xxd #在命令模式下输入.. 切换回默认显示:%!xxd -r

不同的操作系统，不同的 CPU 具有不同的指令集，JAVA能做到平台无关性，依靠的就是 Java 虚拟机。

.java源码是给人类读的，而 .class字节码是给JVM虚拟机读的 ，计算机智能识别 0 和 1组成的二进制文件，所以虚拟机就是我们编写的代码和计算机之间的桥梁。

虚拟机将我们编写的 .java 源程序文件编译为 字节码 格式的 .class 文件，字节码是各种虚拟机与所有平台统一使用的程序存储格式，class文件主要用于解决平台无关性的中间文件

Person.class文件 包含Person类的所有信息

Class类

我们来看下jdk的官方api文档对其的定义：

Class类的类表示正在运行的Java应用程序中的类和接口。 枚举是一种类，一个注释是一种界面。 每个数组也属于一个反映为类对象的类，该对象由具有相同元素类型和维数的所有数组共享。

原始Java类型（ boolean ， byte ， char ， short ， int ， long ， float和double ），和关键字void也表示为类对象。

类没有公共构造函数。 相反， 类对象由Java虚拟机自动构建，因为加载了类，并且通过调用类加载器中的defineClass方法。。

**java 万物皆是Class类 **

【图片】

我们来看下Class类的源码，源码太多了，挑了几个重点：

public final class Class<T> implements java.io.Serializable,                              GenericDeclaration,                              Type,                              AnnotatedElement {    private static final int ANNOTATION= 0x00002000;    private static final int ENUM      = 0x00004000;    private static final int SYNTHETIC = 0x00001000;    private static native void registerNatives();    static {        registerNatives();    }    /*     * Private constructor. Only the Java Virtual Machine creates Class objects.     * This constructor is not used and prevents the default constructor being     * generated.     */    private Class(ClassLoader loader) { //私有化的 构造器        // Initialize final field for classLoader.  The initialization value of non-null        // prevents future JIT optimizations from assuming this final field is null.        classLoader = loader;    }    ...        // reflection data that might get invalidated when JVM TI RedefineClasses() is called    private static class ReflectionData<T> {        volatile Field[] declaredFields;//字段        volatile Field[] publicFields;        volatile Method[] declaredMethods;//方法        volatile Method[] publicMethods;        volatile Constructor<T>[] declaredConstructors;//构造器        volatile Constructor<T>[] publicConstructors;        // Intermediate results for getFields and getMethods        volatile Field[] declaredPublicFields;        volatile Method[] declaredPublicMethods;        volatile Class<?>[] interfaces;//接口        // Value of classRedefinedCount when we created this ReflectionData instance        final int redefinedCount;        ReflectionData(int redefinedCount) {            this.redefinedCount = redefinedCount;        }    }      ...     //注释数据     private volatile transient AnnotationData annotationData;    private AnnotationData annotationData() {        while (true) { // retry loop            AnnotationData annotationData = this.annotationData;            int classRedefinedCount = this.classRedefinedCount;            if (annotationData != null &&                annotationData.redefinedCount == classRedefinedCount) {                return annotationData;            }            // null or stale annotationData -> optimistically create new instance            AnnotationData newAnnotationData = createAnnotationData(classRedefinedCount);            // try to install it            if (Atomic.casAnnotationData(this, annotationData, newAnnotationData)) {                // successfully installed new AnnotationData                return newAnnotationData;            }        }    }     ...

我们可以发现Class也是类，是一种特殊的类，将我们定义普通类的共同的部分进行抽象，保存类的属性，方法，构造方法，类名、包名、父类，注解等和类相关的信息。

Class类的构造方法是private， 只有JVM能创建Class实例 ，我们开发人员 是无法创建Class实例的，JVM在构造Class对象时，需要传入一个 类加载器 。

类也是可以用来存储数据的，Class类就像 普通类的模板 一样，用来保存“类所有相关信息”的类。

我们来继续看这个利用反射的例子： Class personClass = Person.class;

由于JVM为加载的 Person.class创建了对应的Class实例，并在该实例中保存了该 Person.class的所有信息，因此，如果获取了Class实例（personClass ），我们就可以通过这个Class实例获取到该实例对应的 Person类 的所有信息。

反射的使用获取Class实例4种方式通过对象调用 getClass() 方法来获取

Person p1 = new Person();Class c1 = p1.getClass();

像这种已经创建了对象的，再去进行反射的话，有点多此一举。

一般是用于传过来的是Object类型的对象，不知道具体是什么类，再用这种方式比较靠谱

类名.class

Class c2 = Person.class;

这种需要提前知道导入类的包，程序性能更高，比较常用，通过此方式获取 Class 对象 ，Person类不会进行初始化

通过 Class 对象的 forName() 静态方法来获取，最常用的一种方式

Class c3 = Class.forName("com.zj.demotest.domain.Person");

这种只需传入类的全路径 ， Class.forName会进行初始化initialization步骤 ，即静态初始化（会初始化类变量，静态代码块）。

通过类加载器对象的 loadClass() 方法

public class TestReflection {    public static void main(String[] args) throws ClassNotFoundException {        Person p1 = new Person();        Class c1 = p1.getClass();        Class c2 = Person.class;        Class c3 = Class.forName("com.zj.demotest.domain.Person");        //第4中方式，类加载器        ClassLoader classLoader = TestReflection.class.getClassLoader();        Class c4 = classLoader.loadClass("com.zj.demotest.domain.Person");        System.out.println(c1.equals(c2));        System.out.println(c2.equals(c3));        System.out.println(c3.equals(c4));        System.out.println(c1.equals(c4));    }}

loadClass的源码：

public Class<?> loadClass(String name) throws ClassNotFoundException {    return loadClass(name, false);}

loadClass 传入的第二个参数是"false",因此它不会对类进行连接这一步骤，根据 类的生命周期 我们知道，如果一个类没有进行验证和准备的话，是无法进行初始化过程的，即 不会进行类初始化，静态代码块和静态对象也不会得到执行

我们将c1,c2,c3,c4进行 equals 比较

System.out.println(c1.equals(c2));System.out.println(c2.equals(c3));System.out.println(c3.equals(c4));System.out.println(c1.equals(c4));

true  true  true  true

因为Class实例在JVM中是唯一的，所以，上述方法获取的Class实例是同一个实例， 一个类在 JVM 中只会有一个 Class 实例

Class类常用的API

日常开发的时候，我们一般使用反射是为了 创建类实例（对象）、反射获取类的属性和调用类的方法

getName()

获得类的完整名字

getFields()

获得类的public类型的属性

getDeclaredFields()

获得类的所有属性。包括 private 声明的和继承类

getMethods()

获得类的public类型的方法

getDeclaredMethods()

获得类的所有方法。包括 private 声明的和继承类

getMethod(String name, Class[] parameterTypes)

获得类的特定方法，name参数指定方法的名字，parameterTypes 参数指定方法的参数类型。

getConstructors()

获得类的public类型的构造方法

getConstructor(Class[] parameterTypes)

获得类的特定构造方法，parameterTypes 参数指定构造方法的参数类型

newInstance()

通过类的不带参数的构造方法创建这个类的一个对象

getSuperClass()

用于返回表示该 Class 表示的任何类、接口、原始类型或任何 void 类型的 超类的Class(即父类) 。

...

...

我们这边就不全部展开讲了，挑几个重点讲解一下

创建对象调用class对象的 newInstance() 方法

Class c1 = Class.forName("com.zj.demotest.domain.Person");Person p1 = (Person) c1.newInstance();p1.eat();

结果：

吃饭

注意：Person类必须有一个 无参的构造器 且 类的构造器的访问权限不能是private

使用指定构造方法 Constructor 来创建对象

如果我们非得让Person类的无参构造器设为private呢，我们可以获取对应的Constructor来创建对象

Class c1 = Class.forName("com.zj.demotest.domain.Person");Constructor<Person> con =  c1.getDeclaredConstructor();con.setAccessible(true);//允许访问Person p1 = con.newInstance();p1.eat();

结果：

吃饭

注意：setAccessible()方法能在运行时 压制 Java语言访问控制检查(Java language access control checks)，从而能任意调用 被私有化 保护的方法、域和构造方法。

由此我们可以发现** 单例模式不再安全，反射可破之！**

访问属性

Field getField(name)

根据字段名获取某个public的field（包括父类）

Field getDeclaredField(name)

根据字段名获取当前类的某个field（不包括父类）

Field[] getFields()

获取所有public的field（包括父类）

Field[] getDeclaredFields()

获取当前类的所有field（不包括父类）

我们来看一个例子：

public class TestReflection3 {        public static void main(String[] args) throws Exception {        Object p = new Student("li hua");        Class c = p.getClass();        Field f = c.getDeclaredField("name");//获取属性        f.setAccessible(true);//允许访问        Object val= f.get(p);        System.out.println(val);    }    static class Student {        private String name;        public Student(String name) {            this.name = name;        }    }}

结果：

li hua

我们可以发现 反射可以破坏类的封装

调用方法

Method getMethod(name, Class...)

获取某个public的Method（包括父类）

Method getDeclaredMethod(name, Class...)

获取当前类的某个Method（不包括父类）

Method[] getMethods()

获取所有public的Method（包括父类）

Method[] getDeclaredMethods()

获取当前类的所有Method（不包括父类）

我们来看一个例子：

public class TestReflection4 {    public static void main(String[] args) throws Exception {        //获取私有方法，需要传参：方法名和参数        Method h = Student.class.getDeclaredMethod("setName",String.class);        h.setAccessible(true);        Student s1 =new Student();        System.out.println(s1.name);        //传入目标对象，调用对应的方法        h.invoke(s1,"xiao ming");        System.out.println(s1.name);    }    static class Student {        private String name;        private void setName(String name) {            this.name = name;        }    }}

结果：

null  xiao ming

我们发现获取方法getMethod()时，需要传参 方法名和参数

这是因为.class文件中通常有 不止一个方法 ，获取方法getMethod()时,会去调用searchMethods方法循环遍历所有Method，然后根据 方法名和参数类型 找到唯一符合的Method返回。

我们知道类的方法是在JVM的方法区中 ，当我们new 多个对象时，属性会另外开辟堆空间存放，而方法只有一份，不会额外消耗内存，方法就像一套指令模板，谁都可以传入数据交给它执行，然后得到对应执行结果。

method.invoke(obj, args) 时传入目标对象，即可调用对应对象的方法

如果获取到的Method表示一个静态方法，调用静态方法时， 无需指定实例对象 ，所以invoke方法传入的第一个参数永远为null, method.invoke(null, args)

那如果 方法重写了呢， 反射依旧遵循 多态 的原则 。

反射的应用场景

如果平时我们只是写业务代码,很少会接触到直接使用反射机制的场景，毕竟我们可以直接new一个对象，性能比还反射要高。

但如果我们是工具框架的开发者,那一定非常熟悉,像 Spring/Spring Boot、MyBatis 等等框架中都大量使用反射机制， 反射被称为框架的灵魂

比如：

Mybatis Plus可以让我们只写接口，不写实现类，就可以执行SQL开发项目时，切换不同的数据库只需更改配置文件即可类上加上@Component注解，Spring就帮我们创建对象在Spring我们只需 @Value注解就读取到配置文件中的值等等扩展：反射配置文件

我们来模拟一个配置高于编码的例子

新建my.properties，将其放在resources的目录下

#Person类的包路径className=com.zj.demotest.domain.Person methodName=eat

Person类 还是本文 一直用的，在文章的开头有

最后我们来编写一个测试类

public class TestProp {    public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {        Properties properties = new Properties();        ClassLoader classLoader = TestProp.class.getClassLoader();        InputStream inputStream = classLoader.getResourceAsStream("my.properties");// 加载配置文件        properties.load(inputStream);        String className = properties.getProperty("className");        System.out.println("配置文件中的内容：className="+className);        String methodName = properties.getProperty("methodName");        System.out.println("配置文件中的内容：methodName="+methodName);        Class name = Class.forName(className);        Object object = name.newInstance();        Method method = name.getMethod(methodName);        method.invoke(object);    }}

结果：

配置文件中的内容：className=com.zj.demotest.domain.Person

配置文件中的内容：methodName=eat

吃饭

紧接着，我们修改配置文件:

className=com.zj.demotest.domain.PersonmethodName=eat

结果变为：

配置文件中的内容：className=com.zj.demotest.domain.Person

配置文件中的内容：methodName=Dance

跳舞

是不是很方便？

尾语

反射机制是一种功能强大的机制，让Java程序具有在 运行期 分析类以及修改其本身状态或行为的能力 。

对于特定的复杂系统编程任务，它是非常必要的，为各种框架提供开箱即用的功能提供了便利，为解耦合提供了保障机制。

但是世事无绝对，反射相当于一系列解释操作，通知 JVM 要做的事情，性能比直接访问对象要差点（JIT优化后，对于框架来说实际是影响不大的），还会增加程序的复杂性等（明明直接new一下就能解决的事情，非要写一大段代码）。