Java 反射机制

什么是反射？

Java 的反射机制可以使得程序在 Java 运行时能够检测、访问并且修改编译时完全未知的 classes，这个概念很容易和内省混淆。下面是 WiKi 上对这两个概念给出的定义：

反射（Reflection）：反射是指计算机程序在运行时可以访问、检测和修改它本身状态或行为的一种能力。
内省（Introspection）：内省是指计算机程序在运行检查对象类型的一种能力，通常也可以称作运行时类型检查。

从上面的定义可以看出，相对于内省，反射更进一步。例如，Java 具有反射特性，而 C++ 不具有反射特性只具有内省特性。

反射有什么用途？

反射主要提供以下功能：

1. 在运行时检查对象的类型

2. 在运行时新建类的实例

3. 在运行时检测对象一个类的成员变量和方法

4. 在运行时调用对象的任意方法

5. 在运行时修改构造函数、成员变量和方法的访问权限

6. 等等

例如，可以使用反射获得或修改一个对象的私有成员变量，调用对象的私有方法。而要在Java中使用反射，需要用到 java.lang.reflect 包中的下面几个类：

1. Class 类：java.lang.Class, 代表类的定义。

2. Construcor 类：java.lang.reflect.Constructor，代表类的构造函数。

3. Field 类：java.lang.reflect.Field，代表类的成员变量。

4. Method 类：java.lang.reflect.Method，代表类的方法。

5. Array 类：java.lang.reflect.Array，提供动态创建访问数组的静态方法

注：如果要反射内部类，Class.forName()时类名需要写为 “packageName.className$innerClassName”

反射的使用例子

新建类的实例

/**
 * 根据类名和构造函数的参数新建一个对象实例，只能通过 public 的构造函数新建实例。
 * @param className 类名
 * @param args      构造函数的参数
 * @param argClasses 构造函数的参数的 class type
 * @return 该类的对象实例
 */
public static Object newInstance(String className, Object[] args, Class<?>[] argClasses) {
    Object instance = null;
    try {
        Class classObj = Class.forName(className);
        Constructor cons = classObj.getConstructor(argClasses);
        instance = cons.newInstance(args);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return instance;
}

获得类的静态属性

/**
 * 获得类的静态属性值，不管是 public 或者 private 的都可以。
 * @param className 类名
 * @param fieldName 属性名
 * @return 该类的静态属性值
 */
public static Object getStaticField(String className, String fieldName) {
    Object fieldValue = null;
    try {
        Class classObj = Class.forName(className);
        Field field = classObj.getDeclaredField(fieldName);
        field.setAccessible(true);
        fieldValue = field.get(null); // note: Field.get(Object obj), If this field is static, the object argument is ignored.
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return fieldValue;
}

修改类的静态属性

/**
 * 修改类的静态属性值，不管是 public 或者 private 的都可以。
 * @param className 类名
 * @param fieldName 属性名
 * @param value     修改后的属性值
 * @return true，如果修改成功; false，如果修改失败
 */
public static boolean setStaticField(String className, String fieldName, Object value) {
    boolean result = false;
    try {
        Class classObj = Class.forName(className);
        Field field = classObj.getDeclaredField(fieldName);
        field.setAccessible(true);
        field.set(null, value);
        result = true;
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return result;
}

获得对象的属性

/**
 * 获得对象的属性值，不管是 public 或者 private 的都可以，
 * 但是该方法只能获得在该对象的类中所定义的成员变量的值，不能获得其父类的成员变量的值。
 * @param owner     对象
 * @param fieldName 对象所属类的属性名
 * @return 对象所属类中的属性值
 */
public static Object getField(Object owner, String fieldName) {
    Object fieldValue = null;
    try {
        Class classObj = owner.getClass();
        Field field = classObj.getDeclaredField(fieldName);
        field.setAccessible(true);
        fieldValue = field.get(owner);
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return fieldValue;
}

获得对象所属类的父类中的属性

/**
 * 获得对象的属性值（属性是对象的父类中定义的），不管是 public 或者 private 的都可以。
 * @param owner     对象
 * @param className 对象所属类的父类的类名
 * @param fieldName 对象所属类的父类的属性名
 * @return 对象所属类的父类的属性值
 */
public static Object getField(Object owner, String className, String fieldName) {
    Object fieldValue = null;
    try {
        Class classObj = Class.forName(className);
        Field field = classObj.getDeclaredField(fieldName);
        field.setAccessible(true);
        fieldValue = field.get(owner);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    }
    return fieldValue;
}

修改对象的属性

/**
 * 修改对象的属性值，不管是 public 或者 private 的都可以，
 * 但是该方法只能修改在该对象的类中所定义的成员变量的值，不能修改其父类的成员变量的值。
 * @param owner     对象
 * @param fieldName 对象所属类的属性名
 * @param value     修改后的属性值
 * @return true，如果修改成功; false，如果修改失败
 */
public static boolean setField(Object owner, String fieldName, Object value) {
    boolean result = false;
    try {
        Class classObj = owner.getClass();
        Field field = classObj.getDeclaredField(fieldName);
        field.setAccessible(true);
        field.set(owner, value);
        result = true;
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return result;
}

修改对象所属类的父类中的属性

/**
 * 修改对象的属性值（属性是对象的父类中定义的），不管是 public 或者 private 的都可以。
 * @param owner     对象
 * @param className 对象所属类的父类的类名
 * @param fieldName 对象所属类的父类的属性名
 * @param value     修改后的属性值
 * @return true，如果修改成功; false，如果修改失败
 */
public static boolean setField(Object owner, String className, String fieldName, Object value) {
    boolean result = false;
    try {
        Class classObj = Class.forName(className);
        Field field = classObj.getDeclaredField(fieldName);
        field.setAccessible(true);
        field.set(owner, value);
        result = true;
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    }
    return result;
}

调用类的静态方法

/**
 * 调用类的静态方法，不管是 public 或者 private 的都可以。
 * @param className     类名
 * @param methodName    静态方法名
 * @param args          方法的参数
 * @param argClasses    方法的参数的 class type
 * @return 静态方法的返回值
 */
public static Object invokeStaticMethod(String className, String methodName, Object[] args, Class<?>[] argClasses) {
    Object result = null;
    try {
        Class classObj = Class.forName(className);
        Method method = classObj.getDeclaredMethod(methodName, argClasses);
        method.setAccessible(true);
        result = method.invoke(null, args);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return result;
}

调用对象的方法

/**
 * 调用对象的方法，不管是 public 或者 private 的都可以。
 * 但是该方法只能调用对象所属类中定义的方法，不能调用其父类中定义的方法。
 * @param owner         对象
 * @param methodName    对象所属类的方法名
 * @param args          方法的参数
 * @param argClasses    方法的参数的 class type
 * @return 方法的返回值
 */
public static Object invokeMethod(Object owner, String methodName, Object[] args, Class<?>[] argClasses) {
    Object result = null;
    try {
        Class classObj = owner.getClass();
        Method method = classObj.getDeclaredMethod(methodName, argClasses);
        method.setAccessible(true);
        result = method.invoke(owner, args);
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return  result;
}

调用对象所属类的父类的方法

/**
 * 调用对象的方法（方法是在对象所属类的父类中定义的），不管是 public 或者 private 的都可以。
 * 如果这个方法在子类中重写的话，实际上还是调用子类的重写方法
 * @param owner         对象
 * @param className     对象所属类的父类的类名
 * @param methodName    对象所属类的父类的方法名
 * @param args          方法参数
 * @param argClasses    方法的参数的 class type
 * @return 方法的返回值
 */
public static Object invokeMethod(Object owner, String className, String methodName, Object[] args, Class<?>[] argClasses) {
    Object result = null;
    try {
        Class classObj = Class.forName(className);
        Method method = classObj.getDeclaredMethod(methodName, argClasses);
        method.setAccessible(true);
        result = method.invoke(owner, args);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return  result;
}

获得对象的类

这里要区分基本类型与其对应的包装类是不一样的

/**
 * first of all, int.class != Integer.class. but int.class == Integer.TYPE
 * the is similarly to other primitive type, such as float, boolean, double, byte, char, short, long.
 *
 * ---------------------------------
 * int a = 12;
 * Object[] args = new Object[]{a};
 * ---------------------------------
 *
 * in last code block, args[0].class is Integer.class because JVM cast a to Integer type in Java.
 * in that case, this getClassTypes method will return wrong so if args contains primitive type(like int, boolean) you should not use this method.
 *
 * @param args
 * @return the class type of args
 */
public static Class<?>[] getClassTypes(Object[] args) {
    if(null == args || args.length == 0) {
        return null;
    }
    Class<?>[] argClasses = new Class<?>[args.length];
    for(int i = 0; i < args.length; i ++){
        argClasses[i] = args[i].getClass();
    }
    return argClasses;
}

新建一个数组

/**
 * 新建一个类型的数组
 * @param className 数组的类型的类名
 * @param len       数组的大小
 * @return 数组
 */
public static Object newArrayInstance (String className, int len) {
    Object result = null;
    try {
        Class classObj = Class.forName(className);
        result = Array.newInstance(classObj, len);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    return result;
}

获得数组的元素

/**
 * 获得数组中的一个元素
 * @param array 数组
 * @param index 元素在数组中的位置
 * @return 数组中的这个元素
 */
public static Object getObjectInArray(Object array, int index) {
    return Array.get(array, index);
}

修改数组的元素

/**
 * 修改数组中的一个元素的值
 * @param array 数组
 * @param index 元素在数组中的位置
 * @param value 修改后的元素值
 */
public static void setObjectInArray(Object array, int index, Object value) {
    Array.set(array, index, value);
}

最后给出我个人的源代码 http://johnnyshieh.me/uploads/ReflectionUtils.java

参考链接：

• http://www.programcreek.com/2013/09/java-reflection-tutorial/

• http://tutorials.jenkov.com/java-reflection/index.html