Java反射机制

反射引入

很多人学反射学的云里雾里的，很大原因就是因为连最基础的反射是做什么的都不知道，下面模拟一个需求引出反射：

根据配置文件 “re.properties” 指定信息，创建classfulloath指定的对象，并调用method指定的对象方法：

# re.properties 配置文件内容
classfullpath=com.Demo1.Cat
method=hi

我们可以思考，使用什么技术能实现这个功能？
很多人可能很快就可能想到 properties 类，但是有一个很大的问题就是，使用 properties 读取文件中的字符串是没有问题的，但是能使用 properties 读取的字符串创建一个对象吗？这显然是不行的，字符串就是字符串，怎么能创建对象呢？

而以上的需求在实际开发中，包括学习框架时特别多体现，即通过外部文件配置，在不修改源码的情况下来控制程序，也符合设计模式的ocp原则(开闭原则：不修改源码，扩容功能)。

反射快速入门

先演示一下错误的操作：

public class ReflectionQuestion {
    public static void main(String[] args) throws IOException {
        // 1. 调用Properties来读取文件
        Properties properties = new Properties();
        properties.load(new FileReader("src\\re.properties"));	// com.Demo1.Cat
        String classfullpath = properties.getProperty("classfullpath");	// hi
        String method = properties.getProperty("method");
        System.out.println("classfullpath = " + classfullpath);
        System.out.println("method = " + method);

        // 2. 创建对象？？
        new classfullpath();    // ????????
    }
}

很明显，我们得到的是一个字符串对象，我们是无法通过字符串创建一个对象的！！
那么我们就可以使用反射方法改进这段代码：

// 2. 创建对象
// 使用发射机制解决
// (1) 加载类，返回Class类型的对象
Class cls = Class.forName(classfullpath);
// (2) 通过 cls 得到加载的类的 com.Demo1.Cat 对象实例
Object o = cls.newInstance();
System.out.println("o 的运行类型：" + o.getClass());  // class com.Demo1.Cat 说明创建实例成功
// (3) 通过 cls 得到你加载的类 co m.Demo1.Cat 的 method"hi" 的方法对象
Method method1 = cls.getMethod(method); // 即：在反射中，可以把方法也视为对象
// (4) 通过 method1 调用方法：即通过方法对象来实现调用方法
method1.invoke(o);  // 传统调用方法：对象.方法()，反射机制：方法对象.invoke(实例对象)

这样就可以看出反射机制的神奇之处，之后我们如果想调用Cat对象的cry方法，eat方法…我们只需要修改配置文件，而无需修改源码。

反射机制

反射机制允许程序在执行期间借助ReflectionAPI取得任何类的内部信息(比如成员变量、构造器、成员方法、注解…)，并且能够操作对象的属性及方法，反射在设计模式和框架底层都会用到。
加载完类之后，在堆中就产生了一个Class类型的对象(一个类只有一个Class对象)。这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个对象就像一面镜子，透过这个镜子可以看到类的结构，所以形象的称为：反射。

反射机制图解

Java程序计算机的三个阶段
Java反射机制可以完成：

在运行时判断任意一个对象所属的类。
在运行时构造任意一个类的对象。
在运行时得到任意一个类所具有的成员变量和方法。
在运行时调用任意一个对象的成员变量和方法。
生成动态代理。

反射相关类

反射相关的主要类

类名	描述
java.lang.Class	代表一个类，Class对象表示某个类加载后在堆中的对象。
java.lang.reflect.Method	代表类的方法，Method对象表示某个类的方法。
java.lang.reflect.Field	代表类的成员变量，Field对象表示某个类的成员变量。
java.lang.reflect.Constructor	代表类的构造方法，Constructor对象表示构造器。

这些类都在 java.lang.reflect 中，还有更多其他反射相关类可参考帮助文档。

类的相关使用：

// 承接快速入门中的代码...

// Field的使用: 代表类的成员变量
Field fieldName = cls.getField("name");  // getField不能得到私有的属性
System.out.println(fieldName.get(o));   // 传统写法：对象.成员变量，反射：成员变量对象.get(实例对象)

// Constructor: 代表类的构造方法
Constructor constructors = cls.getConstructor();
System.out.println(constructors);   // public com.Demo1.Cat()

// 有参构造，下面传入的String.class就是Cat类的有参构造参数类型
Constructor param_constructor = cls.getConstructor(String.class);
System.out.println(param_constructor);  // public com.Demo1.Cat(java.lang.String)

反射优点和缺点

优点：可以动态的创建和使用对象(也是框架底层核心)，使用灵活，没有反射机制，框架技术就失去了底层支撑。
缺点：使用反射基本是解释执行，对执行速度有影响。

如下面这段代码：

public class Reflection {
    // 传统方法调用hi方法
    @Test
    public void m1() {
        long start = System.currentTimeMillis();

        Cat cat = new Cat();
        for (int i = 0; i < 1000000000; i++) {
            cat.hi();
        }

        System.out.printf(
                "传统方法调用hi方法执行时间：%d", (System.currentTimeMillis() - start));
    }

    // 反射机制调用hi方法
    @Test
    public void m2() throws Exception {
        long start = System.currentTimeMillis();

        Class cls = Class.forName("com.Demo1.Cat");
        Method method = cls.getMethod("hi");
        Object o = cls.newInstance();
        for (int i = 0; i < 1000000000; i++) {
            method.invoke(o);
        }

        System.out.printf(
                "反射机制调用hi方法执行时间：%d", (System.currentTimeMillis() - start));
    }
}

传统方法
反射方法

效率差距十分明显

但是其实我们还可以通过一些方式来优化反射调用的速度 —— 关闭访问检查：

Method、Field和Constructor对象都有setAccessible()方法。
setAccessible()作用是启动和禁用访问安全检查的开关。
参数值为true则表示反射的对象在使用时取消访问检查，提高反射的效率。参数值为false则表示反射的对象执行访问检查。

优化后的代码：

...
    Class cls = Class.forName("com.Demo1.Cat");
    Method method = cls.getMethod("hi");
    method.setAccessible(true);
    Object o = cls.newInstance();
    for (int i = 0; i < 1000000000; i++) {
        method.invoke(o);
    }
...

反射方法
在这里插入图片描述

相对能够提升一些效率

Class类

基本介绍

Class类也是类，因此也基础Object类(从下图可以看出)：

在这里插入图片描述

Class类对象不是new出来的，而是系统创建的。

// 尝试new Class，程序会报错，应为Class类无法实例化，构造器私有
new Class();	
// 传统方法创建对象
new Cat();
/*
	// 底层调用loadClass方法
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
    }
    
*/
// 反射方式
Class aClass = Class.forName("com.Demo1.Cat");
// 底层通过多次跳转，同样会调用loadClass方法

对于某个类的Class类对象，在内存中只有一份，因为类只加载一次。

Cat cat1 = new Cat();
Cat cat2 = new Cat();
// 创建两个对象实例，我们Debug会发现loadClass方法只会被调用一次
// 通过反射方式创建的对象如果之前调用过loadClass方法也不会再次调用

每个类的实例都会记得自己是由哪个Class实例所生成。

Class cls1 = Class.forName("com.Demo1.Cat");
Class cls2 = Class.forName("com.Demo1.Cat");
System.out.println(cls1.hashCode());    // 1468177767
System.out.println(cls2.hashCode());    // 1468177767

通过Class可以完整的得到一个类的完整结构，通过一系列API，后面会进行讲解。
Class对象是存放在堆中的。
类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据(包括方法代码，变量名，方法名，访问权限…)

最后两点见"反射机制章节"中反射机制图解。

Class类的常用方法

返回值	方法	描述
static Class<?>	forName(String className)	返回与给定字符串名称的类或接口相关联的 Class对象。
Package	getPackage()	获取此类的包。
String	getName()	返回由该 Class对象表示的实体，作为 String 返回
Object	newInstance()	已过时。创建一个新的对象实例。
Field	getField(String name)	返回一个 Field 对象，该对象反映由该 Class对象表示的类或接口的指定 public 修饰的成员字段。
Method	getMethod(String name)	返回一个 Method 对象，该对象反映由该 Class对象表示的类或接口的指定公共成员方法。
Constructor	getConstructor()	返回一个 Constructor 对象，该对象反映由该 Class对象表示的类的指定公共构造函数。

常用判断方法

返回值	方法	描述
boolean	isArray()	确定此 Class对象是否表示数组类。
boolean	isEnum()	当且仅当该类在源代码中被声明为枚举时才返回true。
boolean	isInstance(Object obj)	确定指定对象是否为此类的实例
boolean	isInterface()	确定指定的 Class对象是否表示接口类型。

以上仅展示部分方法，更多方法可参考帮助文档。

部分方法使用举例：

public static void main(String[] args) throws Exception {
    String classAllPath = "com.Demo1.Cat";
    // 获取到Cat类对应的Class对象
    // <?> 表示不确定的Java类型，也可以不写<?>
    Class<?> cls = Class.forName(classAllPath);
    // 输出cls
    System.out.println(cls);    // class com.Demo1.Cat
    // 输出cls真正的运行类型
    System.out.println(cls.getClass()); // class java.lang.Class
    // 得到包名
    System.out.println(cls.getPackage().getName()); // com.Demo1
    // 得到全类名
    System.out.println(cls.getName());  // com.Demo1.Cat

    // 通过cls创建对象实例
    // 方法一 已过时，不推荐使用
    Cat cat1 = (Cat) cls.newInstance();
    // 方法二
    Cat cat2 = (Cat) cls.getDeclaredConstructor().newInstance();

    // 通过反射获取属性
    Field name = cls.getField("name");
    System.out.println(name.get(cat2)); // 属性值

    // 通过属性给属性赋值
    name.set(cat2,"小花");
    System.out.println(name.get(cat2)); // 小花

    // 遍历cat2对象的所有属性(遍历方法、构造器同理)
    Field[] cat2Fields = cls.getFields();
    for (Field cat2Field : cat2Fields) {
        System.out.println(cat2Field.getName() + ": " + cat2Field.get(cat2));
    }
}

获取Class类对象

在"反射机制章节"反射机制图解中可以看到Java程序在计算机中有三个阶段，而这三个阶段都可以分别获取Class类对象，并且还可以通过类加载器获取Class类对象：

编译阶段：Class.forName()
加载阶段：类.class
运行阶段：对象.getClass()
类加载器：

获取Class类对象的不同方式：

已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，需要处理ClassNotFoundException异常

Class<?> cls1 = Class.forName("com.Demo1.Cat");
// 应用场景：多用于配置文件，读取类全路径，加载类。

已知具体的类，通过类.class获取，该方式最为安全可靠，程序性能最高。

Class<Cat> cls2 = Cat.class;
// 应用场景：多用于参数传递，比如通过反射得到对应构造器对象

已知某个类的实例，调用该实例的getClass()方法获取Class对象。

Class<? extends Cat> cls3 = new Cat().getClass();
// 应用场景：通过创建号的对象，获取Class对象

通过类加载器，获取Class类对象。

Class<?> cls4 = cls3.getClassLoader().loadClass("com.Demo1.Cat");

基本数据类型获取Class类对象，可以通过以下两种方式获取。

// 方式一：
// 在存储的时候会自动转换为保证类
Class<Integer> integerClass = int.class;
Class<Character> characterClass = char.class;
Class<Boolean> booleanClass = boolean.class;
// ...

// 方式二
Class<Integer> IntegerType = Integer.TYPE;
Class<Character> charType = Character.TYPE;
// ...

如下类型可以获取Class类对象：
外部类、成员内部类、静态内部类、局部内部类、匿名内部类、接口、数组、枚举、注解、基本数据类型、void。

类加载

基本说明：反射机制是Java实现动态语言的关键，也就是通过反射实现类动态加载.

静态加载：编译时加载相关的类，如果没有则报错，依赖性太强。
静态加载典型的应用就是在使用 new 新对象的时候，在编译阶段，如果该类不存在，就会报错，程序无法进行加载阶段以及运行阶段。

动态加载：运行时加载相关的类，如果运行时未使用该类，即使不存在该类，则不报错，降低了依赖性。
动态加载典型的应用就是反射机制，假如我们在forName()方法中传入一个不存在的类，是可以通过编译的，但是当程序执行到反射语句，如果类还不存在，就会抛出ClassNotFoundException异常。

下图为静态加载出现的错误和动态加载出现的错误：

在这里插入图片描述

类加载的时机：

当创建对象时(new) -> 静态加载
当子类被加载时，父类也会加载 -> 静态加载
调用类中的静态成员(static修饰) -> 静态加载
通过反射 -> 动态加载

类加载流程图

在这里插入图片描述

加载阶段：JVM在该阶段的主要目的时将字节码从不同的数据源(可能是class文件，也可能是jar包，甚至网络)转换为二进制字节流加载到内存中，并生成一个代表该类的java.lang.Class对象。
连接阶段：
验证：

目的是为了确保class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
包括：文件格式验证(是否以魔数 0xCAFEBABE 开头)、元数据验证、字节码验证和符号引用验证。
可以考虑使用 Xverify:none 参数来关闭大部分的类验证措施，以缩短虚拟机加载的时间。

准备：
JVM会在该阶段对静态变量分配内存并默认初始化(对应数据类型的默认初始值，如：0,null,false…)。这些变量所使用的内存都将在方法区中进行分配。

class A {
    // 类加载连接阶段 —— 准备 属性如何处理
    // a 不会处理，因为a是实例属性，准备阶段不会分配内存
    public int a = 10;
    // b 是静态变量，分配内存，默认初始化为0，不会赋值为20
    public static int b = 20;
    // c 是常量，和普通的静态变量不一样，
    // 一旦赋值就不会变化了，所以会直接赋值为30
    public static final int c = 30;
}

解析：
JVM虚拟机将常量池内的符号引用替换为直接引用的过程。
在还没有为类分配空间的时候，都是以符号的形式表示类之间的关系，到了类加载解析阶段，就依靠地址之间进行引用。
初始化：

到初始化阶段，真正开始执行类中定义的Java程序代码，此阶段是执行clinit()方法的过程。
clinit()方法是由编译器按语句在源文件中出现的顺序，一次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并。
虚拟机会保证一个类的 clinit() 方法在多线程环境中被正确的加锁，同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的 cliniit() 方法，其他线程都需要阻塞等待，直到活动线程执行 clinit() 方法完毕。

获取类的结构信息

第一组：java.lang.Class类

返回值	方法名	描述
String	getName	获取全类名
String	getSimpleName	获取简单类名
Field[]	getFields	获取所有public修饰的属性，包括本类以及父类的
Field[]	getDeckaredFields	获取本类中的所有属性
Method[]	getMethods	获取所有public修饰的方法，包括本类以及父类的
Method[]	getDeclaredMethods	获取本类中所有方法
Constructor<?>[]	getConstructors	获取所有public修饰的构造器，仅包括本类的
Constructor<?>[]	getDeclaredConstructors	获取本类中所有构造器
Class<?>	getSuperClass	以 Class 形式返回父类信息
Class<?>[]	getInterfaces	以以 Class[] 形式返回接口信息
Annotation[]	getAnnotations	以 Annotation[] 形式返回注解信息

使用演示：

public class ReflectionUtils {
    public static void main(String[] args) throws Exception {
        // 以Double类为例子
        Class<?> pscls = Class.forName("com.class_.Person");
        // getName	获取全类名
        System.out.println("全类名：" + pscls.getName());
        // getSimpleName	获取简单类名
        System.out.println("简单类名：" + pscls.getSimpleName());
        // getFields	获取所有public修饰的属性，包括本类以及父类的
        Field[] fields = pscls.getFields();
        for (Field field : fields) {
            System.out.println("Person(public)成员变量：" + field.getName());
        }
        // getDeckaredFields	获取本类中的所有属性
        Field[] declaredFields = pscls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("Person全部成员变量：" + declaredField.getName());
        }
        // getMethods	获取所有public修饰的方法，包括本类以及父类的
        Method[] methods = pscls.getMethods();
        for (Method method : methods) {
            System.out.println("Person(public)成员方法：" + method.getName());
        }
        // getDeclaredMethods	获取本类中所有方法
        Method[] declaredMethods = pscls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("Person全部成员方法：" + declaredMethod.getName());
        }
        // getConstructors	获取所有public修饰的构造器，包括本类以及父类的
        Constructor<?>[] constructors = pscls.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println("Person(public)构造器：" + constructor.getName());
        }
        // getDeclaredConstructors	获取本类中所有构造器
        Constructor<?>[] declaredConstructors = pscls.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("Person全部构造器：" + declaredConstructor.getName());
        }
        // getSuperClass	以 Class 形式返回父类信息
        Class<?> superclass = pscls.getSuperclass();
        System.out.println("Person父类信息：" + superclass.getName());
        // getInterfaces	以以 Class[] 形式返回接口信息
        Class<?>[] interfaces = pscls.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println("Person实现接口信息：" + anInterface.getName());
        }
        // getAnnotations	以 Annotation[] 形式返回注解信息
        Annotation[] annotations = pscls.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("Person中的注解信息：" + annotation);
        }
    }
}


class Father {
    public String hobby;

    public Father() {
    }
}

interface IA {
}

interface IB {
}

@Deprecated
class Person extends Father implements IA, IB {
    // 四种不同权限的成员变量
    public String name;
    protected int age;
    String gender;
    private int weight;

    // 无参构造
    public Person() {
    }

    // 有参构造
    public Person(String name) {
        this.name = name;
    }

    private Person(int weight) {
        this.weight = weight;
    }

    public void hi() {
    }
}

第二组：java.lang.reflect.Field类

返回值	方法名	描述
int	getModifiers	以int形式返回修饰符
Class	getType	以Class形式返回成员变量类型

说明：getModifiers返回值默认修饰符是0、public 是 1、private 是 2、protected 是 4、static 是 8、final是16。如果一个成员变量被多个修饰符修饰，返回数值为多个修饰符数值相加。

使用举例：

@Test
public void api_02() throws Exception {
    // 同样以上面的Person类为例
    Class<?> pscls = Class.forName("com.class_.Person");
    Field[] fields = pscls.getDeclaredFields();
    for (Field field : fields) {
        System.out.println("Person类属性名：" + field.getName()
                           + "\t该属性的类型：" + field.getType()
                           + "\t该属性修饰符值：" + field.getModifiers()
                          );
    }
}

第三组：java.lang.reflect.Method类

返回值	方法名	描述
int	getModifiers	以int形式返回修饰符
Class	getReturnType	以Class形式返回成员变量类型
Class[]	getParameterTypes	以Class[]返回方法形参类型数组

使用举例：

@Test
public void api_03() throws Exception {
    // 同样以上面的Person类为例
    Class<?> pscls = Class.forName("com.class_.Person");
    Method[] methods = pscls.getMethods();
    for (Method method : methods) {
        System.out.println("Person方法名：" + method.getName()
                           + "\t该方法的返回类型" + method.getReturnType()
                           + "\t该属性修饰符值：" + method.getModifiers()
                           + "\t该方法的形参类型" + Arrays.toString(method.getParameterTypes())
                          );
    }
}

第四组：java.lang.reflect.Constructor类

返回值	方法名	描述
int	getModifiers	以int形式返回修饰符
Class[]	getParameterTypes	以Class[]返回方法形参类型数组

使用举例：

@Test
public void api_04() throws Exception {
    // 同样以上面的Person类为例
    Class<?> pscls = Class.forName("com.class_.Person");
    Constructor<?>[] constructors = pscls.getConstructors();
    for (Constructor<?> constructor : constructors) {
        System.out.println("Person构造器：" + constructor.getName()
                           + "\t该构造器修饰符值：" + constructor.getModifiers()
                           + "\t该构造器的形参类型" + Arrays.toString(constructor.getParameterTypes())
                          );
    }
}

反射暴破操作

在之前的学习中，如果我们想操作类的私有构造器、私有方法、私有属性，都是不被允许的。但是我们学习反射之后，就可以通过爆破机制来强行使用类的私有成员。

为了方便后面的使用，我们先创建一个User类，下面演示即依据如下的User类进行：

class User {
    private int age = 5;
    private String name = "user";

    // 共有无参构造
    public User() {
    }
    // 公有有参构造
    public User(String name) {
        this.name = name;
    }
    // 私有有参构造
    private User(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

反射创建实例

创建步骤：

获取指定类的Class对象。
利用Class对象获取到构造器。
如果是私有构造器需要进行暴破。
使用newInstance方法创建实例。

大部分方法前面都使用过，我们只需要将这些方法融合起来使用即可：

// 1. 先获取到 User 类的 Class 对象
Class<?> userCls = Class.forName("com.class_.User");
// 我们还可以使用如下方式获取 User 类的 Class 对象
Class<User> userClass = User.class;

// 2. 通过public的无参构造创建实例
User user = userClass.getDeclaredConstructor().newInstance();
System.out.println(user);      // User{age=5, name='user'}

// 3. 通过public的有参构造创建实例
Constructor<?> constructor = userCls.getConstructor(String.class);
Object o2 = constructor.newInstance("张飞");
System.out.println(o2);     // User{age=5, name='张飞'}

// 4. 通过非public的有参构造创建实例(需要设置暴力破解)
Constructor<?> dc = userCls.getDeclaredConstructor(int.class, String.class);
dc.setAccessible(true); // 需要设置暴破才能访问私有变量
Object o3 = dc.newInstance(10, "Bob");
System.out.println(o3); // User{age=10, name='Bob'}

反射访问类中成员

访问步骤：

依据上面的方式创建实例。
根据属性名获取 Field 对象。
如果是私有变量需要进行暴破。
Field对象.set(实例, 值) 可以设置成员属性，Field对象.get(实例)可以获取成员属性。
如果是静态属性，set()和get()中的参数实例，可以写成null。

// 1. 得到 User 类对应的Class对象
Class<?> userCls = Class.forName("com.class_.User");
// 2. 创建实例
User u = (User) userCls.getDeclaredConstructor().newInstance();

// 3. 使用反射得到公共的 gender 属性
Field gender = userCls.getField("gender");
gender.set(u, "女"); // 访问/操作属性
System.out.println(gender.get(u));

// 4. 使用反射得到私有的 hobby 属性
Field hobby = userCls.getDeclaredField("hobby");
hobby.setAccessible(true);  // 访问静态属性需要暴破
hobby.set(null, "唱歌");   // 因为是静态属性，所以 u 可以为null
System.out.println(hobby.get(u));   // 当然也可以和原来一样

反射调用方法

调用步骤：

依据上面的方式创建实例。
根据方法名和参数列表获取 Method 方法对象。
如果是私有方法需要进行暴破。
使用 invoke() 方法调用方法，方法的返回值统一都是Object类型。
如果是静态方法，则 invoke() 的第一个参数可以为null。

// 1. 得到User类对应的Class对象
Class<?> userCls = Class.forName("com.class_.User");
// 2. 创建实例
Object o = userCls.getDeclaredConstructor().newInstance();

// 3. 调用 public 的 hi() 方法
Method hi = userCls.getMethod("hi");
hi.invoke(o);

// 4. 调用 private 的 say() 方法
Method say = userCls.getDeclaredMethod("say", int.class, String.class, char.class);
say.setAccessible(true);    // 因为 say 是私有方法，需要暴破
// 返回值都是Object类型，而不是原来的String类型
Object invoke = say.invoke(o, 100, "张三", '男');  
System.out.println(invoke);

// 由于是静态方法，所以第一个参数可以为null
System.out.println(say.invoke(null, 100, "张三", '男'));

本章完。