Java 反射

一、概念

1.1 概念

简单说，JAVA反射机制是指在运行态可直接操作任意类或对象的所有属性和方法的功能。

1.2 反射的用途

  • 在运行时获取任意对象所属的类

    1. Class<?> clazz = Class.forName(String className);

  • 在运行时构造任意类的对象

    1. Object obj = clazz.newInstance();

  • 在运行时获取任意类所具有的成员变量和方法

    1. field.set(Object obj, Object value);
    2. field.get(Object obj);

  • 在运行时调用任意对象的方法 （最常见的需求，尤其是当该方法是私有方法或者隐藏方法）

    1. method.invoke(Object obj, Object... args);

    反射还可以获取类的其他信息，包含modifiers（下面会介绍），以及superclass，实现的interfaces等。
    针对动态语言，大致认同的一个定义是：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。反射机制在运行时只能调用methods或改变fields内容，却无法修改程序结构或变量类型。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。

    二、反射

    2.1 核心类

    java.lang.Class：代表类
    java.lang.reflect.Constructor: 代表类的构造方法
    java.lang.reflect.Field: 代表类的属性
    java.lang.reflect.Method: 代表类的方法
    java.lang.reflect.Modifier：代表类、方法、属性的描述修饰符。
    其中Modifier取值范围如下：
    public, protected, private, abstract, static, final, transient, volatile, synchronized, native, strictfp, interface。
    Constructor， Field， Method这三个类都继承AccessibleObject，该对象有一个非常重要的方法setAccessible(boolean flag), 借助该方法，能直接调用非Public的属性与方法。

    2.2 核心方法

    1.成员属性(Field)：

    1. getFields()：获得类的public类型的属性。
    2. getDeclaredFields()：获得类的所有属性。
    3. getField(String name)
    4. getDeclaredField(String name)：获取类的特定属性

    2.成员方法(Method)：

    1. getMethods()：获得类的public类型的方法。
    2. getDeclaredMethods()：获得类的所有方法。
    3. getMethod(String name, Class[] parameterTypes)：获得类的特定方法
    4. getDeclaredMethod(String name, Class[] parameterTypes)：获得类的特定方法

    3.构造方法(Constructor)：

    1. getConstructors()：获得类的public类型的构造方法。
    2. getDeclaredConstructors()：获得类的所有构造方法。
    3. getConstructor(Class[] parameterTypes)：获得类的特定构造方法
    4. getDeclaredConstructor(Class[] params)；获得类的特定方法

    2.3 深入Class类

    Java所有的类都是继承于Oject类，其内声明了多个应该被所有Java类覆写的方法：hashCode()、equals()、clone()、toString()、notify()、wait()、getClass()等，其中getClass返回的便是一个Class类的对象。Class类也同样是继承Object类，拥有相应的方法。
    Java程序在运行时，运行时系统对每一个对象都有一项类型标识，用于记录对象所属的类。虚拟机使用运行时类型来选择相应方法去执行，保存所有对象类型信息的类便是Class类。
    Class类没有公共构造方法，Class对象是在加载类时由 Java 虚拟机以及通过调用ClassLoader的defineClass 方法自动构造的，因此不能显式地声明一个Class对象。
    虚拟机为每种类型管理一个独一无二的Class对象。也就是说，每个类（型）都有一个Class对象。运行程序时，Java虚拟机(JVM)首先检查是否所要加载的类对应的Class对象是否已经加载。如果没有加载，JVM就会根据类名查找.class文件，并将其Class对象载入。
    基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也都对应一个 Class 对象。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。一般某个类的Class对象被载入内存，它就用来创建这个类的所有对象。

    三、用处

    1.如何通过反射获取一个类？

    Class.forName(String className); (最常用)
    Java反射知识点总汇 - 图1

    2.如何调用私有类，或者类的私有方法或属性？

  • 私有类：通过getDeclaredConstructor获取constructor，再调用constructor.setAccessible(true);

  • 私有方法：通过getDeclaredMethod获取method，再调用method.setAccessible(true);
  • 私有属性：通过getDeclaredField获取field，再调用field.setAccessible(true);

    3.@hide标记是做什么的，反射能否调用@hide标记的类？

    在Android的源码中，发现有很多被“@hide”标记的类，它的作用是使这个类或方法在生成SDK时不可见。那么应用程序便不可以直接调用。而反射机制可调用@hide标记的类或方法，如入无人之地，畅通无阻。

    4.如何通过反射调用内部类？

    假设com.reflect.Outer类有一个内部类inner，调用方法如下：
    1. String className = "com.reflect.Outer$inner";
    2. Class.forName(className);

    五、反射用法

    反射是为了在运行态能操作类和对象，接下来重点介绍如何反射使用。
    对于正常方式来调用方法，往往只需要一行到两行代码，即可完成相应工作。而反射则显得比较繁琐，之所以繁琐仍然使用反射方式，是因为反射能干很多正常实例化对象的方式所无法做到的事。比如操作那些private的类、方法、属性，以及@hide标记过的类、方法、属性。
    为了到达即能有反射的功效，同时调用方法简单易用，写了一个ReflectUtils类。对于方法调用，与正常对象的调用过程差不多。主要有以下4类需要用到反射的地方：
  1. 调用类的静态方法
  2. 调用类的非静态方法
  3. set/get类的静态属性
  4. set/get类的非静态属性

    5.1 ReflectUtils类用法

    调用流程一般为先获取类或对象，再调用相应方法。针对上述4种需求，用法分别如下：

    1. 调用类的静态方法
    对于参数方法，只需把参数，紧跟方法名后面，可以跟不定长的参数个数。

    1. Class<?> clazz = ReflectUtils.getClazz("com.fcant.model.Outer"); //获取class
    2. ReflectUtils.invokeStaticMethod(clazz, "outerStaticMethod");  //无参方法
    3. ReflectUtils.invokeStaticMethod(clazz, "outerStaticMethod","fcant"); //有参数方法

    2. 调用类的非静态方法

    ```java Object obj = ReflectUtils.newInstance(“com.fcant.model.Outer”); //实例化对象 ReflectUtils.invokeMethod(obj, “outerMethod”); //无参方法 ReflectUtils.invokeMethod(obj, “outerMethod”, “fcant”); //有参方法 3. set/get类的静态属性

ReflectUtils.getStaticField(clazz, “outerStaticField”); //get操作 ReflectUtils.setStaticField(clazz, “outerStaticField”, “new value”); //set操作

  1. <a name="KoUi4"></a>
  2. #### 3. set/get类的非静态属性
  3. ```java
  4. ReflectUtils.getField(obj, "outerField");  //get操作
  5. ReflectUtils.setField(obj, "outerField", "new value"); //set操作

如果只知道类名，需先查看该类的所有方法详细参数信息，可以通过调用dumpClass(String className) ，返回值是String，记录着所有构造函数，成员方法，属性值的信息。

5.2 核心代码

关于ReflectUtils类，列表部分核心方法。
先定义一个Outer类，包名假设为com.fcant.model，对于该类，非public，构造方法，成员方法，属性都是private：

  1. class Outer {
  2.     private String outerField = "outer Field";
  3.     private static String outerStaticField = "outer static Field";
  5.     private Outer(){
  6.         System.out.println("I'am outer construction without args");
  7.     }
  9.     private Outer(String outerField){
  10.         this.outerField = outerField;
  11.         System.out.println("I'am outer construction with args "+ this.outerField);
  12.     }
  14.     private void outerMethod(){
  15.         System.out.println("I'am outer method");
  16.     }
  18.     private void outerMethod(String param){
  19.         System.out.println("I'am outer method with param "+param);
  20.     }
  22.     private static void outerStaticMethod(){
  23.         System.out.println("I'am outer static method");
  24.     }
  26.     private static void outerStaticMethod(String param){
  27.         System.out.println("I'am outer static method with param "+param);
  28.     }
  29. }

构造函数，获取类的实例化对象：

  1. /** 
  2.  * 实例化获取类名对应的类 * 
  3.  * @param clazz 类 
  4.  * @param constructorArgs 构造函数的各个参数 
  5.  * @return 实例化对象 
  6.  */
  7. public static Object newInstance(Class clazz, Object... constructorArgs) {
  8.     if (clazz == null) {
  9.         return null;
  10.     }
  12.     Object object = null;
  14.     int argLen = constructorArgs == null ? 0 : constructorArgs.length;
  15.     Class<?>[] parameterTypes = new Class[argLen];
  16.     for (int i = 0; i < argLen; i++) {
  17.         parameterTypes[i] = constructorArgs[i].getClass();
  18.     }
  20.     try {
  21.         Constructor constructor = clazz.getDeclaredConstructor(parameterTypes);
  22.         if (!constructor.isAccessible()) {
  23.             constructor.setAccessible(true);
  24.         }
  25.         object = constructor.newInstance(constructorArgs);
  27.     } catch (Exception e) {
  28.         e.printStackTrace();
  29.     }
  31.     return object;
  32. }

对象方法的反射调用如下：

  1. /** 
  2.  * 反射调用方法 * 
  3.  * @param object 反射调用的对象实例 
  4.  * @param methodName 反射调用的对象方法名 
  5.  * @param methodArgs 反射调用的对象方法的参数列表 
  6.  * @return 反射调用执行的结果 
  7.  */
  8. public static Object invokeMethod(Object object, String methodName, Object... methodArgs) {
  9.     if (object == null) {
  10.         return null;
  11.     }
  13.     Object result = null;
  14.     Class<?> clazz = object.getClass();
  15.     try {
  16.         Method method = clazz.getDeclaredMethod(methodName, obj2class(methodArgs));
  17.         if (method != null) {
  18.             if (!method.isAccessible()) {
  19.                 method.setAccessible(true);  //当私有方法时，设置可访问
  20.             }
  21.             result = method.invoke(object, methodArgs);
  22.         }
  23.     } catch (Exception e) {
  24.         e.printStackTrace();
  25.     }
  27.     return result;
  29. }

对象属性值的反射获取方法：

  1. /**
  2.  * 反射调用，获取属性值 * 
  3.  * @param object 操作对象 
  4.  * @param fieldName 对象属性 
  5.  * @return 属性值 
  6.  */
  7. public static Object getField(Object object, String fieldName) {
  8.     if (object == null) {
  9.         return null;
  10.     }
  12.     Object result = null;
  13.     Class<?> clazz = object.getClass();
  14.     try {
  15.         Field field = clazz.getDeclaredField(fieldName);
  16.         if (field != null) {
  17.             if (!field.isAccessible()) {
  18.                 field.setAccessible(true);
  19.             }
  20.             result = field.get(object);
  21.         }
  22.     } catch (Exception e) {
  23.         e.printStackTrace();
  24.     }
  25.     return result;
  26. }

类属性的反射设置过程：

  1. /** 
  2.  * 反射调用，设置属性值 
  3.  * @param clazz 操作类 
  4.  * @param fieldName 属性名 
  5.  * @param value 属性的新值 
  6.  * @return 设置是否成功 
  7.  */
  8. public static boolean setStaticField(Class clazz, String fieldName, Object value) {
  9.     if (clazz == null) {
  10.         return false;
  11.     }
  13.     Object result = null;
  14.     try {
  15.         Field field = clazz.getDeclaredField(fieldName);
  16.         if (field != null) {
  17.             if (!field.isAccessible()) {
  18.                 field.setAccessible(true);
  19.             }
  20.             field.set(null, value);
  21.         }
  22.     } catch (Exception e) {
  23.         e.printStackTrace();
  24.         return false;
  25.     }
  26.     return true;
  27. }

六、内部类的反射用法

对于内部类，这里比较复杂，而内部类又分static内部类与非static内部类，两者的反射方式还是有区别的。static内部类与非static内部类的反射调用，根本区别在于构造方法不一样。下面通过代码来告诉如何正确。

6.1 static与非static内部类的反射差异

先定义一个包含两个内部类的类：

  1. class Outer {
  2.     /** 
  3.      * 普通内部类 
  4.      */
  5.     class Inner {
  6.         private String innerField = "inner Field";
  8.         private Inner(){
  9.             System.out.println("I'am Inner construction without args");
  10.         }
  12.         private Inner(String innerField){
  13.             this.innerField = innerField;
  14.             System.out.println("I'am Inner construction with args "+ this.innerField);
  15.         }
  17.         private void innerMethod(){
  18.             System.out.println("I'am inner method");
  19.         }
  20.     }
  22.     /** * 静态内部类 */
  23.     static class StaticInner {
  25.         private String innerField = "StaticInner Field";
  26.         private static String innerStaticField = "StaticInner static Field";
  28.         private StaticInner(){
  29.             System.out.println("I'am StaticInner construction without args");
  30.         }
  32.         private StaticInner(String innerField){
  33.             this.innerField = innerField;
  34.             System.out.println("I'am StaticInner construction with args "+ this.innerField);
  35.         }
  37.         private void innerMethod(){
  38.             System.out.println("I'am StaticInner method");
  39.         }
  41.         private static void innerStaticMethod(){
  42.             System.out.println("I'am StaticInner static method");
  43.         }
  44.     }
  45. }

对于上面两个内部类，如果直接实例化内部类，该怎么做，抛开private等权限不够的问题，应该是这样的：

  • 静态内部类：Outer.StaticInner sInner = new Outer.StaticInner();
  • 非静态内部类： Outer.Inner inner = new Outer().new Inner();

这种差异，在于内部类的构造方法不一样。可以通过下面的方法dumpClass()来比较。

  1. /** * 获取类的所有 构造函数，属性，方法 * * @param className 类名 * @return */
  2. public static String dumpClass(String className) {
  3.     StringBuffer sb = new StringBuffer();
  4.     Class<?> clazz;
  5.     try {
  6.         clazz = Class.forName(className);
  7.     } catch (ClassNotFoundException e) {
  8.         e.printStackTrace();
  9.         return "";
  10.     }
  12.     Constructor<?>[] cs = clazz.getDeclaredConstructors();
  13.     sb.append("------ Constructor ------> ").append("\n");
  14.     for (Constructor<?> c : cs) {
  15.         sb.append(c.toString()).append("\n");
  16.     }
  18.     sb.append("------ Field ------>").append("\n");
  19.     Field[] fs = clazz.getDeclaredFields();
  20.     for (Field f : fs) {
  21.         sb.append(f.toString()).append("\n");
  22.         ;
  23.     }
  24.     sb.append("------ Method ------>").append("\n");
  25.     Method[] ms = clazz.getDeclaredMethods();
  26.     for (Method m : ms) {
  27.         sb.append(m.toString()).append("\n");
  28.     }
  29.     return sb.toString();
  30. }

通过dumpClass()，对比可以发现，

  • static内部类的默认构造函数：private void com.fcant.model.Outer$StaticInner.innerMethod()
  • 非static内部类的默认构造函数：private com.fcant.model.Outer$Inner(com.fcant.model.Outer)，多了一个参数com.fcant.model.Outer，也就是说非static内部类保持了外部类的引用。从属性也会发现多了一个final属性final com.fcant.model.Outer com.fcant.model.Outer$Inner.this$0，这正是用于存储外部类的属性值。

正是这差异，导致两者的反射调用过程中构造方法的使用不一样。另外内部类的类名使用采用$符号，来连接外部类与内部类，格式为outer$inner。

6.2 static内部类的 ReflectUtils类用法

1. 调用类的静态方法（先获取类，再调用）

  1. Class<?> clazz = ReflectUtils.getClazz("com.fcant.model.Outer$StaticInner"); //获取class
  2. ReflectUtils.invokeStaticMethod(clazz, "innerStaticMethod");  //无参方法
  3. ReflectUtils.invokeStaticMethod(clazz, "innerStaticMethod","fcant"); //有参数方法

2. 调用类的非静态方法（先获取对象，再调用）

  1. Object obj = ReflectUtils.newInstance("com.fcant.model.Outer$StaticInner");  //实例化对象
  2. ReflectUtils.invokeMethod(obj, "innerMethod");  //无参方法
  3. ReflectUtils.invokeMethod(obj, "innerMethod", "fcant"); //有参方法

3. set/get类的静态属性（先获取类，再调用）

  1. ReflectUtils.getStaticField(clazz, "innerField"); //get操作
  2. ReflectUtils.setStaticField(clazz, "innerField", "new value"); //set操作

4. set/get类的非静态属性（先获取对象，再调用）

  1. ReflectUtils.getField(obj, "innerField");  //get操作
  2. ReflectUtils.setField(obj, "innerField", "new value"); //set操作 ### 2.2 非static内部类的 `ReflectUtils`类用法 非static内部类，不能定义静态方法和静态属性，故操作只有两项：

5. 调用类的非静态方法（先获取对象，再调用）

  1. // 获取外部类实例，这是static内部类所不需要的，注意点
  2. Object outObj = ReflectUtils.newInstance("com.fcant.model.Outer"); 
  3. Object obj = ReflectUtils.newInstance("com.fcant.model.Outer$Inner"， outObj);  //实例化对象
  4. ReflectUtils.invokeMethod(obj, "innerMethod");  //无参方法
  5. ReflectUtils.invokeMethod(obj, "innerMethod", "fcant"); //有参方法

6. set/get类的非静态属性（先获取对象，再调用）

  1. ReflectUtils.getField(obj, "innerField");  //get操作
  2. ReflectUtils.setField(obj, "innerField", "new value"); //set操作