Java的反射机制

      Java的反射机制可以理解成，Java类Class信息的各个成分都是用类来表示，Java里面有个很特殊的类就是Class，其包含了Method、Field、Constructor等信息，都是用类来表示。获取Java的Class信息，有几种办法（ReflectVo）

1、Class clazz = ReflectVo.Class;获取字节码

2、Class clazz = Class.forName("类所在的包的信息");

3、通过对象获取：ReflectVo vo = new ReflectVo(); Class clazz = vo.getClass();

 

      获取了类的字节码信息后，我们就可以通过反射机制获取类的信息，而不需要去new这个类，返回的就是Object类，当我们不明白类的信息的时候，我们就可以这样的去实现。返回的结果包含的类的信息，也可以调用其方法(invoke())等。

当程序运行加载的时候，JVM运行时候，可以动态的去修改类的信息，从而实现类的动态化和强大的功能。

 

      下面就是我自己写了一个例子：

 

/**
 * ReflectVo.java	  V1.0   May 5, 2012 1:24:16 PM
 *
 * Copyright Lizhenbin Co. ,Ltd. All rights reserved.
 *
 * Modification history(By    Time    Reason):
 * 
 * Description:
 */

package com.lzb.reflect;

import java.util.Date;

/**
 * 
 * 功能描述： 测试Java的反射机制
 *
 * @author  lizhenbin
 *
 * <p>修改历史：(修改人，修改时间，修改原因/内容)</p>
 */
public class ReflectVo {
	
	public static String text_001 = "123456789_lzb_number";
	public static String text_002 = "abcdefg_lzb_letter";
	public static String text_003 = "abcd12345_lzb_all";
	public static String text_name = "lzb";
	
	private String id;
	private String context;
	public Date createDate;
	protected int limitNum;
	
	/**
	 * 方便使用newInstance()
	 * 构造函数：
	 *
	 */
	public ReflectVo() {
		super();
	}
	
	/**]
	 * 
	 * 构造函数：传入public, private, protected作用域的值
	 *
	 * @param id
	 * @param createDate
	 * @param limitNum
	 */
	public ReflectVo(String id, Date createDate, int limitNum) {
		super();
		this.id = id;
		this.createDate = createDate;
		this.limitNum = limitNum;
	}



	/**
	 * 
	 * 构造函数：全部属性
	 *
	 * @param id
	 * @param context
	 * @param createDate
	 * @param limitNum
	 */
	public ReflectVo(String id, String context, Date createDate, int limitNum) {
		super();
		this.id = id;
		this.context = context;
		this.createDate = createDate;
		this.limitNum = limitNum;
	}
	
	@Override
	public String toString() {
		
		return "Modefy Str Result: " + "\n\n " +
			   "TXT001: " + this.text_001 + "\n" +
		       " TXT002: " + this.text_002 + "\n" +
		       " TXT003: " + this.text_003 + "\n" +
		       " TXT_EDITOR: " + this.text_name;
	}

	// 设置一个公有的方法
	public void msgReflectVo(String msg) {
		
		System.out.println("\nCall Private Method.    " + msg);
	}

	//设置一个私有的方法
	private void queryReflectVo(String msg) {
		
		System.out.println("Call Private Method. " + msg);
	}
	
	// protected方法
	protected void proReflectVo(String msg) {
		
		System.out.println("Call protected Method<-----");
	}
	
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getContext() {
		return context;
	}
	public void setContext(String context) {
		this.context = context;
	}
	public Date getCreateDate() {
		return createDate;
	}
	public void setCreateDate(Date createDate) {
		this.createDate = createDate;
	}
	public int getLimitNum() {
		return limitNum;
	}
	public void setLimitNum(int limitNum) {
		this.limitNum = limitNum;
	}
}

 

package com.lzb.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Date;
/**
 * 
 * 功能描述：利用反射机制构造类，并调用其方法，动态的修改类的信息
 *
 * @author  lizhenbin
 *
 * <p>修改历史：(修改人，修改时间，修改原因/内容)</p>
 */
public class ReflectManager {
	
	private static String REFLECT_STR = "com.lzb.reflect.ReflectVo";
	private Class clazz = null;
	
	/**
	 * 
	 * 构造函数：初始化
	 *
	 */
	public ReflectManager() {
		
		try {
			this.clazz = Class.forName(REFLECT_STR);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 
	 * 功能描述：
	 * 		  利用Java的反射机制，在不new对象， 动态的构造信息， 
	 *        然后在运行的时候动态的修改类的信息，调用类的参数等。
	 *
	 * @author  lizhenbin
	 * <p>创建日期 ：May 5, 2012 3:48:14 PM</p>
	 *
	 * @throws Exception
	 *
	 * <p>修改历史 ：(修改人，修改时间，修改原因/内容)</p>
	 */
	public void reflectMsg() throws Exception {
		
		/**
		 * 利用反射机制构造对象
		 * 1、 获取构造方法
		 * 2、 通过newInstance()传入参数初始化实例对象，并转换成相应的vo信息
		 */
		Constructor cons = clazz.getConstructor(String.class, String.class, Date.class, int.class);
		Object obj = cons.newInstance("SN000001", 
									  "Copyright lizhenbin. All rights reserved.", 
									  new Date(), 
									  100);
//		/**
//		 * 注：当类有无参数的构造方法时，可以使用如下方式
//		 */
//		Object deflateVo = clazz.newInstance();
		
		/**
		 * 把Vo属性里面的常量值，都动态的修改
		 * 字符串中的"lzb",动态的修改为"lizhenbin"
		 * 这里只演示修改属性的值
		 */
		Field[] fields = clazz.getFields();
		for(Field f : fields) {
			/**
			 * 对所有的值是String类型的修改，则取出所有的String类型的值信息即可
			 */
			if(f.getType()==String.class) {
				/**
				 * 通过类型获取相应的信息
				 */
				String voStr = (String) f.get(obj);
				if(voStr!=null && !voStr.equals("")) {
					String modifyStr = voStr.replace("lzb", "lizhenbin");
					/**
					 * 把修改后的值返回
					 */
					f.set(obj, modifyStr);
				}else{
					System.out.println("Usage: Error!");
				}
			}
		}
		// 打印
		System.out.println(obj);
		
		// 调用类的方法
		Method method = clazz.getMethod("msgReflectVo", String.class);
		/**
		 * 调用类的方法用invoke,参数1是反射获得的方法，参数二是传入的参数
		 */
		/**
		 * 参数1： 对象， 参数2： 传入到方法的参数
		 */
		method.invoke(obj, "------>Input datas<-------");
		
	}
	
	/**
	 * 
	 * 功能描述：执行
	 *
	 * @author  lizhenbin
	 * <p>创建日期 ：May 5, 2012 3:40:01 PM</p>
	 *
	 * @param args
	 *
	 * <p>修改历史 ：(修改人，修改时间，修改原因/内容)</p>
	 */
	public static void main(String[] args) {
		
		ReflectManager rm = new ReflectManager();
		try {
			rm.reflectMsg();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}

}

 

/**
 * Reflect.java	  V1.0   May 5, 2012 1:35:01 PM
 *
 * Copyright Lizhenbin Co. ,Ltd. All rights reserved.
 *
 * Modification history(By    Time    Reason):
 * 
 * Description:
 */

package com.lzb.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Date;

/**
 * 
 * 功能描述：利用Java的反射机制获取数据
 *
 * @author  lizhenbin
 *
 * <p>修改历史：(修改人，修改时间，修改原因/内容)</p>
 */
public class ReflectClassMessage {
	
	private Class clazz = null;
	
	/**
	 * 
	 * 构造函数：初始化
	 *
	 */
	public ReflectClassMessage() {
		
		try {
			init();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 
	 * 功能描述：初始化，利用反射机制获取类信息
	 *
	 * @author  lizhenbin
	 * <p>创建日期 ：May 5, 2012 2:10:15 PM</p>
	 *
	 * @throws Exception
	 *
	 * <p>修改历史 ：(修改人，修改时间，修改原因/内容)</p>
	 */
	public void init() throws Exception{
		/**
		 * 方式一获取类的字节码
		 */
//		clazz = ReflectVo.class;
		/**
		 * 方式二，通过对象获取类的字节码
		 */
//		ReflectVo rvo = new ReflectVo();
//		clazz = rvo.getClass();	
		/**
		 * 方式s三获取类的字节码
		 */
		clazz = Class.forName("com.lzb.reflect.vo.ReflectVo");
	}
	
	/**
	 * 
	 * 功能描述：利用反射机制获取类的构造器信息
	 *
	 * @author  lizhenbin
	 * <p>创建日期 ：May 5, 2012 2:09:57 PM</p>
	 *
	 * @throws Exception
	 *
	 * <p>修改历史 ：(修改人，修改时间，修改原因/内容)</p>
	 */
	public void reflectConstructor() throws Exception{
		
		// 获取所有的构造方法
		Constructor[] cons = clazz.getConstructors();
		for(Constructor c : cons) {
			System.out.println(c);
		}
		// 获取指定的构造方法，需要传入去参数类型
		Constructor consType = null;
		consType = clazz.getConstructor(String.class, Date.class, int.class);
		System.out.println("-------->" + consType);
		consType = clazz.getConstructor();
		System.out.println(consType + "<---------");
	}
	
	/**
	 * 
	 * 功能描述：反射的方式获取类的方法信息
	 *
	 * @author  lizhenbin
	 * <p>创建日期 ：May 5, 2012 2:09:09 PM</p>
	 *
	 * @throws Exception
	 *
	 * <p>修改历史 ：(修改人，修改时间，修改原因/内容)</p>
	 */
	public void reflectMethods() throws Exception {
		
		// 获取类所有的公有（public）方法信息，包括父类
		Method[] ms = clazz.getMethods();
		for(Method m : ms) {
			System.out.println(m);
		}
		// 获取类的所有方法信息，不包括父类的
		ms = clazz.getDeclaredMethods();
		for(Method m : ms) {
			System.out.println("----->" + m);
		}
		// 获取公有方法
		Method m = clazz.getMethod("msgReflectVo", String.class);
		// 获取私有的方法
		m = clazz.getDeclaredMethod("queryReflectVo", String.class);
	}
	
	/**
	 * 
	 * 功能描述：获取属性
	 *
	 * @author  lizhenbin
	 * <p>创建日期 ：May 5, 2012 2:24:17 PM</p>
	 *
	 * @throws Exception
	 *
	 * <p>修改历史 ：(修改人，修改时间，修改原因/内容)</p>
	 */
	public void reflectField() throws Exception {
		
		Field[] fs = clazz.getFields();
		// 获取公有的属性
		Field f = clazz.getField("createDate");
		System.out.println(f);
		// 获取私有属性
		f = clazz.getDeclaredField("context");
		System.out.println(f);
	}
	
}