我自己的处理：写一个util类，然后封装方法
@SuppressWarnings("unchecked")
public static List resultSetToList(ResultSet rs, Class cls)throws Exception {
//取得Method
Method[] methods = cls.getDeclaredMethods();
System.out.println(methods[0].getName());
List lst = new ArrayList();
// 用于获取列数、或者列类型
ResultSetMetaData meta = rs.getMetaData();
Object obj = null;
while (rs.next()) {
// 获取formbean实例对象
obj = cls.newInstance(); // 用Class.forName方法实例化对象和new创建实例化对象是有很大区别的，它要求JVM首先从类加载器中查找类，然后再实例化，并且能执行类中的静态方法。而new仅仅是新建一个对象实例
// 循环获取指定行的每一列的信息
for (int i = 1; i <= meta.getColumnCount(); i++) {
// 当前列名
String colName = meta.getColumnName(i);
// 设置方法名
String setMethodName = "set" + colName;
//遍历Method
for (int j = 0; j < methods.length; j++) {
if (methods[j].getName().equalsIgnoreCase(setMethodName)) {
setMethodName = methods[j].getName();
System.out.println(setMethodName);
// 获取当前位置的值，返回Object类型
Object value = rs.getObject(colName);
if(value == null){
continue;
}
//实行Set方法
try {
//// 利用反射获取对象
//JavaBean内部属性和ResultSet中一致时候
Method setMethod = obj.getClass().getMethod(
setMethodName, value.getClass());
setMethod.invoke(obj, value);
} catch (Exception e) {
//JavaBean内部属性和ResultSet中不一致时候，使用String来输入值。
e.printStackTrace();
}
}
}
}
lst.add(obj);
}
return lst;
}
相关参考：
原文地址 http://blog.csdn.net/redria/article/details/2988158
其实反射也不是什么高深莫测的东西。反射就是我们对一个未知对象进行操作，由于它是未知的，所以我们需要从类型等方面下手，使用该对象共有的方法和属性，引用自该对象，从而得到我们想要的结果。
本文简单列举了一个利用反射将ResultSet的值自动赋值到POJO(JavaBean)对象的一个实例，便于大家学习。
package demo;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.sql.ResultSetMetaData;
import java.sql.ResultSet;
/**
* 绑定数据处理
* Wrote by redria
*/
public class BindData {
/**
* 从ResultSet绑定到JavaBean
*
* @param ResultSet
* @param DTO（JavaBean）
* @return DTO
*/
public static DTO bindDataToDTO(ResultSet rs, DTO dto) throws Exception {
//取得Method方法
Method[] methods = dto.getClass().getMethods();
//取得ResultSet的列名
ResultSetMetaData rsmd = rs.getMetaData();
int columnsCount = rsmd.getColumnCount();
String[] columnNames = new String[columnsCount];
for (int i = 0; i < columnsCount; i++) {
columnNames[i] = rsmd.getColumnLabel(i + 1);
}
//遍历ResultSet
while (rs.next()) {
//反射, 从ResultSet绑定到JavaBean
for (int i = 0; i < columnNames.length; i++) {
//取得Set方法
String setMethodName = "set" + columnNames[i];
//遍历Method
for (int j = 0; j < methods.length; j++) {
if (methods[j].getName().equalsIgnoreCase(setMethodName)) {
setMethodName = methods[j].getName();
Object value = rs.getObject(columnNames[i]);
//实行Set方法
try {
//JavaBean内部属性和ResultSet中一致时候
Method setMethod = dto.getClass().getMethod(
setMethodName, value.getClass());
setMethod.invoke(dto, value);
} catch (Exception e) {
//JavaBean内部属性和ResultSet中不一致时候，使用String来输入值。
Method setMethod = dto.getClass().getMethod(
setMethodName, String.class);
setMethod.invoke(dto, value.toString());
}
}
}
}
}
//戻り値
return dto;
}
/**
*从ResultSet绑定到JavaBean数组
*
* @param ResultSet
* @param DTO（JavaBean）
* @return DTO数组
*/
public static DTO[] bindDataToDTOS(ResultSet rs, DTO dto) throws Exception {
//取得Method
Method[] methods = dto.getClass().getMethods();
//取得ResultSet的列名
ResultSetMetaData rsmd = rs.getMetaData();
int columnsCount = rsmd.getColumnCount();
String[] columnNames = new String[columnsCount];
for (int i = 0; i < columnsCount; i++) {
columnNames[i] = rsmd.getColumnLabel(i + 1);
}
//取得Class
Class<? extends DTO> dtoClass = dto.getClass();
//取得record数
rs.last();
int rsCnt = rs.getRow();
rs.beforeFirst();
//DTO[]初期化
DTO[] dtos = (DTO[]) Array.newInstance(dtoClass, rsCnt);
int dtoNow = 0;
//遍历ResultSet
while (rs.next()) {
//DTO[]中DTO初期化
dtos[dtoNow] = (DTO) dtoClass.newInstance();
//反射, 从ResultSet绑定到JavaBean
for (int i = 0; i < columnNames.length; i++) {
//取得Set方法
String setMethodName = "set" + columnNames[i];
//遍历Method
for (int j = 0; j < methods.length; j++) {
if (methods[j].getName().equalsIgnoreCase(setMethodName)) {
setMethodName = methods[j].getName();
Object value = rs.getObject(columnNames[i]);
//实行Set方法
try {
//JavaBean内部属性和ResultSet中一致时候
Method setMethod = dto.getClass().getMethod(
setMethodName, value.getClass());
setMethod.invoke(dtos[dtoNow], value);
} catch (Exception e) {
//JavaBean内部属性和ResultSet中不一致时候，使用String来输入值。
Method setMethod = dto.getClass().getMethod(
setMethodName, String.class);
setMethod.invoke(dtos[dtoNow], value.toString());
}
}
}
}
dtoNow++;
}
//返回值
return dtos;
}
}
当然这里的DTO是一个普通的JavaBean类。我们可以建立一个基类，然后建立我们要的JavaBean子类来继承于该基类，将子类扔进来反射，我们就可以得到一个绑定好数据的子类。诚然，我这里对数据类型判别的也不多，不是和ResultSet中一直的，统统变成了String，这里可以根据需要自行修改。
注意：这里如果要绑定，则必须JavaBean中的属性名称和ResultSet中的列名一致，反射也需要有一个参照对象不是么，不然绑定到哪里去呢？呵呵……
原理么，就是拿ResultSet中的列名和JavaBean中的属性名配对，然后赋值。
http://www.blogjava.net/wanghl259748/articles/277261.html
一般做法是将ResultSet封装成一个个javabean然后将javabean放入list集合中返回。
类似于：
public class test {
DB dbx = new DB();
public static List resultSetToList(String sql) throws SQLException {
DB dbx = new DB();
ResultSet rs = dbx.executeQuery(sql);
ResultSetMetaData md = rs.getMetaData();
for (int i = 0; i < md.getColumnCount(); i++) {
System.out.println(md.getColumnName(i));
System.out.println( "----------------- ");
}
List list = new ArrayList();
while (rs.next()) {
UserBean bean = new UserBean();
int userid = rs.getInt( "userid ");
String username = rs.getString( "username ");
bean.setUserid(userid + " ");
bean.setUsername(username);
list.add(bean);
System.out.println(userid + " "+username);
}
return list;
}
}
另外一种方法
package com.service;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.List;
import com.entity.Student;
public class Service {
public List toList(ResultSet rs,Class cls)
{
try
{
List lst=new ArrayList();
//用于获取列数、或者列类型
ResultSetMetaData meta=rs.getMetaData();
Object obj=null;
while(rs.next())
{
//获取formbean实例对象
obj=Class.forName(cls.getName()).newInstance(); //用Class.forName方法实例化对象和new创建实例化对象是有很大区别的，它要求JVM首先从类加载器中查找类，然后再实例化，并且能执行类中的静态方法。而new仅仅是新建一个对象实例
//循环获取指定行的每一列的信息
for(int i=1;i<=meta.getColumnCount();i++)
{
//当前列名
String colName=meta.getColumnName(i);
//将列名第一个字母大写（为什么加+""ne ?是大写字母比小写字母多个字节？）
colName=colName.replace(colName.charAt(0)+"", new String(colName.charAt(0)+"").toUpperCase());
//设置方法名
String methodName="set"+colName;
System.out.println(methodName);
//获取当前位置的值，返回Object类型
Object value=rs.getObject(i);
//利用反射获取对象（反射概念很模糊？不太懂）
Method method=obj.getClass().getMethod(methodName, value.getClass());
method.invoke(obj, value); //感觉这段类似于obj.setMethodName(value)......对于静态方法的反射可以写成method.invoke(null,value),而不能把第一个参数省略，如果方法没有参数的话，第二个参数可以为空
}
lst.add(obj);
}
return lst;
}
catch(Exception ex)
{
ex.printStackTrace();
return null;
}
}
}
使用BeanUtils类简化request和resultset转换
2009年06月01日 20:02
当提交表单时，如果没有使用Struts等框架的话，你的代码可能是这样
User user=new User();
user.setUsername(request.getParameter("username"));
user.setPassword(request.getParameter("password"));
user.setEmail(request.getParameter("email"));
如果表单项比较多，每次都要这样写是不是很烦？
OK，使用commons-beanutils吧。你只需要这样写
try {
Map params=request.getParameterMap();
BeanUtils.populate(user , params);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
那么处理ResultSet时，如果没有Hibernate等框架，你的代码可能是这样
if (rs.next()) {
User user = new User();
user.setId(rs.getLong("id"));
user.setUsercode(rs.getString("usercode"));
user.setSex(rs.getString("sex"));
user.setPassword(rs.getString("password"));
user.setPhone(rs.getString("phone"));
user.setEmail(rs.getString("email"));
users.add(user);
}
是不是也有点烦？OK，这样来写吧
ResultSetDynaClass rsdc = new ResultSetDynaClass(rs);
Iterator rows = rsdc.iterator();
ArrayList lists = new ArrayList();
while (rows.hasNext()) {
User user = new User();
DynaBean row = (DynaBean) rows.next();
BeanUtils.copyProperties(user, row);
lists.add(user)
}
如何，是否让你的工作更加有效率了呢？
分享到：
相关推荐
在Java编程中，ResultSet是处理数据库查询结果的主要接口，它由Statement或PreparedStatement对象执行SQL查询后返回。而JavaBean是一种符合特定规范的Java类，通常用于封装数据，便于数据的传输和操作。当我们从...
本文将详细介绍如何在Java中将ResultSet转换为JSON，以及如何将JSON转换为List。 首先，我们来探讨如何将ResultSet转化为JSON。在Java中，通常使用第三方库如Jackson或Gson来实现JSON操作。这里以Jackson为例： 1....
为了方便数据处理和使用，我们需要将 ResultSet 转为 List，以便于后续的数据处理和展示。 下面是将 ResultSet 转为 List<Map> 的实现代码： ```java public static List,Object>> ResultSetToList(ResultSet rs) ...
在实际开发中，我们可以根据需要选择合适的方法来将ResultSet转换为List对象，以便更方便地处理和操作数据。同时，我们还需要注意到ResultSet对象的二维结构，可以使用二维模型处理，并将其转换为List对象以便更方便...
通过反射从数据库返回集合ResultSet中得到实体对象的list集合
这些方法允许我们灵活地移动`ResultSet`对象中的光标位置，以便进行数据检索或更新操作。 #### 3. ResultSet对象数据获取方法 `ResultSet`提供了多种方法来根据不同的数据类型获取值： - `Array getArray(int ...
### Java反射机制应用详解 #### 一、Java反射机制简介 ...合理利用反射机制，可以极大地提高程序的灵活性和可扩展性。然而，反射也有其局限性，比如性能问题、安全问题等，因此在使用时也需要权衡利弊。
ResultSet转List
在本篇文章中，我们将深入探讨ResultSet的主要概念、操作方法以及相关知识点。 1. ResultSet的创建：ResultSet对象是由Statement或PreparedStatement的executeQuery()方法返回的。当你执行一个SELECT语句时，这个...
ResultSet对象提供了许多有用的方法来处理查询结果，以下是Java ResultSet常用方法的总结。 创建Statement对象 在使用ResultSet之前，需要首先创建一个Statement对象，该对象将生成具有给定类型和并发性的...
例如，如果 ResultSet 对象 rs 的第二列名为“title”，并将值存储为字符串，则可以使用以下代码来获取存储在该列中的值： ```java String s = rs.getString("title"); String s = rs.getString(2); ``` 需要注意...
Java反射机制是Java编程语言中的一个强大工具，它允许程序在运行时检查和操作类、接口、对象等的内部结构。通过反射，开发者可以动态地创建对象、调用方法、访问字段，甚至修改私有成员，这极大地增强了代码的灵活性...
它利用反射机制动态地创建数据库连接，执行SQL语句，并处理结果集。这里我们简单描述一下DBUTIL的几个关键步骤： 1. **获取数据库驱动的Class对象**：通过`Class.forName()`加载指定的数据库驱动，如`...
本案例通过注解的方式，简化了JDBC操作数据库的过程，并利用反射机制动态地调用这些操作。 首先，让我们详细了解Java注解。Java注解是一种元数据，它提供了一种安全的方法来将信息附加到代码中，而不会改变其语义。...
- `rs.absolute(int n)`：将游标移动到指定的行号，n为行号，如果n无效（如负数或超过总行数），则抛出异常。 - `rs.relative(int n)`：相对当前行移动n行，可以正向或负向移动。 - `rs.first()` 和 `rs.last()`...
当需要将这些数据转换为XML格式时，以便于数据交换、存储或进一步处理，我们可以使用各种方法来实现这个过程。"resultset2xml"就是这样一个主题，它涉及将ResultSet对象转换为XML格式的输出。 ResultSet对象是...
java 使ResultSet转换List代码，绝对好用 方便类型转换 不促之处，请提意见
2. **SQL查询**：执行`Statement`或`PreparedStatement`对象的`executeQuery()`方法来执行SQL查询，这会返回一个`ResultSet`对象。 3. **处理ResultSet**：`ResultSet`是一个游标，可以按照顺序读取查询结果。我们...
通过对`ResultSet`的不同类型以及常用方法的理解，开发人员可以根据具体的应用需求选择合适的ResultSet类型，并灵活地利用各种方法来高效地处理查询结果。这对于提高应用程序的性能和用户体验是非常重要的。
这将确保任何后续的查询都将返回可以转换为REF CURSOR的ResultSet。如果不进行这个设置，试图将ResultSet作为REF CURSOR返回会导致错误，例如"ORA-00932: inconsistent datatypes"。 以下是一个示例Java存储过程，...