利用反射机制,将ResultSet处理为bean或list的方法
2011-09-27 22:06
447 查看
我自己的处理:写一个util类,然后封装方法
Java代码
相关参考:
原文地址 http://blog.csdn.net/redria/article/details/2988158
Java代码
其实反射也不是什么高深莫测的东西。反射就是我们对一个未知对象进行操作,由于它是未知的,所以我们需要从类型等方面下手,使用该对象共有的方法和属性,引用自该对象,从而得到我们想要的结果。
本文简单列举了一个利用反射将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
Java代码
一般做法是将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;
}
}
另外一种方法
Java代码
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;
}
}
}
Java代码
使用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代码
@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
Java代码
其实反射也不是什么高深莫测的东西。反射就是我们对一个未知对象进行操作,由于它是未知的,所以我们需要从类型等方面下手,使用该对象共有的方法和属性,引用自该对象,从而得到我们想要的结果。
本文简单列举了一个利用反射将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中的属性名配对,然后赋值。
其实反射也不是什么高深莫测的东西。反射就是我们对一个未知对象进行操作,由于它是未知的,所以我们需要从类型等方面下手,使用该对象共有的方法和属性,引用自该对象,从而得到我们想要的结果。 本文简单列举了一个利用反射将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
Java代码
一般做法是将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;
}
}
一般做法是将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; } }
另外一种方法
Java代码
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;
}
}
}
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; } } }
Java代码
使用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)
}
如何,是否让你的工作更加有效率了呢?
相关文章推荐
- Spring 配置bean, 注解方式配置 xml方式要生产set方法方便属性注入,注解方式不需要,利用反射机制注入
- 处理ResultSet查询结果并返回一个List方法---利用元数据
- 利用反射机制,将表跟BEAN对象关联的原理
- php利用反射机制查找类和方法的所在位置
- java 利用反射机制,获取实体所有属性和方法,并对属性赋值
- java 利用反射机制,获取实体所有属性和方法,并对属性赋值
- 利用Java的反射机制实现Bean实体与Map自动转换的工具类
- JAVA jdbc ResultSet 通过反射机制转换为实体类Bean
- Java笔记——利用反射机制获取成员变量及成员方法
- 利用反射机制编写一个程序,这个程序能指定调用类的某个方法及构造方法,并把操作信息输出到控制台。
- 利用Objective-C的反射机制和运行时特性实现类静态方法的动态访问(一)
- java 利用反射机制,获取实体所有属性和方法,并对属性赋值
- 利用java的反射机制调用类的私有方法及私有属性
- JDBC:利用 ResultSetMetaData 和反射编写通用查询方法
- java 利用反射机制,获取实体所有属性和方法,并对属性赋值
- 利用反射机制,读取dll,并调用其中的方法
- 利用反射机制动态调用方法
- java 利用反射机制,获取实体所有属性和方法,并对属性赋值
- 泛型与反射机制处理ComBox绑定的数据源是List<实体对象>
- (二)利用反射机制实例化类,获取和修改变量,获取和调用方法和构造方法