ResultSet结果集转换为实体对象实现方案在应用开发中，我们从数据库查询出的结果集（ResultSet）一般都需要取得（get）其中的数据然后存放到（set）实体对象（Entity，有的称为VO值对象或称为PO持久化对象）中，以便进一步的处理需要。常用也最容易理解的方式就是从ResultSet中get相应的字段值后调用实体对象的set方法，把值保存在实体对象中。这种方式编码量很大，特别是很多字段的查询，编码就会觉得很烦琐。这里我们提供了一种方法，封装实现了ResultSet结果集转换为实体对象（Entity，或叫VO值对象，或PO持久化对象）的方法。 注：三流合一项目有种实现方式，不过我觉得有点烦琐，这里做了重新设计定义，欢迎各位大家多多指教交流。
一、定义结果集返回表结构对象首先我们需要对返回的结果集进行分析，需要知道它返回了那些字段，字段名、字段类型是什么等，结果集表结构对象定义如下： public class DataTableEntity
{
//查询出的ReslutSet中的字段数量
private int columnCount = 0;
//字段名称数组
private String[] columnNames;
//字段类型数组
private int[] columnTypes;
//默认构造器
public DataTableEntity()
{
this(0);
}
//初始化构造器
public DataTableEntity(int columnCount)
{
this.columnCount = columnCount;
this.columnNames = new String[columnCount];
this.columnTypes = new int[columnCount];
}
//获取字段数量
public int getColumnCount()
{
return this.columnCount;
}
//获取字段名称数组
public String[] getColumnNames()
{
return this.columnNames;
}
//获取第index个字段名称，如果index字段不存在，则抛出ArrayIndexOutOfBoundsException异常
public String getColumnName(int index)
{
if (index <= this.columnCount)
{
return this.columnNames[index];
}
else
{
throw new ArrayIndexOutOfBoundsException();
}
}
//设置字段名称数组
public void setColumnNames(String[] columnNames)
{
this.columnNames = columnNames;
}
//设置第index个字段名称，如果index字段不存在，则抛出ArrayIndexOutOfBoundsException异常
public void setColumnName(String columnName, int index)
{
if(index <= this.columnCount)
{
this.columnNames[index] = columnName;
}
else
{
throw new ArrayIndexOutOfBoundsException();
}
}
//获取字段类型数组
public int[] getColumnTypes()
{
return this.columnTypes;
}
//获取字段类型
public int getColumnType(int index)
{
if(index <= this.columnCount)
{
return this.columnTypes[index];
}
else
{
throw new ArrayIndexOutOfBoundsException();
}
}
//设置字段类型数组
public void setColumnTypes(int[] columnTypes)
{
this.columnTypes = columnTypes;
}
//获取字段类型
public void setColumnType(int columnType, int index)
{
if(index <= this.columnCount)
{
this.columnTypes[index] = columnType;
}
else
{
throw new ArrayIndexOutOfBoundsException();
}
}
}
二、定义实体对象（或值对象）的方法实体对象我们在实体对象中定义set和get等方法，当ResultSet转换为Entity时，我们需要调用Entity的一系列set方法，那么我们就需要知道在entity中都定义了哪些方法，这些方法的参数是什么？返回值是什么？以及抛出的异常等信息。
因此，我们需要对实体对象进行分析，定义一个对象来存储分析后的实体对象中定义的方法（Methods）信息。
基于以上需要，我们定义了一个方法实体对象：
import java.util.ArrayList;
public class MethodEntity
{
//方法名称
private String methodName;
//重载方法个数
private int repeatMethodNum = 1;
//方法参数类型列表
private Class[] methodParamTypes;
//存放重载方法参数
private ArrayList repeatMethodsParamTypes;
/**获取参数名称
* @return
*/
public String getMethodName()
{
return methodName;
}
/**获取方法参数类型列表
* @return
*/
public Class[] getMethodParamTypes()
{
return methodParamTypes;
}
/**设置参数名称
* @param string
*/
public void setMethodName(String string)
{
methodName = string;
}
/**设置参数类型列表
* @param classes
*/
public void setMethodParamTypes(Class[] classes)
{
methodParamTypes = classes;
}
/**获取重载方法个数
* @return
*/
public int getRepeatMethodNum()
{
return repeatMethodNum;
}
/**获取第i个重载方法参数列表
* @return
*/
public Class[] getRepeatMethodsParamTypes(int i)
{
int count = this.repeatMethodsParamTypes.size();
if(i <= count)
{
return (Class[])this.repeatMethodsParamTypes.get(i);
}
else
{
throw new ArrayIndexOutOfBoundsException();
}
}
/**设置重载方法个数
* @param i
*/
public void setRepeatMethodNum(int i)
{
repeatMethodNum = i;
}
/**设置重载方法参数类型
* @param list
*/
public void setRepeatMethodsParamTypes(ArrayList list)
{
repeatMethodsParamTypes = list;
}
/**获取重载方法类型
* @return
*/
public ArrayList getRepeatMethodsParamTypes()
{
return repeatMethodsParamTypes;
}
/**
* 设置重载方法参数类型列表
* @param paramTypes
*/
public void setRepeatMethodsParamTypes(Class[] paramTypes)
{
if(this.repeatMethodsParamTypes == null)
this.repeatMethodsParamTypes = new ArrayList();
repeatMethodsParamTypes.add(paramTypes);
}
}
三、实现ResultSet到Entity对象转换方法定义
定义完毕方法实体对象和结果集表结构实体对象后，我们就可以对返回的结果集进行分析，把分析结构分别存储在方法实体对象和结果集表结构实体对象中。
首先我们需要知道返回的结果集和哪个实体对象相对应，需要指定ResultSet转化为的Entity对象类名称。
然后我们对这个实体对象类中定义的方法进行分析，获取实体中定义的方法名称，方法参数类型等信息，如下：
//注册实体, strEntity指定的实体类名称字符串
Class classEntity = Class.forName(strEntity);
//获取实体中定义的方法
HashMap hmMethods = new HashMap();
for (int i = 0; i < classEntity.getDeclaredMethods().length; i++)
{
MethodEntity methodEntity = new MethodEntity();
//方法的名称
String methodName = classEntity.getDeclaredMethods()[i].getName();
String methodKey = methodName.toUpperCase();
//方法的参数
Class[] paramTypes = classEntity.getDeclaredMethods()[i].getParameterTypes();
methodEntity.setMethodName(methodName);
methodEntity.setMethodParamTypes(paramTypes);
//处理方法重载
if(hmMethods.containsKey(methodKey))
{
methodEntity.setRepeatMethodNum(methodEntity.getRepeatMethodNum()+1);
methodEntity.setRepeatMethodsParamTypes(paramTypes);
}
else
{
hmMethods.put(methodKey, methodEntity);
}
}
这里我们把解析出来的方法信息存储在方法实体对象中，通过全大写方法名作为key存放在HashMap中。
这个方法的实现，我们支持方法的重载。
然后我们分析返回结果集的字段信息，存放在表结构对象实体中：
ResultSetMetaData rsMetaData = rsResult.getMetaData();
int columnCount = rsMetaData.getColumnCount();
dataTable = new DataTableEntity(columnCount);
//获取字段名称，类型
for (int i = 0; i < columnCount; i++)
{
String columnName = rsMetaData.getColumnName(i + 1);
int columnType = rsMetaData.getColumnType(i + 1);
dataTable.setColumnName(columnName, i);
dataTable.setColumnType(columnType, i);
}
下面就可以对返回的结果集数据进行处理了：
while(rsResult.next())
{
//调用方法，根据字段名在hsMethods中查找对应的set方法
}
完整是实现如下：
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.lang.reflect.Array;
public class ConvertResultSetToEntity
{
/**
* 实现结果集到实体对象/值对象/持久化对象转换
* @param rsResult ResultSet
* @param strEntity String
* @throws Exception
* @return Object[]
*/
public static Object[] parseDataEntityBeans(ResultSet rsResult, String strEntity)
throws Exception
{
DataTableEntity dataTable = null;
java.util.List listResult = new java.util.ArrayList();
//注册实体,strEntity指定的实体类名称字符串
Class classEntity = Class.forName(strEntity);
//获取实体中定义的方法
HashMap hmMethods = new HashMap();
for (int i = 0; i < classEntity.getDeclaredMethods().length; i++)
{
MethodEntity methodEntity = new MethodEntity();
//方法的名称
String methodName = classEntity.getDeclaredMethods()[i].getName();
String methodKey = methodName.toUpperCase();
//方法的参数
Class[] paramTypes = classEntity.getDeclaredMethods()[i].getParameterTypes();
methodEntity.setMethodName(methodName);
methodEntity.setMethodParamTypes(paramTypes);
//处理方法重载
if(hmMethods.containsKey(methodKey))
{
methodEntity.setRepeatMethodNum(methodEntity.getRepeatMethodNum()+1);
methodEntity.setRepeatMethodsParamTypes(paramTypes);
}
else
{
hmMethods.put(methodKey, methodEntity);
}
}
//处理ResultSet结构体信息
if(rsResult != null)
{
ResultSetMetaData rsMetaData = rsResult.getMetaData();
int columnCount = rsMetaData.getColumnCount();
dataTable = new DataTableEntity(columnCount);
//获取字段名称，类型
for (int i = 0; i < columnCount; i++)
{
String columnName = rsMetaData.getColumnName(i + 1);
int columnType = rsMetaData.getColumnType(i + 1);
dataTable.setColumnName(columnName, i);
dataTable.setColumnType(columnType, i);
}
}
//处理ResultSet数据信息
while(rsResult.next())
{
//调用方法，根据字段名在hsMethods中查找对应的set方法
Object objResult = ParseObjectFromResultSet(rsResult, dataTable, classEntity, hmMethods);
listResult.add(objResult);
}
//以数组方式返回
Object objResutlArray = Array.newInstance(classEntity, listResult.size());
listResult.toArray((Object[]) objResutlArray);
return (Object[])objResutlArray;
}
/**
* 从Resultset中解析出单行记录对象，存储在实体对象中
*/
public static Object ParseObjectFromResultSet(
ResultSet rs,
DataTableEntity dataTable,
Class classEntity,
java.util.HashMap hsMethods)
throws Exception
{
Object objEntity = classEntity.newInstance();
Method method = null;
int nColumnCount = dataTable.getColumnCount();
String[] strColumnNames = dataTable.getColumnNames();
for (int i = 0; i < nColumnCount; i++)
{
//获取字段值
Object objColumnValue = rs.getObject(strColumnNames[i]);
//HashMap中的方法名key值
String strMethodKey = null;
//获取set方法名
if (strColumnNames[i] != null)
{
strMethodKey = String.valueOf("SET" + strColumnNames[i].toUpperCase());
}
//值和方法都不为空,这里方法名不为空即可,值可以为空的
if (strMethodKey!= null)
{
//判断字段的类型,方法名，参数类型
try
{
MethodEntity methodEntity = (MethodEntity)hsMethods.get(strMethodKey);
String methodName = methodEntity.getMethodName();
int repeatMethodNum = methodEntity.getRepeatMethodNum();
Class[] paramTypes = methodEntity.getMethodParamTypes();
method = classEntity.getMethod(methodName, paramTypes);
//如果重载方法数 > 1，则判断是否有java.lang.IllegalArgumentException异常，循环处理
try
{
//设置参数,实体对象，实体对象方法参数
method.invoke(objEntity, new Object[]{objColumnValue});
}
catch(java.lang.IllegalArgumentException e)
{
//处理重载方法
for(int j = 1; j < repeatMethodNum; j++)
{
try
{
Class[] repeatParamTypes = methodEntity.getRepeatMethodsParamTypes(j - 1);
method = classEntity.getMethod(methodName, repeatParamTypes);
method.invoke(objEntity, new Object[]{objColumnValue});
break;
}
catch(java.lang.IllegalArgumentException ex)
{
continue;
}
}
}
}
catch (NoSuchMethodException e)
{
throw new NoSuchMethodException();
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
}
return objEntity;
}
|
|
|
