Java Reflection API 简介

在JDK中，主要由以下类来实现Java反射机制，这些类都位于java.lang.reflect包中
Class类：代表一个类。java.lang.Class
Field 类：代表类的成员变量（成员变量也称为类的属性）。java.lang.reflect.Field
Method类：代表类的方法。java.lang.reflect.Method
Constructor 类：代表类的构造方法。java.lang.reflect.Constructor
Array类：提供了动态创建数组，以及访问数组的元素的静态方法.java.lang.reflect.Array

 

Class对象的获得途径

 

1、众所周知Java有个Object class，是所有Java classes的继承根源，其内声明了数个应该在所有Java class中被改写的methods：hashCode()、equals()、clone()、toString()、getClass()等。其中getClass()返回一个Class object。

eg：String str = "abc"; Class class = str.getClass(); Class class = str.getSuperClass();

 

2、运用Class.forName("对象名");

eg: Class c = Class.forName("java.lang.String");

 

3、.class 用法

eg: Class c = java.lang.String.class; Class c2 = int.class;  Class c3 = int[].class

 

4、运用primitive wrapper classes的TYPE语法

eg:  Class c1 = Boolean.TYPE;

       Class c2 = String.TYPE;

       Class c3 = Integer.TYPE;

       Class c4 = Float.TYPE;

       Class c5 = Double.TYPE;

       Class c6 = Long.TYPE;

       Class c7 = Byte.TYPE;

       Class c8 = Short.TYPE;

       Class c9 = Void.TYPE;

 

运行时生成instances

欲生成对象实体，在Reflection 动态机制中有两种作法，一个针对“无自变量ctor”，一个针对“带参数ctor”。如果欲调用的是“带参数ctor“就比较麻烦些，不再调用Class的newInstance()，而是调用Constructor 的newInstance()。首先准备一个Class[]做为ctor的参数类型,然后以此为自变量调用getConstructor()，获得一个专属ctor。接下来再准备一个Object[] 做为ctor实参值,调用上述专属ctor的newInstance()。

 

运行时调用methods

这个动作和上述调用“带参数之ctor”相当类似。首先准备一个Class[]做为参数类型,然后以此为自变量调用getMethod()，获得特定的Method object。接下来准备一个Object[]放置变量，然后调用上述所得之特定Method object的invoke()。为什么获得Method object时不需指定回返类型？因为method overloading机制要求signature必须唯一，而回返类型并非signature的一个成份。换句话说，只要指定了method名称和参数列，就一定指出了一个独一无二的method。

 

运行时变更fields内容

与先前两个动作相比，“变更field内容”轻松多了，因为它不需要参数和自变量。首先调用Class的getField()并指定field名称。获得特定的Field object之后便可直接调用Field的get()和set() 

 

例子代码：

/*通过一个参数导出参数所指定的对象的所有方法*/
public class DumpMethod {
	
	public static void main(String [] args)throws Exception{
		Class<?> classType = Class.forName(args[0]);
		Method[] methods = classType.getDeclaredMethods();
		for(int i = 0;i<methods.length;i++){
			System.out.println(methods[i].toString());
		}
	}
	
}

 

import java.lang.reflect.Method;
/*测试方法调用*/
public class InvokerTest {	
	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 = InvokerTest.class;
		//创建一个新对象
		Object createObj = classType.newInstance();
		
		//由Class生成指定名字和参数的方法
		Method addMethod  = classType.getMethod("add", new Class[]{int.class,int.class});
		Object result = addMethod.invoke(createObj, new Object[]{new Integer(100),new Integer(200)});//装箱和拆箱
		//Object result = addMethod.invoke(createObj, new Object[]{100,200});//装箱和拆箱
		System.out.println("result：" + result);
		
		Method echoMethod  = classType.getMethod("echo", new Class[]{String.class});
		result = echoMethod.invoke(createObj,new Object[]{"Hello Boy!"});
		System.out.println(result);
		
		
	}	
}

  

 

import java.lang.reflect.Field;
import java.lang.reflect.Method;
/*反射测试*/
public class TestReflect {
	public static Object copy(Object obj) throws Exception{
		Class<?> classType = obj.getClass();
		System.out.println("classType = " + classType.getName());
		//运用默认的构造方法生成一个对象
		//Object copyObj = classType.getConstructor(new Class[]{}).newInstance(new Object [] {});
        //运用含参数的构造方法生成一个对象
		Object copyObj = classType.getConstructor(new Class[]{String.class,long.class}).newInstance(new Object[]{"BOB",2l});
		
		Field[] fields = classType.getDeclaredFields();
		for(int i=0; i<fields.length;i++){
			Field field = fields[i];
			String fieldname = field.getName();//得到方法名
			if("age".equalsIgnoreCase(fieldname)){
				
				String getMethodName = "get" + fieldname.substring(0,1).toUpperCase() + fieldname.substring(1);
				String setMethodName = "set" + fieldname.substring(0,1).toUpperCase() + fieldname.substring(1);
				
				Method getMethod = classType.getMethod(getMethodName, new Class[]{});
				Method setMethod = classType.getMethod(setMethodName, new Class[]{field.getType()});
				
				Object value = getMethod.invoke(obj, new Object[]{});
				setMethod.invoke(copyObj, new Object[]{value});
			}	
		}
		return copyObj;
	}
	public static void main(String[] args) throws Exception{
		User user = new User("Tom", 1l);
		user.setAge(20);
		User u = (User)TestReflect.copy(user);
		System.out.println("copyUser.username:" +  u.getUsername() + " id:" + u.getId() + " age: " + u.getAge());
	}	
}
	class User{
		private String username;
		private long id;
		private int age;
		
		public User(){
		}
		public User(String username, long id){
			this.username = username;
			this.id = id;
		}
		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}
		public long getId() {
			return id;
		}
		public void setId(long id) {
			this.id = id;
		}
		public String getUsername() {
			return username;
		}
		public void setUsername(String username) {
			this.username = username;
		}
	}