一、背景

要理解反射，首先要知道它产生的背景。

在 Java 中，正常情况下我们只需要 new 某个类来使用就行了，但是如果想在运行时灵活创建某个类怎么办？想要使用某个类但是并没有被 JVM 加载怎么办？

答案就是利用 反射，这个机制可以帮助我们在运行期需要的时候去加载创建某个类，从而使用该类的方法。

这里引用 知乎Kira 的回答可能更容易理解：

假如你写了一段代码：Object o=new Object();运行了起来！
首先JVM会启动，你的代码会编译成一个.class文件，然后被类加载器加载进jvm的内存中，你的类Object加载到方法区中，创建了Object类的class对象到堆中，注意这个不是new出来的对象，而是类的类型对象，每个类只有一个class对象，作为方法区类的数据结构的接口。
jvm创建对象前，会先检查类是否加载，寻找类对应的class对象，若加载好，则为你的对象分配内存，初始化也就是代码:new Object()。
上面的流程就是你自己写好的代码扔给jvm去跑，跑完就over了，jvm关闭，你的程序也停止了。

相当于这些代码都是写 "死" 的，但是在运行时要使用则需要利用反射通过包名灵活地加载某些类。

二、反射的组件

实现反射的一些主要类都处于 java.lang 包下：

• Class：代表一个类；
• Field：代表类的成员变量（属性）；
• Method：代表类的方法；
• Constructor：代表构造器（构造函数、构造方法）；
• Array：提供动态创建数组，以及访问数组元素的方法；
• Package：存放路径，包名；

接下来看一下怎么获取这些组件。

类对象 Class

• 通过类型获取；

Class c = String.class;

• 通过对象获取：

Class c = o.getClass();

构造器 Constructor

首先使用 Class 对象获取 Constructor ：

• getConstructors()
• getConstructor(Class<?>…parameterTypes)
• getDeclaredConstructors()
• getDeclaredConstructor(Class<?>...parameterTypes)

然后就可以使用 Constructor 的下列方法：

Modifier 用来获取修饰符信息，比如 isStatic(int mod) 返回是否静态、isPublic(int mod) 是否公共。不只是构造器类型含有此方法，函数、属性都有此方法。

方法 Method

属性、字段 Field

数组相关 Array

三、使用

获取组件

接下来写一个简单的小例子来看下反射的使用，首先准备一个 Student 类：

package com.sky.test.ref;

public class Student {

    private int privateAge;
    public int publicAge;

    public void publicStudy(){
    }

    private void privateStudy(){
    }
}

很简单的类，拥有一个私有、一个公共属性，一个私有、一个公共方法，接下来使用反射获取这些信息。

public static void main(String[] args) {

    try {
        // 根据包名找到类型
        Class<?> classType = Class.forName("com.sky.test.ref.Student");

        // 获取所有属性
        Field[] fields = classType.getFields();
        Field[] fieldsD = classType.getDeclaredFields();
        for (Field f : fields) {
            System.out.println("getFields 获取到的属性：" + f.getName());
            // getFields 获取到的属性：publicAge
        }

        for (Field f : fieldsD) {
            System.out.println("getDeclaredFields 获取到的属性：" + f.getName());
            // getDeclaredFields 获取到的属性：privateAge
            // getDeclaredFields 获取到的属性：publicAge
        }

        // 获取该类的所有方法
        Method[] methods = classType.getMethods();
        Method[] methodsD = classType.getDeclaredMethods();
        for (Method m : methods) {
            System.out.println("getMethods 获取到的方法：" + m.getName());
            // getMethods 获取到的方法：publicStudy
            // getMethods 获取到的方法：wait
            // getMethods 获取到的方法：wait
            // getMethods 获取到的方法：wait
            // getMethods 获取到的方法：equals
            // getMethods 获取到的方法：toString
            // getMethods 获取到的方法：hashCode
            // getMethods 获取到的方法：getClass
            // getMethods 获取到的方法：notify
            // getMethods 获取到的方法：notifyAll
        }

        for (Method m : methodsD) {
            System.out.println("getDeclaredMethods 获取到的方法：" + m.getName());
            // getDeclaredMethods 获取到的方法：publicStudy
            // getDeclaredMethods 获取到的方法：privateStudy
        }
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }

}

• Class.forName() 方法传入包名，以找到想要使用的类，找不到会抛 ClassNotFoundException 异常；
• Class 的 getFields() 方法：获取所有 公共的(public) 的属性，包含父类的 public 属性(但不包含父类非 public 属性)；
• Class 的 getDeclaredFields() 方法：获取本类所有的属性，但不包含父类的属性；
• Class 的 getMethods() 方法：获取所有 公共的(public) 的方法，包含父类的 public 方法(但不包含父类非 public 方法)；
• Class 的 gettDeclaredMethods() 方法：获取本类所有的方法，但不包含父类的方法；

简单使用

已经成功获取到这些方法和属性了，接下来就是使用通过反射获取到的属性和方法了。但是首先要做的是能把修改的信息展示出来，把 Student 类简单修改下：

public class Student extends SuperStudent {

    private int privateAge;
    public int publicAge;

    public void publicStudy(int hour) {
        System.out.println("设置年龄为" + publicAge);
        System.out.println("学习了" + hour + "小时");
    }

    private void privateStudy() {
    }
}

只是给 publicStudy() 方法增加了 int 类型的参数，并打印了两个字段：publicAge、hour。接下来就可以使用反射来修改里面的信息了。

public static void main(String[] args) {

    try {
        // 1. 根据包名找到类型
        Class<?> classType = Class.forName("com.sky.test.ref.Student");
        // 创建实例，修改该对象的信息
        Object o = classType.newInstance();
        // 2. 获取 年龄 字段
        Field field = classType.getDeclaredField("publicAge");
        // 设置年龄 publicAge 属性：第一个参数为要修改的对象，第二个参数为数值
        field.set(o, 1);
        // 3. 获取 publicStudy 方法，第二个参数传入参数类型
        Method method = classType.getDeclaredMethod("publicStudy", int.class);
        // 调用 publicStudy 方法
        method.invoke(o, 3);
        
    } catch (ClassNotFoundException
            | NoSuchFieldException
            | NoSuchMethodException | IllegalAccessException
            | InstantiationException | InvocationTargetException
            e) {
        e.printStackTrace();
    }

}

1. 首先要做的是找到该类型，并创建该类型的对象。修改数据首先得有对象吧，然后内存空间有它的地方吧，不然修改啥。
2. 然后就是获取字段了，我们要做的是修改年龄 publicAge 字段：获取该字段的 Field 对象，使用 set() 传入 对象 和要修改的值，这样就 ok 了。
3. 类似的方法获取 publicStudy() 方法，调用 invoke() 方法传参激活打印。特别注意： 第二个参数是当前方法的参数类型，如果传的不对直接给你报 NoSuchMethodException。而且注意 int.class 和 Integer.class 竟然不是一个东西，传 Integer 还是会报错...

这样就完成了普通的使用。

特别注意：权限问题

反射使用引入了权限机制，私有的属性已经方法直接反射调用的话会抛出异常。

Field fieldPrivate = classType.getDeclaredField("privateAge");
fieldPrivate.set(o,2); // 会抛出 java.lang.IllegalAccessException 异常

如果想要使用的话，需要设置属性或方法等的访问权限：

Field fieldPrivate = classType.getDeclaredField("privateAge");
fieldPrivate.setAccessible(true);
fieldPrivate.set(o,2);

注解使用

注解一般也是利用反射来使用的，大概过程就是利用反射获取 Class 类型上面的注解，然后执行相应逻辑。

之前写过一篇文章有记录，在此不再赘述。

谈谈你对注解的理解 第三节

远程方法运用反射

摘自 Java在远程方法调用中运用反射机制

• 服务端：HelloService
• 客户端：SimpleClient
• 通信信息：Call

客户端生成 Call 对象，指定要调用的类、对象以及方法参数等信息，通过流的形式发生给服务端。

public class Call implements Serializable {
    private static final long serialVersionUID = 6659953547331194808L;
    private String className; // 表示类名或接口名
    private String methodName; // 表示方法名
    private Class[] paramTypes; // 表示方法参数类型
    private Object[] params; // 表示方法参数值
    // 表示方法的执行结果
    // 如果方法正常执行，则result为方法返回值，如果方法抛出异常，那么result为该异常。
    private Object result;
    ...
}

服务端处理过将结果再以流的形式返回给客户端。

远程反射

反射操作数组

需求： 创建一个数组，通过反射获取数组的类型，然后创建一个新长度的新数组，拷贝旧数组的内容。

为了看出效果，首先为 Student 类增加一个静态的创建方法：

public class Student extends SuperStudent {
    public int publicAge;
    ...
    public static Student newInstance(){
        Student student = new Student();
        student.publicAge = 8;
        return student;
    }
}

使用此方法创建实例，给内部的年龄字段一个初始值 8。接下来就创建一个 Student 的数组，并利用反射进行创建和复制。

public static void main(String[] args) {

    // 1. 创建数组，里面存放一个 Student 对象
    Student[] students = new Student[]{Student.newInstance()};
    // 2. 获取元素类型
    Class<?> classType = students.getClass().getComponentType();

    // 3. 创建新数组
    Object[] objects = (Object[]) Array.newInstance(classType, Array.getLength(students));
    // 4. 进行 copy：原数组，拷贝起始，新数组，拷贝起始，拷贝长度
    System.arraycopy(students, 0, objects, 0, Array.getLength(students));

    // 5. 从新数组获取第一个元素
    Student s = (Student)Array.get(objects, 0);
    System.out.println("拷贝完成，第一个数据年龄： " + s.publicAge);
    // 拷贝完成，第一个数据年龄： 8
}

需要注意的是一些方法的使用：

• getClass() 和 getComponentType() 的区别：
  getClass()用于获取对象的类型，比如这里获取数组的是 Student[] 类型；
  getComponentType() 获取数组元素类型，比如这里获取到的是 Student 类型。

• Array.newInstance() 可以帮助我们动态创建数组，可以从别的地方传递来类型和长度，即可完成创建。

反射操作泛型

知识储备：

• Type：所有类型的公共父接口，Class 就是 Type 的子类之一，以下是该接口的子类型：
  • ParameterizedType：参数化类型，可以理解为泛型；
  • TypeVariable：类型变量，也就是平时定义的 T t、K k 等类似的变量；
  • GenericArrayType：泛型数组类型，T[] 这种类型；
  • WildcardType：通配符类型，<?>, <? Extends String> 这种。

小栗子：

依旧是使用上面的 Student 类，给它增加一个包含泛型的方法：

public void setStudents(List<Student> list){
}

接下来就是获取泛型：

public static void main(String[] args) {
    try {
        Method method = Student.class.getMethod("setStudents", List.class);
        // 获取方法参数类型
        Type[] t = method.getGenericParameterTypes();

        for (Type type : t) {
            System.out.println("参数类型：" + type);// 泛型类型：java.util.List<com.sky.test.ref.Student>
            if (type instanceof ParameterizedType) {
                Type[] real = ((ParameterizedType) type).getActualTypeArguments();
                for (Type genericType : real) {
                    System.out.println("泛型类型：" + genericType);
                    // 泛型类型：class com.sky.test.ref.Student
                }
            }
        }

    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    }
}

这只是利用反射获取泛型的一个很小的例子，可以使用不同的方法获取 接口、类等的参数、返回值中的泛型。

说起来为什么会把泛型擦除掉，是因为泛型本来不是 Java 中的东西（可能是抄来的）。如果要把泛型加入字节码，就需要修改字节码指令集。我们都知道新增简单修改难，这字节码指令用了多少年了，要改基本不肯能了。

所以把泛型擦除之后呢，又需要一些类型来表示到底是哪种泛型，于是就有了上面那些 Type 的子接口。

四、反射影响性能

这里引用文章 大家都说 Java 反射效率低，你知道原因在哪里么 的结论：

1. Method#invoke 方法会对参数做封装和解封操作
2. 需要检查方法可见性
3. 需要校验参数
4. 反射方法难以内联
5. JIT 无法优化

具体可以参考该文章，自此本文结束。

参考：

Java反射机制
Java 反射操作数组