Java 反射机制初探（一）--仿hibernate持久化实现

Java 反射机制使用

反射机制 基础：
用例子作为说明，相信很好理解。

package com.ghrt.programmer;

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

/**
* author : zhangyinlong

* date :2009/06/25
* content:反射机制:所谓的反射机制就是java语言在运行时拥有一项自观的能力。
* 通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。

* 该类通过代码说明 java 反射的用法
*/
public class ReflectionTest {

/*
*根据类名的字符串打印该类的所有方法
* @parameter className : 类的全名，例如 "java.utill.List"
*/
public void printMethodByClassname(String className)
{
try {

Class c = Class.forName(className);

//打印出所有方法
System.out.println("打印出所有方法");
Method m[] = c.getDeclaredMethods();
for(int i=0;i<m.length;i++)
{
System.out.println(m[i].toString());
}

//打印出类声明的所有字段
System.out.println("打印出类声明的所有字段");
Field f[] = c.getDeclaredFields();
for(int i=0;i<f.length;i++)
{
System.out.println(f[i]);
}

//打印出该类声明的所有构造函数
System.out.println("打印出该类声明的所有构造函数");
Constructor ct[] = c.getDeclaredConstructors();
for(int i=0;i<ct.length;i++)
{
System.out.println(ct[i]);
}

} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
//测试方法
public void test(String str)
{
System.out.println(str);
}
//既然可以通过反射获得类的所有属性和方法，那 通过反射调用测试类的方法 也是很容易的
public void useMethodByReflection()
{
try {
//通过反射获得 “com.ghrt.programmer.RelectionTest” 这个类
Class c = Class.forName("com.ghrt.programmer.ReflectionTest");
//实例化该类的对象
Object obj = c.newInstance();

//根据方法名和参数类型获得该对象的方法
Class[] types = new Class[1];
types[0] = Class.forName("java.lang.String");
Method m = c.getDeclaredMethod("test",types);

//执行方法
m.invoke(obj, new Object[]{"aaa"});

} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

ReflectionTest rt = new ReflectionTest();
rt.useMethodByReflection();
//rt.printMethodByClassname("java.util.ArrayList");

}

}

java 反射的应用
反射的应用不能不提到 hibernate 的框架，hibernate 可以使我们轻松的进行数据库的操作，
传递一个查询语句(类似 "select id,name from userInfo"),hibernate 会自动的将符合条件的
对象封装的list里面，供我们调用，大大简化了我们的代码量。下面就以一段代码模仿hibernate
的实现。

代码片段一(一般的查询方法)：
/**
* 通用的查询方法
* 通过SQL语句,与传递进来的object
* 将查询出来的sql结果,通过反射机制封装至object
* 注: ojbect必须为POJO,或BEAN的类
* @param sql 查询SQL
* @param objName 需要返回的列表内包含对象的类型
* @return 封装好的对象
*/
public List getResult(String sql,String objName,int db_flag) throws Exception
{

PreparedStatement stmt = null;
ResultSet rs = null;
RecordReflection rr = null;

//获得数据库的连接
dbConnection = new DbConn1().getDBConnection();
if(dbConnection != null) System.out.println("GetConn successful");

List result = null;
try {

stmt = dbConnection.prepareStatement(sql);
rs = stmt.executeQuery();
if(rs != null){
System.out.println("GetRS successful");
}

//具体内容见代码片段2
rr = new RecordReflection();
//通过传递 结果集 和 “对象的全名” 返回 对象列表,和 普通查询 这一步不同
result = rr.Relection(rs, objName);

} catch (SQLException ex) {
log.error("getResult is error:" + ex.getMessage());
ex.printStackTrace();
} finally {
this.closeResultSet(rs);
this.closeStatement(stmt);
this.closeConnection();
}

return result; //返回范类型集合,该集合中存储着符合条件的行与列
}

代码片段二(RecordReflection 类)：
package com.ghrt.frame;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import org.apache.log4j.Logger;

public class RecordReflection {

private Logger log = Logger.getLogger(RecordReflection.class);

/**
* 通过传递进来的ResultSet与对象名称,序列化为对象,塞入list
* @param rs 结果集
* @param objName 对象
* @return list list里存储传递的objName的对象
*/
public List Relection(ResultSet rs,String objName){
List list = null;
try{
List resultList = this.ProcessResultSet(rs);
list = this.ProcessObject(resultList, objName);

}catch(Exception e){
log.error("Relection is error:" + e.getMessage());
}
return list;
}

public List ProcessResultSet(ResultSet rs) throws PlatformException{

List listResult =new ArrayList();
int cols = 0;
String colName="";
String colType="";
String colValue="";
try{
if(rs == null) //判断是否结果集为空,如果为空,直接返回
return null;

LabelValue lv = null; //见代码片段3

List list = new ArrayList<LabelValue>();
ResultSetMetaData rsetMd = null;
rsetMd = rs.getMetaData();
cols = rsetMd.getColumnCount();
while(rs.next()){

list = new ArrayList<LabelValue>();
for (int i=0;i<cols;i++){
colName = rsetMd.getColumnName(i+1);
colType = rsetMd.getColumnTypeName(i+1);
colValue = rs.getString(i+1);
lv = new LabelValue();
lv.setName(colName);
lv.setType(colType);
lv.setValue(colValue);

list.add(lv);
}

listResult.add(list);
}

}catch(Exception e){
log.error(" // Relection process ResultSet is error // " + e.getMessage());
throw new PlatformException("class RecordReflection ProcessResultSet is error: " + e.getMessage());
}
return listResult;
}

public List ProcessObject(List list,String objName) throws PlatformException{

List resultList = null;
try{
resultList = new ArrayList();
log.debug(" // list.size:" + list.size());
Iterator it = list.iterator();

while(it.hasNext()){//获取每条记录
List lvList = (List)it.next();
log.debug(" // lvList.size:" + lvList.size());

System.out.println("lvList:"+lvList.size());
Iterator lvIt = lvList.iterator();

Class clazz = Class.forName(objName);
Object obj = clazz.newInstance();

while(lvIt.hasNext()){//获取记录里的每个字段
LabelValue lv = (LabelValue)lvIt.next();
//获取生成的object对象

Field[] fields = clazz.getDeclaredFields();
log.debug("// fileds.length // "+fields.length);
// for(Field field:fields){
for(int i = 0;i<fields.length;i++){
Field field = fields[i];
System.out.println(fields[i]);
log.debug("getname:"+field.getName()+" // lv.getName // "+lv.getName());
String fieldName = field.getName();

if(fieldName.equalsIgnoreCase(lv.getName())){
log.debug(" // fieldName//" + fieldName +" // fieldType //" + field.getType().getName());
log.debug(" // lv.getName // " + lv.getName() + " // lv.value // " + lv.getValue());
Method method = clazz.getDeclaredMethod("set"+
fieldName.substring(0,1).toUpperCase()+fieldName.substring(1)
,new Class[]{field.getType()});
if(field.getType().equals(String.class)){ //处理当为String类型情况
method.invoke(obj, new Object[]{this.toString(lv.getValue())});
}else if(field.getType().equals(Integer.class)){//处理当为Integer类型情况
method.invoke(obj, new Object[]{this.toInteger(lv.getValue())});
}else if(field.getType().equals(Float.class)){//处理当为Float类型情况
method.invoke(obj, new Object[]{this.toFloat(lv.getValue())});
}else if(field.getType().equals(Double.class)){//处理当为Double类型情况
method.invoke(obj, new Object[]{this.toDouble(lv.getValue())});
}else if(field.getType().equals(BigDecimal.class)){//处理当为BigDecimal类型情况
method.invoke(obj, new Object[]{this.toBigDecimal(lv.getValue())});
}else if(field.getType().equals(Long.class)){//处理当为Long类型情况
method.invoke(obj, new Object[]{this.toLong(lv.getValue())});
}else if(field.getType().equals(Timestamp.class)){//处理当为Timestamp类型情况
method.invoke(obj, new Object[]{this.toTimestamp(lv.getValue())});
}else if(field.getType().equals(int.class)){//处理当为int类型情况
method.invoke(obj, new Object[]{this.toInteger(lv.getValue())});
}else if(field.getType().equals(float.class)){//处理当为float类型情况
method.invoke(obj, new Object[]{this.toFloat(lv.getValue())});
}else if(field.getType().equals(double.class)){//处理当为double类型情况
method.invoke(obj, new Object[]{this.toDouble(lv.getValue())});
}else if(field.getType().equals(Date.class)){//处理当为Date类型情况
method.invoke(obj, new Object[]{this.toTimestamp(lv.getValue())});
}else if(field.getType().equals(short.class)){//处理当为Short类型情况
log.debug(" // parse short // ");
method.invoke(obj, new Object[]{this.toShort(lv.getValue())});
}

}

}
}

resultList.add(obj);
}
}catch(Exception ex){
log.error(" // process object is error // " + ex.getMessage());
throw new PlatformException("class RecordReflection ProcessObject is error: " + ex.getMessage());
}
return resultList;
}

/**
* 对Date类型转换
* @param args
* @return
*/
public Date toDate(String args){
Date result = null;
if(null == args || "".equals(args))
result = null;
else
try{
// result = BigDecimal.parseBigDecimal(args);
result = new Date(args);
}catch(Exception e){
result = null;
log.error(" // RecordReflection parse Date is error // " + e.getMessage());
}

return result;
}
/**
* 对Timestamp类型转换
* @param args
* @return
*/
public Timestamp toTimestamp(String args){
Timestamp result = null;
if(null == args || "".equals(args))
result = null;
else
try{
// result = BigDecimal.parseBigDecimal(args);
result = Timestamp.valueOf(args);
}catch(Exception e){
result = null;
log.error(" // RecordReflection parse Timestamp is error // " + e.getMessage());
}

return result;
}
/**
* 对BigDecimal类型转换
* @param args
* @return
*/
public BigDecimal toBigDecimal(String args){
BigDecimal result = null;
if(null == args || "".equals(args))
result = new BigDecimal(0);
else
try{
// result = BigDecimal.parseBigDecimal(args);
result = new BigDecimal(args);
}catch(Exception e){
result = new BigDecimal(0);
log.error(" // RecordReflection parse BigDecimal is error // " + e.getMessage());
}

return result;
}
/**
* 对Long类型转换
* @param args
* @return
*/
public Long toLong(String args){
Long result = null;
if(null == args || "".equals(args))
result = new Long(0);
else
try{
result = Long.parseLong(args);
}catch(Exception e){
result = new Long(0);
log.error(" // RecordReflection parse Long is error // " + e.getMessage());
}

return result;
}
/**
* 对Double类型转换
* @param args
* @return
*/
public Double toDouble(String args){
Double result = null;
if(null == args || "".equals(args))
result = new Double(0);
else
try{
result = Double.parseDouble(args);
}catch(Exception e){
result = new Double(0);
log.error(" // RecordReflection parse Double is error // " + e.getMessage());
}

return result;
}
/**
* 对Float类型转换
* @param args
* @return
*/
public Float toFloat(String args){
Float result = null;
if(null == args || "".equals(args))
result = new Float(0);
else
try{
result = Float.parseFloat(args);
}catch(Exception e){
result = new Float(0);
log.error(" // RecordReflection parse Float is error // " + e.getMessage());
}

return result;
}
/**
* 对Integer类型转换
* @param args
* @return
*/
public Integer toInteger(String args){
Integer result = null;
if(null == args || "".equals(args))
result = 0;
else{
try{
result = Integer.parseInt(args);
}catch(Exception e){
result = 0;
log.error(" // RecordReflection parse Integer is error // " + e.getMessage());
}
}
return result;
}

/**
* 对Short类型转换
* @param args
* @return
*/
public Short toShort(String args){
Short result = null;
if(null == args || "".equals(args))
result = 0;
else{
try{
result = Short.parseShort(args);
}catch(Exception e){
result = 0;
log.error(" // RecordReflection parse Short is error // " + e.getMessage());
}
}
return result;
}

/**
* 重写了对String类型的转换
* @param args
* @return
*/
public String toString(String args){
String result = null;
if (null == args || "".equals(args))
result = "";
else
result = args.toString();
return result;
}

}

代码片段3(LabelValue 类):
package com.ghrt.frame;

import java.io.Serializable;

public class LabelValue implements Serializable{

private String name;
private String value;
private String type;
private int id;

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}