开发的时候有时候会碰到这样的情况，我们在写程序的时候并不知道需要调用某个对象的哪个方法，只有程序运行后，我们才能够知道。或许我们需要根据客户端传过来的某个String 参数的值来判断我们应该执行哪个方法。在这种情况下JAVA 的反射执行就可以帮上忙了。下面是我做的一个简单的测试代码，提供给大家做个参考。
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* @author Dong
* 测试 JAVA reflect 机制
*/
public class TestRef {
/**
* @param args
*/
public static void main(String[] args) {
TestBean test = new TestBean();
Method[] methods = test.getClass().getMethods();
test.setAbc("---");
for ( int i=0;i<methods.length;i++) {
if (methods[i].getName().equalsIgnoreCase("getabc")) {
try {
System.out.println(methods[i].invoke(test));
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
}
}
JAVA 反射机制
JAVA 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java 语言的反射机制。
Java 反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
1. 得到某个对象的属性
1 public Object getProperty(Object owner, String fieldName) throws Exception {
2 Class ownerClass = owner.getClass();
3
4 Field field = ownerClass.getField(fieldName);
5
6 Object property = field.get(owner);
7
8 return property;
9 }
Class ownerClass = owner.getClass() ：得到该对象的Class 。
Field field = ownerClass.getField(fieldName) ：通过Class 得到类声明的属性。
Object property = field.get(owner) ：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException 。
2. 得到某个类的静态属性
1 public Object getStaticProperty(String className, String fieldName)
2 throws Exception {
3 Class ownerClass = Class.forName(className);
4
5 Field field = ownerClass.getField(fieldName);
6
7 Object property = field.get(ownerClass);
8
9 return property;
10 }
Class ownerClass = Class.forName(className) ：首先得到这个类的Class 。
Field field = ownerClass.getField(fieldName) ：和上面一样，通过Class 得到类声明的属性。
Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class 里取。
3. 执行某对象的方法
1 public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
2
3 Class ownerClass = owner.getClass();
4
5 Class[] argsClass = new Class[args.length];
6
7 for (int i = 0, j = args.length; i < j; i++) {
8 argsClass[i] = args[i].getClass();
9 }
10
11 Method method = ownerClass.getMethod(methodName, argsClass);
12
13 return method.invoke(owner, args);
14 }
Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class 。
5 ～9 行：配置参数的Class 数组，作为寻找Method 的条件。
Method method = ownerClass.getMethod(methodName, argsClass) ：通过Method 名和参数的Class 数组得到要执行的Method 。
method.invoke(owner, args) ：执行该Method ，invoke 方法的参数是执行这个方法的对象，和参数数组。返回值是Object ，也既是该方法的返回值。
4. 执行某个类的静态方法
1 public Object invokeStaticMethod(String className, String methodName,
2 Object[] args) throws Exception {
3 Class ownerClass = Class.forName(className);
4
5 Class[] argsClass = new Class[args.length];
6
7 for (int i = 0, j = args.length; i < j; i++) {
8 argsClass[i] = args[i].getClass();
9 }
10
11 Method method = ownerClass.getMethod(methodName, argsClass);
12
13 return method.invoke(null, args);
14 }
基本的原理和实例3 相同，不同点是最后一行，invoke 的一个参数是null ，因为这是静态方法，不需要借助实例运行。
5. 新建实例
1
2 public Object newInstance(String className, Object[] args) throws Exception {
3 Class newoneClass = Class.forName(className);
4
5 Class[] argsClass = new Class[args.length];
6
7 for (int i = 0, j = args.length; i < j; i++) {
8 argsClass[i] = args[i].getClass();
9 }
10
11 Constructor cons = newoneClass.getConstructor(argsClass);
12
13 return cons.newInstance(args);
14
15 }
这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance() 来实现。
Class newoneClass = Class.forName(className) ：第一步，得到要构造的实例的Class 。
第5 ～第9 行：得到参数的Class 数组。
Constructor cons = newoneClass.getConstructor(argsClass) ：得到构造子。
cons.newInstance(args) ：新建实例。
6. 判断是否为某个类的实例
1 public boolean isInstance(Object obj, Class cls) {
2 return cls.isInstance(obj);
3 }
7. 得到数组中的某个元素
1 public Object getByArray(Object array, int index) {
2 return Array.get(array,index);
3 }
Java 反射机制深入研究
Java 反射是 Java 语言的一个很重要的特征，它使得 Java 具体了 “ 动态性 ” 。
在 Java 运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。这种动态获取类的信息以及动态调用对象的方法的功能来自于 Java 语言的反射（ Reflection ）机制。
Java 反射机制主要提供了以下功能：
在运行时判断任意一个对象所属的类。
在运行时构造任意一个类的对象。
在运行时判断任意一个类所具有的成员变量和方法。
在运行时调用任意一个对象的方法。
Reflection 是 Java 被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过 Reflection APIs 取得任何一个已知名称的 class 的内部信息，包括其 modifiers （诸如 public, static 等等）、 superclass （例如 Object ）、实现之interfaces （例如 Serializable ），也包括 fields 和 methods 的所有信息，并可于运行时改变 fields 内容或调用 methods 。
一般而言，开发者社群说到动态语言，大致认同的一个定义是： “ 程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言” 。从这个观点看， Perl ， Python ， Ruby 是动态语言， C++ ， Java ， C# 不是动态语言。
尽管在这样的定义与分类下 Java 不是动态语言，它却有着一个非常突出的动态相关机制： Reflection 。这个字的意思是 “ 反射、映象、倒影 ” ，用在 Java 身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的 classes 。换句话说， Java 程序可以加载一个运行时才得知名称的 class ，获悉其完整构造（但不包括 methods 定义），并生成其对象实体、或对其 fields 设值、或唤起其 methods 。这种 “ 看透 class” 的能力（ the ability of the program to examine itself ）被称为 introspection （内省、内观、反省）。 Reflection 和 introspection 是常被并提的两个术语。
在 JDK 中，主要由以下类来实现 Java 反射机制，这些类都位于 java.lang.reflect 包中：
Class 类：代表一个类。
Field 类：代表类的成员变量（成员变量也称为类的属性）。
Method 类：代表类的方法。
Constructor 类：代表类的构造方法。
Array 类：提供了动态创建数组，以及访问数组的元素的静态方法。
下面给出几个例子看看 Reflection API 的实际运用：
一、通过 Class 类获取成员变量、成员方法、接口、超类、构造方法等
在 java.lang.Object 类中定义了 getClass() 方法，因此对于任意一个 Java 对象，都可以通过此方法获得对象的类型。 Class 类是Reflection API 中的核心类，它有以下方法
getName() ：获得类的完整名字。
getFields() ：获得类的 public 类型的属性。
getDeclaredFields() ：获得类的所有属性。
getMethods() ：获得类的 public 类型的方法。
getDeclaredMethods() ：获得类的所有方法。
getMethod(String name, Class[] parameterTypes) ：获得类的特定方法， name 参数指定方法的名字， parameterTypes 参数指定方法的参数类型。
getConstructors() ：获得类的 public 类型的构造方法。
getConstructor(Class[] parameterTypes) ：获得类的特定构造方法， parameterTypes 参数指定构造方法的参数类型。
newInstance() ：通过类的不带参数的构造方法创建这个类的一个对象。
下面给出一个综合运用的例子：
public class RefConstructor {
public static void main(String args[]) throws Exception {
RefConstructor ref = new RefConstructor();
ref.getConstructor();
}
public void getConstructor() throws Exception {
Class c = null;
c = Class.forName("java.lang.Long");
Class cs[] = {java.lang.String.class};
System.out.println("/n-------------------------------/n");
Constructor cst1 = c.getConstructor(cs);
System.out.println("1 、通过参数获取指定 Class 对象的构造方法： ");
System.out.println(cst1.toString());
Constructor cst2 = c.getDeclaredConstructor(cs);
System.out.println("2 、通过参数获取指定 Class 对象所表示的类或接口的构造方法： ");
System.out.println(cst2.toString());
Constructor cst3 = c.getEnclosingConstructor();
System.out.println("3 、获取本地或匿名类 Constructor 对象，它表示基础类的立即封闭构造方法。 ");
if (cst3 != null) System.out.println(cst3.toString());
else System.out.println("-- 没有获取到任何构造方法！ ");
Constructor[] csts = c.getConstructors();
System.out.println("4 、获取指定 Class 对象的所有构造方法： ");
for (int i = 0; i < csts.length; i++) {
System.out.println(csts[i].toString());
}
System.out.println("/n-------------------------------/n");
Type types1[] = c.getGenericInterfaces();
System.out.println("1 、返回直接实现的接口： ");
for (int i = 0; i < types1.length; i++) {
System.out.println(types1[i].toString());
}
Type type1 = c.getGenericSuperclass();
System.out.println("2 、返回直接超类： ");
System.out.println(type1.toString());
Class[] cis = c.getClasses();
System.out.println("3 、返回超类和所有实现的接口： ");
for (int i = 0; i < cis.length; i++) {
System.out.println(cis[i].toString());
}
Class cs1[] = c.getInterfaces();
System.out.println("4 、实现的接口 ");
for (int i = 0; i < cs1.length; i++) {
System.out.println(cs1[i].toString());
}
System.out.println("/n-------------------------------/n");
Field fs1[] = c.getFields();
System.out.println("1 、类或接口的所有可访问公共字段： ");
for (int i = 0; i < fs1.length; i++) {
System.out.println(fs1[i].toString());
}
Field f1 = c.getField("MIN_VALUE");
System.out.println("2 、类或接口的指定已声明指定公共成员字段： ");
System.out.println(f1.toString());
Field fs2[] = c.getDeclaredFields();
System.out.println("3 、类或接口所声明的所有字段： ");
for (int i = 0; i < fs2.length; i++) {
System.out.println(fs2[i].toString());
}
Field f2 = c.getDeclaredField("serialVersionUID");
System.out.println("4 、类或接口的指定已声明指定字段： ");
System.out.println(f2.toString());
System.out.println("/n-------------------------------/n");
Method m1[] = c.getMethods();
System.out.println("1 、返回类所有的公共成员方法： ");
for (int i = 0; i < m1.length; i++) {
System.out.println(m1[i].toString());
}
Method m2 = c.getMethod("longValue", new Class[]{});
System.out.println("2 、返回指定公共成员方法： ");
System.out.println(m2.toString());
}
}
输出结果：输出结果很长，这里不再给出。
二、运行时复制对象
例程 ReflectTester 类进一步演示了 Reflection API 的基本使用方法。 ReflectTester 类有一个 copy(Object object) 方法，这个方法能够创建一个和参数 object 同样类型的对象，然后把 object 对象中的所有属性拷贝到新建的对象中，并将它返回
这个例子只能复制简单的 JavaBean ，假定 JavaBean 的每个属性都有 public 类型的 getXXX() 和 setXXX() 方法。
public class ReflectTester {
public Object copy(Object object) throws Exception {
// 获得对象的类型
Class<?> classType = object.getClass();
System.out.println("Class:" + classType.getName());
// 通过默认构造方法创建一个新的对象
Object objectCopy = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});
// 获得对象的所有属性
Field fields[] = classType.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
String fieldName = field.getName();
String firstLetter = fieldName.substring(0, 1).toUpperCase();
// 获得和属性对应的 getXXX() 方法的名字
String getMethodName = "get" + firstLetter + fieldName.substring(1);
// 获得和属性对应的 setXXX() 方法的名字
String setMethodName = "set" + firstLetter + fieldName.substring(1);
// 获得和属性对应的 getXXX() 方法
Method getMethod = classType.getMethod(getMethodName, new Class[]{});
// 获得和属性对应的 setXXX() 方法
Method setMethod = classType.getMethod(setMethodName, new Class[]{field.getType()});
// 调用原对象的 getXXX() 方法
Object value = getMethod.invoke(object, new Object[]{});
System.out.println(fieldName + ":" + value);
// 调用拷贝对象的 setXXX() 方法
setMethod.invoke(objectCopy, new Object[]{value});
}
return objectCopy;
}
public static void main(String[] args) throws Exception {
Customer customer = new Customer("Tom", 21);
customer.setId(new Long(1));
Customer customerCopy = (Customer) new ReflectTester().copy(customer);
System.out.println("Copy information:" + customerCopy.getId() + " " + customerCopy.getName() + " "
+ customerCopy.getAge());
}
}
class Customer {
private Long id;
private String name;
private int age;
public Customer() {
}
public Customer(String name, int age) {
this.name = name;
this.age = age;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
输出结果：
Class:com.langsin.reflection.Customer
id:1
name:Tom
age:21
Copy information:1 Tom 21
Process finished with exit code 0
解说：
ReflectTester 类的 copy(Object object) 方法依次执行以下步骤
（ 1 ）获得对象的类型：
Class classType=object.getClass();
System.out.println("Class:"+classType.getName());
（ 2 ）通过默认构造方法创建一个新对象：
Object objectCopy=classType.getConstructor(new Class[]{}).newInstance(new Object[]{});
以上代码先调用 Class 类的 getConstructor() 方法获得一个 Constructor 对象，它代表默认的构造方法，然后调用 Constructor 对象的 newInstance() 方法构造一个实例。
3 ）获得对象的所有属性：
Field fields[]=classType.getDeclaredFields();
Class 类的 getDeclaredFields() 方法返回类的所有属性，包括 public 、 protected 、默认和 private 访问级别的属性
（ 4 ）获得每个属性相应的 getXXX() 和 setXXX() 方法，然后执行这些方法，把原来对象的属性拷贝到新的对象中
三、用反射机制调用对象的方法
public class InvokeTester {
public int add(int param1, int param2) {
return param1 + param2;
}
public String echo(String msg) {
return "echo: " + msg;
}
public static void main(String[] args) throws Exception {
Class<?> classType = InvokeTester.class;
Object invokeTester = classType.newInstance();
// Object invokeTester = classType.getConstructor(new
// Class[]{}).newInstance(new Object[]{});
// 获取 InvokeTester 类的 add() 方法
Method addMethod = classType.getMethod("add", new Class[]{int.class, int.class});
// 调用 invokeTester 对象上的 add() 方法
Object result = addMethod.invoke(invokeTester, new Object[]{new Integer(100), new Integer(200)});
System.out.println((Integer) result);
// 获取 InvokeTester 类的 echo() 方法
Method echoMethod = classType.getMethod("echo", new Class[]{String.class});
// 调用 invokeTester 对象的 echo() 方法
result = echoMethod.invoke(invokeTester, new Object[]{"Hello"});
System.out.println((String) result);
}
}
在例程 InvokeTester 类的 main() 方法中，运用反射机制调用一个 InvokeTester 对象的 add() 和 echo() 方法
add() 方法的两个参数为 int 类型，获得表示 add() 方法的 Method 对象的代码如下：
Method addMethod=classType.getMethod("add",new Class[]{int.class,int.class});
Method 类的 invoke(Object obj,Object args[]) 方法接收的参数必须为对象，如果参数为基本类型数据，必须转换为相应的包装类型的对象。 invoke() 方法的返回值总是对象，如果实际被调用的方法的返回类型是基本类型数据，那么 invoke() 方法会把它转换为相应的包装类型的对象，再将其返回。
在本例中，尽管 InvokeTester 类的 add() 方法的两个参数以及返回值都是 int 类型，调用 add Method 对象的 invoke() 方法时，只能传递 Integer 类型的参数，并且 invoke() 方法的返回类型也是 Integer 类型， Integer 类是 int 基本类型的包装类：
Object result=addMethod.invoke(invokeTester,
new Object[]{new Integer(100),new Integer(200)});
System.out.println((Integer)result); //result 为 Integer 类型
四、动态创建和访问数组
java.lang.Array 类提供了动态创建和访问数组元素的各种静态方法。
例程 ArrayTester1 类的 main() 方法创建了一个长度为 10 的字符串数组，接着把索引位置为 5 的元素设为 “hello” ，然后再读取索引位置为 5 的元素的值
public class ArrayTester1 {
public static void main(String args[]) throws Exception {
Class<?> classType = Class.forName("java.lang.String");
// 创建一个长度为 10 的字符串数组
Object array = Array.newInstance(classType, 10);
// 把索引位置为 5 的元素设为 "hello"
Array.set(array, 5, "hello");
// 获得索引位置为 5 的元素的值
String s = (String) Array.get(array, 5);
System.out.println(s);
}
}
例程 ArrayTester2 类的 main() 方法创建了一个 5 x 10 x 15 的整型数组，并把索引位置为 [3][5][10] 的元素的值为设 37 。
public class ArrayTester2 {
public static void main(String args[]) {
int[] dims = new int[]{5, 10, 15};
// 创建一个具有指定的组件类型和维度的新数组。
Object array = Array.newInstance(Integer.TYPE, dims);
Object arrayObj = Array.get(array, 3);
Class<?> cls = arrayObj.getClass().getComponentType();
System.out.println(cls);
arrayObj = Array.get(arrayObj, 5);
Array.setInt(arrayObj, 10, 37);
int arrayCast[][][] = (int[][][]) array;
System.out.println(arrayCast[3][5][10]);
}
}
深入认识 Class 类
众所周知 Java 有个 Object 类，是所有 Java 类的继承根源，其内声明了数个应该在所有 Java 类中被改写的方法： hashCode() 、equals() 、 clone() 、 toString() 、 getClass() 等。其中 getClass() 返回一个 Class 类的对象。
Class 类十分特殊。它和一般 classes 一样继承自 Object ，其实体用以表达 Java 程序运行时的 classes 和 interfaces ，也用来表达 enum 、 array 、 primitive Java types
（ boolean, byte, char, short, int, long, float, double ）以及关键词 void 。当一个 class 被加载，或当加载器（ class loader ）的 defineClass() 被 JVM 调用， JVM 便自动产生一个 Class object 。如果您想借由 “ 修改 Java 标准库源码 ” 来观察Class object 的实际生成时机（例如在 Class 的 constructor 内添加一个 println() ），不能够！因为 Class 并没有 public constructor
Class 是 Reflection 起源。针对任何您想探勘的 class ，唯有先为它产生一个 Class object ，接下来才能经由后者唤起为数十多个的 Reflection APIs
Java 允许我们从多种途径为一个 class 生成对应的 Class 对象。参看本人的《 深入研究 java.long.Class 类 》一文。
欲生成对象实体，在 Reflection 动态机制中有两种作法，一个针对 “ 无自变量 ctor” ，一个针对 “ 带参数 ctor” 。如果欲调用的是 “带参数 ctor“ 就比较麻烦些，不再调用 Class 的 newInstance() ，而是调用 Constructor 的 newInstance() 。首先准备一个Class[] 做为 ctor 的参数类型（本例指定
为一个 double 和一个 int ），然后以此为自变量调用 getConstructor() ，获得一个专属 ctor 。接下来再准备一个 Object[] 做为ctor 实参值（本例指定 3.14159 和 125 ），调用上述专属 ctor 的 newInstance() 。
动态生成 “Class object 所对应之 class” 的对象实体；无自变量。
这个动作和上述调用 “ 带参数之 ctor” 相当类似。首先准备一个 Class[] 做为参数类型（本例指定其中一个是 String ，另一个是Hashtable ），然后以此为自变量调用 getMethod() ，获得特定的 Method object 。接下来准备一个 Object[] 放置自变量，然后调用上述所得之特定 Method object 的 invoke() 。
为什么获得 Method object 时不需指定回返类型？
因为 method overloading 机制要求 signature 必须唯一，而回返类型并非 signature 的一个成份。换句话说，只要指定了method 名称和参数列，就一定指出了一个独一无二的 method 。
四、运行时变更 field 内容
与先前两个动作相比， “ 变更 field 内容 ” 轻松多了，因为它不需要参数和自变量。首先调用 Class 的 getField() 并指定 field 名称。获得特定的 Field object 之后便可直接调用 Field 的 get() 和 set() 。
public class RefFiled {
public double x;
public Double y;
public static void main(String args[]) throws NoSuchFieldException, IllegalAccessException {
Class c = RefFiled.class;
Field xf = c.getField("x");
Field yf = c.getField("y");
RefFiled obj = new RefFiled();
System.out.println(" 变更前 x=" + xf.get(obj));
// 变更成员 x 值
xf.set(obj, 1.1);
System.out.println(" 变更后 x=" + xf.get(obj));
System.out.println(" 变更前 y=" + yf.get(obj));
// 变更成员 y 值
yf.set(obj, 2.1);
System.out.println(" 变更后 y=" + yf.get(obj));
}
}
运行结果：
变更前 x=0.0
变更后 x=1.1
变更前 y=null
变更后 y=2.1
Process finished with exit code 0
private static Object check(Object obj,String flag) throws Exception
{
Class ts=obj.getClass();
Field[] fs=ts.getDeclaredFields();
Method[] ms=ts.getDeclaredMethods();
StringBuffer fd=new StringBuffer();
Map<String,Object> getMethodMap=new HashMap<String,Object>();
Map<String,Method> setMethodMap=new HashMap<String,Method>();
String methodName="";
String value="";
for(int i=0;i<fs.length;i++)
{
if(java.lang.String.class!=fs[i].getType())
{
fd.append(fs[i].getName());
}
}
for(int i=0;i<ms.length;i++)
{
methodName=ms[i].getName().toLowerCase();
if(methodName.indexOf("get")!=-1)
{
getMethodMap.put(methodName.substring(3), ms[i].invoke(obj, null));
}
else
{
setMethodMap.put(methodName.substring(3), ms[i]);
}
}
Set keySet=getMethodMap.keySet();
Iterator it=keySet.iterator();
String key="";
while(it.hasNext())
{
key=it.next().toString();
if(fd.indexOf(key)==-1&&getMethodMap.get(key)!=null)
{
value=getMethodMap.get(key).toString().replaceAll(",", "").replaceAll(" ", "");
if("".equals(value)||flag.equals(value))
{
((Method) setMethodMap.get(key)).invoke(obj, new Object[]{null});
}
else
{
((Method) setMethodMap.get(key)).invoke(obj, new Object[]{value});
}
}
}
return obj;
}