（摘抄）利用反射机制，将ResultSet处理为bean或list的方法

ghl116

浏览: 164402 次
性别:
来自: 上海

最近访客更多访客>>

zzy7075

存储炒菜错

yaofangshou

Adan-Chiu

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

java bean

我自己的处理：写一个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)
}

如何，是否让你的工作更加有效率了呢？

分享到：