Java反射-你不得不知道的那点事

Posted 2021-07-17 李子捌

Java反射

1、动态语言

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

2、反射机制概念

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

3、反射的应用场合

编译时类型和运行时类型

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

// 其编译类型为person，运行类型为Student
Person 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()方法

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

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

  Class clazz = Student.class;
  

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

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

• 使用类加载器获取

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

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

try {
    // 获取Person的Class对象
    Class<?> clazz = Class.forName("com.liziba.reflect.Person");
    // 获取Person类的所有成员属性信息
    Field[] fields = clazz.getDeclaredFields();
    for (Field field : fields) {
        System.out.println(field);
    }
    // 获取Person类的所有方法信息
    Method[] methods = clazz.getDeclaredMethods();
    for (Method method : methods) {
        System.out.println(method);
    }
    // 获取Person类的所有构造方法信息
    Constructor<?>[] constructors = clazz.getDeclaredConstructors();
    for (Constructor<?> constructor : constructors) {
        System.out.println(constructor);
    }
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

7、创建对象的两种方法

• Class对象的newInstance()

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

• 调用Constructor的newInstance()

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

8、反射到底慢在哪里

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

// 安全机制校验，Field/Method/Constructor
private void checkMemberAccess(int which, Class<?> caller, boolean checkProxyInterfaces){
    final SecurityManager s = System.getSecurityManager();
    if (s != null) {
        final ClassLoader ccl = ClassLoader.getClassLoader(caller);
        final ClassLoader cl = getClassLoader0();
        if (which != Member.PUBLIC) {
            if (ccl != cl) {
                s.checkPermission(SecurityConstants.CHECK_MEMBER_ACCESS_PERMISSION);
            }
        }
        this.checkPackageAccess(ccl, checkProxyInterfaces);
    }
}

9、反射单例模式的漏洞

简单单例

public class SingletonFactory {

    private volatile static SingletonFactory singletonFactory = null;

    private SingletonFactory() {
    }

    public static SingletonFactory getInstance() {
        if(singletonFactory == null) {
            synchronized (SingletonFactory.class) {
                if(singletonFactory == null) {
                     singletonFactory = new SingletonFactory();
                }
            }
        }
        return singletonFactory;
    }
}

反射破坏单例

public class TestReflectBreakSingleInstance {

    public static void main(String[] args) {
        SingletonFactory instance1 = null;
        SingletonFactory instance2 = null;
        Class<?> clazz = null;
        try {
            clazz = Class.forName("com.liziba.reflect.SingletonFactory");
            Constructor<?> constructor = clazz.getDeclaredConstructor(null);
            constructor.setAccessible(true);
            // 单例获取对象1
            instance1 = SingletonFactory.getInstance();
            // 反射获取对象2
            instance2 = (SingletonFactory)constructor.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 输出false
        System.out.println(instance1 == instance2);
    }
}

解决方法

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