本文已参与 「掘力星计划」 ，赢取创作大礼包，挑战创作激励金。

Java反射

1、动态语言

动态语言是指程序在运行时可以改变其结构，新的函数可以引进，已有的函数可以删除等结构上的变化。比如常见的JavaScript就是动态语言，除此之外Ruby、Python也属于动态语言，而c、c++则不属于动态语言。从反射的角度来说Java属于半动态语言。

2、反射机制概念

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

3、反射的应用场合

编译时类型和运行时类型

在Java程序中许多对象在运行时都会出现两种类型：编译时类型和运行时类型。编译时的类型由申明对象时引用的类型来决定，运行时类型由实际赋值给对象的类型决定。如：

1// 其编译类型为person，运行类型为Student
2Person person = new Student();

如果程序在编译类型无法获取具体对象，程序在运行时还可能接收到外部传入的对象，该对象的编译时类型为Object,但是程序有需要调用该对象的运行时类型的方法。为了解决这些问题，程序需要运行时发现对象和类的真实信息。然而，如果编译时根本无法预知该对象和类属于那些类，程序只能依靠运行时信息来发现对象和类的真实信息，此时就需要使用到反射了。

4、Java反射API

反射用来生成JVM中的类、接口或者对象的信息

• Class类：java.lang.Class反射的核心类，可以获取类的属性，方法等信息。
• Field类：java.lang.reflect.Field，表示类的成员变量，可以用来获取和设置类之中的属性值。
• Method类：java.lang.reflect.Method，表示类的方法，可以用来获取类中的方法信息或者执行方法。
• Constructor类：java.lang.reflect.Constructor，表示类中的构造方法。

5、反射的使用步骤

• 获取想要操作的类的class对象，它是反射的核心，通过class对象我们可以任意调用类的方法。
• 调用class类中的方法，就是反射的使用阶段
• 使用反射API来操作这些信息

6、获取class对象的4种方法

• 调用某个对象的getClass()方法

1Person person = new Student();
2Class clazz = person.getClass();

• 调用某个类的class属性来获取该类对应的class对象

1Class clazz = Student.class;

• 使用class类中的forName()静态方法（最常用|最安全|性能最高）

1Class clazz = Class.forName("类的全路径");

• 使用类加载器获取

1// Xxx为与需要获取类信息的类同级别的类加载器。类加载器的选择，要符合双亲委派机制
2Class<?> clazz = Xxx.class.getClassLoader().loadClass("类的全路径");

当我们获得了想要操作的类的Class的对象后，可以通过Class类中的方法获取并查看该类中的方法和属性

 1try {
 2    // 获取Person的Class对象
 3    Class<?> clazz = Class.forName("com.liziba.reflect.Person");
 4    // 获取Person类的所有成员属性信息
 5    Field[] fields = clazz.getDeclaredFields();
 6    for (Field field : fields) {
 7        System.out.println(field);
 8    }
 9    // 获取Person类的所有方法信息
10    Method[] methods = clazz.getDeclaredMethods();
11    for (Method method : methods) {
12        System.out.println(method);
13    }
14    // 获取Person类的所有构造方法信息
15    Constructor<?>[] constructors = clazz.getDeclaredConstructors();
16    for (Constructor<?> constructor : constructors) {
17        System.out.println(constructor);
18    }
19} catch (ClassNotFoundException e) {
20    e.printStackTrace();
21}

7、创建对象的两种方法

• Class对象的newInstance()

 1// 使用Class对象的newInstance()方法来创建该Class对象对应类的实例，但是这种方法要求该Class对象对应的类有默认的空构造器
 2Person person = (Person)clazz.newInstance();
 3
 4// newInstance()方法的本质，仍然是下面的情况，只是传入的参数是(Object[])null
 5 try {
 6     return tmpConstructor.newInstance((Object[])null);
 7 } catch (InvocationTargetException e) {
 8     Unsafe.getUnsafe().throwException(e.getTargetException());
 9     return null;
10 }

• 调用Constructor的newInstance()

1// 先使用Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方发来创建Class对象对应类的实例，通过这种方法可以选定指定构造方法创建实例
2Constructor<?> constructor = clazz.getConstructor(String.class, int.class, String.class, int.class);
3            constructor.newInstance("李子捌", 1, "深圳宝安", 23);

8、反射到底慢在哪里

• 寻找类Class字节码的过程
• 安全机制的权限校验
• 可能需要调用native方法时调用JNI接口

 1// 安全机制校验，Field/Method/Constructor
 2private void checkMemberAccess(int which, Class<?> caller, boolean checkProxyInterfaces){
 3    final SecurityManager s = System.getSecurityManager();
 4    if (s != null) {
 5        final ClassLoader ccl = ClassLoader.getClassLoader(caller);
 6        final ClassLoader cl = getClassLoader0();
 7        if (which != Member.PUBLIC) {
 8            if (ccl != cl) {
 9                s.checkPermission(SecurityConstants.CHECK_MEMBER_ACCESS_PERMISSION);
10            }
11        }
12        this.checkPackageAccess(ccl, checkProxyInterfaces);
13    }
14}

9、反射单例模式的漏洞

简单单例

 1public class SingletonFactory {
 2
 3    private volatile static SingletonFactory singletonFactory = null;
 4
 5    private SingletonFactory() {
 6    }
 7
 8    public static SingletonFactory getInstance() {
 9        if(singletonFactory == null) {
10            synchronized (SingletonFactory.class) {
11                if(singletonFactory == null) {
12                     singletonFactory = new SingletonFactory();
13                }
14            }
15        }
16        return singletonFactory;
17    }
18}

反射破坏单例

 1public class TestReflectBreakSingleInstance {
 2
 3    public static void main(String[] args) {
 4        SingletonFactory instance1 = null;
 5        SingletonFactory instance2 = null;
 6        Class<?> clazz = null;
 7        try {
 8            clazz = Class.forName("com.liziba.reflect.SingletonFactory");
 9            Constructor<?> constructor = clazz.getDeclaredConstructor(null);
10            constructor.setAccessible(true);
11            // 单例获取对象1
12            instance1 = SingletonFactory.getInstance();
13            // 反射获取对象2
14            instance2 = (SingletonFactory)constructor.newInstance();
15        } catch (Exception e) {
16            e.printStackTrace();
17        }
18        // 输出false
19        System.out.println(instance1 == instance2);
20    }
21}

解决方法

1// 在单例构造方法中判断实例是否存在
2private SingletonFactory() {
3    if(SingletonFactory.singletonFactory != null) {
4        throw new RuntimeException("实例存在，无法实例化...");
5    }
6}