1.反射机制
定义：能够在运行时分析类能力的程序称为反射（Reflection）。
反射机制的作用：在程序运行时能够获取类的完整结构信息及调用对象的方法。
（1）在运行中分析类的能力；（2）在运行中查看类对象；（3）实现通用数组操作代码；（4）利用Method对象获取类方法。
2.Class类
java.lang.Class<T>类是反射机制的基础，存放着对应类型对象的运行时信息。
在程序运行期间，Java运行时系统始终为所有的对象维护一个运行时类型标识java.lang.Class<T>对象。该Class<T>对象存放着所有关于该类型对象的运行时信息，虚拟机利用运行时类型信息选择相应的方法执行。
获取Class对象的方法：
（1）Object类中的getClass()方法将会返回一个Class类型的实例
（2）调用静态方法Class.forName获取类名对应的Class对象
（注意：如果类名保存在字符串中，并可在运行中改变，就可以使用这个方法。这个方法只有在className是类名或接口名是才能够执行，否则将抛出一个已检查异常。）
（3）如果T是任意的Java类型，T.class将代表匹配的类对象
（注意：一个Class对象实际上表示的是一个类型，而这个类型未必一定是一种类。例如，int不是类，但int.class是一个Class类型的对象）
（4）通过newInstance()方法创建一个类的实例
（注意：newInstance方法调用默认的构造器初始化新创建的对象。如果这个类没有默认构造器，就会抛出一个异常。）
（5）通过forName()和newInstance()方法结合创建一个类的实例
package com.nwpu.davince.reflection;
import java.sql.Date;
public class RefectionTest {
public static void main(String[] args)
throws ClassNotFoundException, InstantiationException, IllegalAccessException {
// Object类中的getClass()方法将会返回一个Class类型的实例
Person person = new Person();
Class class1 = person.getClass();
System.out.println(class1);
// 调用静态方法Class.forName获取类名对应的Class对象
String className = "com.nwpu.davince.reflection.Person";
Class class2 = Class.forName(className);
System.out.println(class2);
// 如果T是任意的Java类型，T.class将代表匹配的类对象
Class class3 = Date.class;
Class class4 = int.class;
Class class5 = Double[].class;
System.out.println(class3);
System.out.println(class4);
System.out.println(class5);
// 通过newInstance()方法创建一个类的实例
Person class6 = person.getClass().newInstance();
System.out.println(class6);
// 通过forName()和newInstance()方法结合创建一个类的实例
Person class7 = (Person) Class.forName(className).newInstance();
System.out.println(class7);
}
}
程序输出结果如下所示：
class com.nwpu.davince.reflection.Person
class com.nwpu.davince.reflection.Person
class java.sql.Date
int
class [Ljava.lang.Double;
Person [idNumber=null, phoneNo=null]
Person [idNumber=null, phoneNo=null]
3.利用反射分析类的能力
———————————反射机制最重要的内容：检查类的结构——————————
在java.lang.reflect包中有三个类Field、Method和Constructor分别用于描述类的域、方法和构造器。这三个类都有一个叫做getName的方法，用来返回项目的名称。
1）Class类中的getFields、getMethods和getConstructors方法将分别返回类提供的public域、方法和构造器数组，其中包括超类的公有成员。
2）Class类的getDeclareFields、getDeclareMethods和getDeclaredConstructors方法将分别返回类中声明的全部域、方法和构造器，其中包括私有和受保护成员，但不包括超类的成员。
package com.nwpu.davince.reflection;
public class Person {
private String idNumber;
private String phoneNo;
public Person() {
}
public Person(String idNumber, String phoneNo) {
this.idNumber = idNumber;
this.phoneNo = phoneNo;
}
public String getIdNumber() {
return idNumber;
}
public void setIdNumber(String idNumber) {
this.idNumber = idNumber;
}
public String getPhoneNo() {
return phoneNo;
}
public void setPhoneNo(String phoneNo) {
this.phoneNo = phoneNo;
}
@Override
public String toString() {
return "Person [idNumber=" + idNumber + ", phoneNo=" + phoneNo + "]";
}
}
package com.nwpu.davince.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Scanner;
public class ReflectionTest {
public static void main(String[] args) {
// read class name from command line args or user input
String name = "com.nwpu.davince.reflection.Person";
if (args.length > 0) {
name = args[0];
} else {
Scanner in = new Scanner(System.in);
System.out.println("Enter class name(e.g. java.util.Date): ");
in.next();
}
try {
// print class name and superClass name(if != Object)
Class cl = Class.forName(name);
Class superClass = cl.getSuperclass();
String modifiers = Modifier.toString(cl.getModifiers());
if (modifiers.length() > 0) {
System.out.println(modifiers + " ");
}
System.out.print("class " + name);
if (superClass != null && superClass != Object.class) {
System.out.print(" extends " + superClass.getName());
}
System.out.print("\n{\n");
printConstructors(cl);
System.out.println();
printMethods(cl);
System.out.println();
printFields(cl);
System.out.println("}");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
System.exit(0);
}
/**
* Prints all constructors of a class
*
* @param cl
*/
public static void printConstructors(Class cl) {
Constructor[] constructors = cl.getConstructors();
for (Constructor constructor : constructors) {
String name = constructor.getName();
System.out.print(" ");
String modifiers = Modifier.toString(cl.getModifiers());
if (modifiers.length() > 0) {
System.out.print(modifiers + " ");
}
System.out.print(name + "(");
// print parameter types
Class[] paramTypes = constructor.getParameterTypes();
for (int i = 0; i < paramTypes.length; i++) {
if (i > 0) {
System.out.print(", ");
}
System.out.print(paramTypes[i].getName());
}
System.out.println(");");
}
}
/**
* Prints all method of a class
*
* @param cl
*/
public static void printMethods(Class cl) {
Method[] methods = cl.getDeclaredMethods();
for (Method method : methods) {
Class returnType = method.getReturnType();
String name = method.getName();
System.out.print(" ");
// print modifiers,return type and method name
String modifiers = Modifier.toString(method.getModifiers());
if (modifiers.length() > 0) {
System.out.print(modifiers + " ");
}
System.out.println(returnType.getName() + " " + name + "(");
// print parameter types
Class[] paramTypes = method.getParameterTypes();
for (int i = 0; i < paramTypes.length; i++) {
if (i > 0) {
System.out.print(", ");
}
System.out.print(paramTypes[i].getName());
}
System.out.println(");");
}
}
/**
* Prints all fields of a class
*
* @param cl
*/
public static void printFields(Class cl) {
Field[] fields = cl.getDeclaredFields();
for (Field field : fields) {
Class type = field.getType();
String name = field.getName();
System.out.print(" ");
// print modifiers,return type and method name
String modifiers = Modifier.toString(field.getModifiers());
if (modifiers.length() > 0) {
System.out.print(modifiers + " ");
}
System.out.println(type.getName() + " " + name + ";");
}
}
}
输出结果如下：
Enter class name(e.g. java.util.Date):
com.nwpu.davince.reflection.Person
public class com.nwpu.davince.reflection.Person
{
// Prints all constructors of a class
public com.nwpu.davince.reflection.Person();
public com.nwpu.davince.reflection.Person(java.lang.String, java.lang.String);
// Prints all method of a class
public java.lang.String toString();
public java.lang.String getPhoneNo();
public void setIdNumber(java.lang.String);
public java.lang.String getIdNumber();
public void setPhoneNo(java.lang.String);
// Prints all fields of a class
private java.lang.String idNumber;
private java.lang.String phoneNo;
}
4.在运行时使用反射分析对象
在上一节中，我们已经知道如何查看任意对象的数据域名称和类型，本节将进一步查看数据域的实际内容。查看对象域的关键方法是Field类中的get方法。如果filed是一个Field类型的对象，obj是某个包含field域的类的对象，field.get(obj)将返回一个对象，其值为obj域的当前值。当然，可以获得就可以设置，调用field.set(obj,value)方法可以将obj对象的field域设置成新值。
package com.nwpu.davince.reflection;
import java.lang.reflect.Field;
public class FieldTest {
public static void main(String[] args) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
Person person = new Person("123", "13000001111");
Class clazz = person.getClass();
Field field = clazz.getDeclaredField("phoneNo");
field.setAccessible(true);
Object obj = field.get(person);
System.out.println("old obj: " + obj);
field.set(person, "13200002222");
Field field2 = clazz.getDeclaredField("phoneNo");
field2.setAccessible(true);
Object obj2 = field.get(person);
System.out.println("new obj: " + obj2);
}
}
输出结果为：
old obj: 13000001111
new obj:13200002222
注意：反射机制的默认行为受限于Java的访问控制，为访问私有成员属性，需要调用Field、Method或Constructor对象的setAccessible方法。setAccessible方法是AccessibleObject类中的一个方法，这个特性是为调试、持久存储和相似机制提供的。
5.使用反射编写泛型数组代码
——————————java.lang.reflect包中的Array类允许动态地创建数组———————————
例如，将这个特性应用到Array类中的copyOf方法实现数组容量扩展。如何编写通用的扩容方法呢？最关键的是Array类中的静态方法newInstance，它能够构造新数组。在调用它时必须提供两个参数，一个是数组的元素类型，一个是数组的长度。
（1）可以通过Array.getLength(arr)获取数组的长度，也可以通过Array类的静态getLength方法的返回值得到任意数组的长度。
（2）获取新数组元素类型：首先获得arr数组的类对象，确认它是一个数组并使用Class类的getComponentType方法确定数组对应的类型。
package com.nwpu.davince.reflection;
import java.lang.reflect.Array;
public class ArrayTest {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
System.out.println("old arr size=" + arr.length);
arr = (int[]) goodCopyOf(arr, 10);
System.out.println("new arr size=" + arr.length);
}
public static Object goodCopyOf(Object arr,int newLength) {
// 首先获取arr数组的类对象
Class cl = arr.getClass();
// 确认它是否是一个数组
if (!cl.isArray()) {
return null;
}
// 使用Class的getComponentType()方法确定数组对应的类型
Class componentType = cl.getComponentType();
int length = Array.getLength(arr);
// 使用java.lang.Array的newInstance()方法动态创建新的数组
Object newArray = Array.newInstance(componentType, newLength);
// 数组复制
System.arraycopy(arr, 0, newArray, 0, Math.min(length, newLength));
return newArray;
}
}
输出结果为：
old arr size=5
new arr size=10
6.调用任意方法
——————在Method类中有一个invoke方法，它允许调用包装在当前Method对象中的方法————
@CallerSensitive
public Object invoke(Object obj, Object... args)
throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException
{
if (!override) {
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
Class<?> caller = Reflection.getCallerClass();
checkAccess(caller, clazz, obj, modifiers);
}
}
MethodAccessor ma = methodAccessor; // read volatile
if (ma == null) {
ma = acquireMethodAccessor();
}
return ma.invoke(obj, args);
}
如何得到Method对象呢？可以通过调用getDeclareMethods方法，然后对返回的Method对象数组进行查找，知道发现为止。也可以通过Class类中的getMethod方法得到想要的方法。但方法可能存在重名情况，因此需要有方法的参数类型才能区别出是哪个方法。故getMethod的方法签名如下所示：
@CallerSensitive
public Method getMethod(String name, Class<?>... parameterTypes)
throws NoSuchMethodException, SecurityException {
checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
Method method = getMethod0(name, parameterTypes, true);
if (method == null) {
throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
}
return method;
}
注意：invoke的参数和返回值必须是Object类型的，意味着必须进行多次的类型转换，将会使编译器错过检查代码的机会。有鉴于此，建议仅在有必要的时候才是用Method对象，而最好使用接口和内部类。特别重申：建议Java开发者不要使用Method对象的回调功能，使用接口进行回调会使得代码的执行速度更快，更易于维护。
原创不易，如需转载，请注明出处@author Davince！
