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);
}
}