BeanUtils 以及BeanUtils.populate使用

Apache Jakarta Commons项目非常有用。我曾在许多不同的项目上或直接或间接地使用各种流行的commons组件。其中的一个强大的组件就是BeanUtils。我将说明如何使用BeanUtils将local实体bean转换为对应的value 对象:

BeanUtils.copyProperties(aValue, aLocal)

上面的代码从aLocal对象复制属性到aValue对象。它相当简单!它不管local(或对应的value)对象有多少个属性,只管进行复制。我们假设local对象有100个属性。上面的代码使我们可以无需键入至少100行的冗长、容易出错和反复的get和set方法调用。这太棒了!太强大了!太有用了!

现在,还有一个坏消息:使用BeanUtils的成本惊人地昂贵!我做了一个简单的测试,BeanUtils所花费的时间要超过取数据、将其复制到对应的value对象(通过手动调用get和set方法),以及通过串行化将其返回到远程的客户机的时间总和。所以要小心使用这种威力!

如果您有BeanUtils和类似的实用程序方面的体验,请与我交流分享。

+prakash


Beanutils用了魔术般的反射技术,实现了很多夸张有用的功能,都是C/C++时代不敢想的。无论谁的项目,始终一天都会用得上它。我算是后知后觉了,第一回看到它的时候居然错过。

1.属性的动态getter,setter

在这框架满天飞的年代,不能事事都保证执行getter,setter函数了,有时候属性是要需要根据名字动态取得的,就像这样:

BeanUtils.getProperty(myBean,"code");

而BeanUtils更强的功能是直接访问内嵌对象的属性,只要使用点号分隔。

BeanUtils.getProperty(orderBean, "address.city");

相比之下其他类库的BeanUtils通常都很简单,不能访问内嵌的对象,所以经常要用Commons BeanUtils替换它们。

BeanUtils还支持List和Map类型的属性。如下面的语法即可取得顾客列表中第一个顾客的名字

BeanUtils.getProperty(orderBean, "customers[1].name");

其中BeanUtils会使用ConvertUtils类把字符串转为Bean属性的真正类型,方便从HttpServletRequest等对象中提取bean,或者把bean输出到页面。

而PropertyUtils就会原色的保留Bean原来的类型。

2.beanCompartor 动态排序

还是通过反射,动态设定Bean按照哪个属性来排序,而不再需要在bean的Compare接口进行复杂的条件判断。

List peoples = ...; // Person对象的列表 Collections.sort(peoples, new BeanComparator("age"));

如果要支持多个属性的复合排序,如"Order By lastName,firstName"

ArrayList sortFields = new ArrayList(); sortFields.add(new BeanComparator("lastName")); sortFields.add(new BeanComparator("firstName")); ComparatorChain multiSort = new ComparatorChain(sortFields); Collections.sort(rows,multiSort);

其中ComparatorChain属于jakata commons-collections包。

如果age属性不是普通类型,构造函数需要再传入一个comparator对象为age变量排序。

另外, BeanCompartor本身的ComparebleComparator, 遇到属性为null就会抛出异常, 也不能设定升序还是降序。

这个时候又要借助commons-collections包的ComparatorUtils.

Comparator mycmp = ComparableComparator.getInstance();

mycmp = ComparatorUtils.nullLowComparator(mycmp);  //允许null

mycmp = ComparatorUtils.reversedComparator(mycmp); //逆序

Comparator cmp = new BeanComparator(sortColumn, mycmp);

3.Converter 把Request或ResultSet中的字符串绑定到对象的属性

   经常要从request,resultSet等对象取出值来赋入bean中,下面的代码谁都写腻了,如果不用MVC框架的绑定功能的话。

String a = request.getParameter("a"); bean.setA(a); String b = ....

不妨写一个Binder:

MyBean bean = ...; HashMap map = new HashMap(); Enumeration names = request.getParameterNames(); while (names.hasMoreElements()) { String name = (String) names.nextElement(); map.put(name, request.getParameterValues(name)); } BeanUtils.populate(bean, map);

其中BeanUtils的populate方法或者getProperty,setProperty方法其实都会调用convert进行转换。

但Converter只支持一些基本的类型,甚至连java.util.Date类型也不支持。而且它比较笨的一个地方是当遇到不认识的类型时,居然会抛出异常来。

对于Date类型,我参考它的sqldate类型实现了一个Converter,而且添加了一个设置日期格式的函数。

要把这个Converter注册,需要如下语句:

ConvertUtilsBean convertUtils = new ConvertUtilsBean();

DateConverter dateConverter = new DateConverter();

convertUtils.register(dateConverter,Date.class);

//因为要注册converter,所以不能再使用BeanUtils的静态方法了,必须创建BeanUtilsBean实例

BeanUtilsBean beanUtils = new BeanUtilsBean(convertUtils,new PropertyUtilsBean());

beanUtils.setProperty(bean, name, value);

4 其他功能

4.1 PropertyUtils,当属性为Collection,Map时的动态读取:


Collection: 提供index

BeanUtils.getIndexedProperty(orderBean,"items",1);

或者

BeanUtils.getIndexedProperty(orderBean,"items[1]");

Map: 提供Key Value

BeanUtils.getMappedProperty(orderBean, "items","111");//key-value goods_no=111

或者

BeanUtils.getMappedProperty(orderBean, "items(111)")


4.2 PropertyUtils,获取属性的Class类型

     public static Class getPropertyType(Object bean, String name)


4.3 ConstructorUtils,动态创建对象

      public static Object invokeConstructor(Class klass, Object arg)

4.4 MethodUtils,动态调用方法

MethodUtils.invokeMethod(bean, methodName, parameter);

4.5 动态Bean 见用DynaBean减除不必要的VO和FormBean 

一、概述

第一次看到BeanUtils包,是在Struts项目中,作为Struts一个工具来使用的,

估计功能越弄越强,就移到Common项目中了吧。

BeanUtils一共有四个package:

org.apache.commons.beanutils

org.apache.commons.beanutils.converters

org.apache.commons.beanutils.locale

org.apache.commons.beanutils.locale.converters

后三个包主要是用于数据的转换,围绕着一个Converter接口,该接口只有一个方法:

java.lang.Object convert(java.lang.Class type, java.lang.Object value) ,

用于将一个value转换成另一个类型为type的Object。在一些自动化的应用中应该会有用。

这里不作评论,以后有兴趣了,或者觉得有用了,再行研究。

这里只讲第一个包。

二、测试用的Bean

在开始所有的测试之前,我写了一个简单的Bean,以便于测试,代码如下:

package test.jakarta.commons.beanutils;

public class Month {

private int value;

private String name;

private int[] days={11,22,33,44,55};

public Month(int v, String n){

value=v;

name=n;

}

public String getName() {

return name;

}

public int getValue() {

return value;

}

public void setName(String name) {

this.name = name;

}

public void setValue(int value) {

this.value = value;

}

public String toString() {

return value+"("+name+")";

}

public int[] getDays() {

return days;

}

public void setDays(int[] is) {

days = is;

}

}

三、BeanUtils

这是一个主要应用于Bean的Util(呵呵,这个解释很绝吧),以下是其中几个方法的例子

//static java.util.Map describe(java.lang.Object bean)

//这个方法返回一个Object中所有的可读属性,并将属性名/属性值放入一个Map中,另外还有

//一个名为class的属性,属性值是Object的类名,事实上class是java.lang.Object的一个属性

Month month=new Month(1, "Jan");

try {

Map map=BeanUtils.describe(month);

Set keySet=map.keySet();

for (Iterator iter = keySet.iterator(); iter.hasNext();) {

Object element = (Object) iter.next();

System.out.println("KeyClass:"+element.getClass().getName());

System.out.println("ValueClass:"+map.get(element).getClass().getName());

System.out.print(element+"\t");

System.out.print(map.get(element));

System.out.println();

}

} catch (IllegalAccessException e) {

e.printStackTrace();

} catch (InvocationTargetException e) {

e.printStackTrace();

} catch (NoSuchMethodException e) {

e.printStackTrace();

}

输出为:

KeyClass:java.lang.String

ValueClass:java.lang.String

value  1

KeyClass:java.lang.String

ValueClass:java.lang.String

class  class test.jakarta.commons.beanutils.Month

KeyClass:java.lang.String

ValueClass:java.lang.String

name  Jan

注意到所有Map中的key/value都是String,而不管object中实际的值是多少。

与此对应的还有static void populate(java.lang.Object bean, java.util.Map properties)

用于将刚才describe出的Map再装配成一个对象。

再看这样一段代码

曹晓钢也许还记得,为了取一个不确定对象的property,着实花了不少时间,

难度不大,但要做到100%的正确,仍然需要付出很大的精力。

//static java.lang.String getProperty(java.lang.Object bean, java.lang.String name)

Month month=new Month(1, "Jan");

try {

System.out.println(BeanUtils.getProperty(month,"value"));

} catch (Exception e) {

e.printStackTrace();

}

//输出是:1

与getProperty类似的还有getIndexedProperty, getMappedProperty,

以getIndexedProperty为例:

Month month=new Month(1, "Jan");

try {

System.out.println(BeanUtils.getIndexedProperty(month,"days",1));

System.out.println(BeanUtils.getIndexedProperty(month,"days[1]"));

} catch (Exception e) {

e.printStackTrace();

}

这两个调用是相同的。

BeanUtils中还有一个方法:

static void copyProperties(java.lang.Object dest, java.lang.Object orig)

它真是太有用,还记得struts中满天飞的都是copyProperties,我甚至怀疑整个BeanUtils最初

是不是因为这个方法的需求才写出来的。

它将对象orig中的属性复制到dest中去。

四、PropertyUtils

这个类和BeanUtils类很多的方法在参数上都是相同的,但返回值不同。

BeanUtils着重于"Bean",返回值通常是String,而PropertyUtils着重于属性,

它的返回值通常是Object。

五、ConstructorUtils

这个类中的方法主要分成两种,一种是得到构造方法,一种是创建对象。

事实上多数时候得到构造方法的目的就是创建对象,这里只介绍一下创建对象。

//static java.lang.Object ConstructorUtils.invokeConstructor

//(java.lang.Class klass, java.lang.Object[] args)

//根据一个java.lang.Class以及相应的构造方法的参数,创建一个对象。

Object obj=ConstructorUtils.invokeConstructor(Month.class, {new Integer(1), "Jan"});

Month month=(Month)obj;

try {

System.out.println(BeanUtils.getProperty(month,"value"));

} catch (Exception e) {

e.printStackTrace();

}

输出证明,构造方法的调用是成功的。

如果需要强制指定构造方法的参数类型,可以这样调用:

Object[] args={new Integer(1), "Jan"};

Class[] argsType={int.class, String.class};

Object obj;

obj = ConstructorUtils.invokeExactConstructor(Month.class, args, argsType);

Month month=(Month)obj;

System.out.println(BeanUtils.getProperty(month,"value"));

argsType指定了参数的类型。


六、ConstructorUtils补遗

创建对象还有一个方法:invokeExactConstructor,该方法对参数要求

更加严格,传递进去的参数必须严格符合构造方法的参数列表。

例如:

Object[] args={new Integer(1), "Jan"};

Class[] argsType={int.class, String.class};

Object obj;

//下面这句调用将不会成功,因为args[0]的类型为Integer,而不是int

//obj = ConstructorUtils.invokeExactConstructor(Month.class, args);

//这一句就可以,因为argsType指定了类型。

obj = ConstructorUtils.invokeExactConstructor(Month.class, args, argsType);

Month month=(Month)obj;

System.out.println(BeanUtils.getProperty(month,"value"));

七、MethodUtils

与ConstructorUtils类似,不过调用的时候,通常需要再指定一个method name的参数。

八、DynaClass/DynaBean

这似乎是BeanUtils中最有趣的部分之一了,很简单,简单到光看这两个接口中的方法会不明白

为什么要设计这两个接口。不过看到ResultSetDynaClass后,就明白了。下面是java doc中的代码:

ResultSet rs = ...;

ResultSetDynaClass rsdc = new ResultSetDynaClass(rs);

Iterator rows = rsdc.iterator();

while (rows.hasNext())  {

DynaBean row = (DynaBean) rows.next();

... process this row ...

}

rs.close();

原来这是一个ResultSet的包装器,ResultSetDynaClass实现了DynaClass,它的iterator方法返回一个

ResultSetIterator,则是实现了DynaBean接口。

在获得一个DynaBean之后,我们就可以用

DynaBean row = (DynaBean) rows.next();

System.out.println(row.get("field1")); //field1是其中一个字段的名字

再看另一个类RowSetDynaClass的用法,代码如下:

String driver="com.mysql.jdbc.Driver";

String url="jdbc:mysql://localhost/2hu?useUnicode=true&characterEncoding=GBK";

String username="root";

String password="";

java.sql.Connection con=null;

PreparedStatement ps=null;

ResultSet rs=null;

try {

Class.forName(driver).newInstance();

con = DriverManager.getConnection(url);

ps=con.prepareStatement("select * from forumlist");

rs=ps.executeQuery();

//先打印一下,用于检验后面的结果。

while(rs.next()){

System.out.println(rs.getString("name"));

}

rs.beforeFirst();//这里必须用beforeFirst,因为RowSetDynaClass只从当前位置向前滚动

RowSetDynaClass rsdc = new RowSetDynaClass(rs);

rs.close();

ps.close();

List rows = rsdc.getRows();//返回一个标准的List,存放的是DynaBean

for (int i = 0; i

DynaBean b=(DynaBean)rows.get(i);

System.out.println(b.get("name"));

}

} catch (Exception e) {

e.printStackTrace();

}

finally{

try {

con.close();

} catch (Exception e) {

}

}

是不是很有趣?封装了ResultSet的数据,代价是占用内存。如果一个表有10万条记录,rsdc.getRows()

就会返回10万个记录。@_@

需要注意的是ResultSetDynaClass和RowSetDynaClass的不同之处:

1,ResultSetDynaClass是基于Iterator的,一次只返回一条记录,而RowSetDynaClass是基于

List的,一次性返回全部记录。直接影响是在数据比较多时ResultSetDynaClass会比较的快速,

而RowSetDynaClass需要将ResultSet中的全部数据都读出来(并存储在其内部),会占用过多的

内存,并且速度也会比较慢。

2,ResultSetDynaClass一次只处理一条记录,在处理完成之前,ResultSet不可以关闭。

3,ResultSetIterator的next()方法返回的DynaBean其实是指向其内部的一个固定

对象,在每次next()之后,内部的值都会被改变。这样做的目的是节约内存,如果你需要保存每

次生成的DynaBean,就需要创建另一个DynaBean,并将数据复制过去,下面也是java doc中的代码:

ArrayList results = new ArrayList(); // To hold copied list

ResultSetDynaClass rsdc = ...;

DynaProperty properties[] = rsdc.getDynaProperties();

BasicDynaClass bdc =

new BasicDynaClass("foo", BasicDynaBean.class,

rsdc.getDynaProperties());

Iterator rows = rsdc.iterator();

while (rows.hasNext()) {

DynaBean oldRow = (DynaBean) rows.next();

DynaBean newRow = bdc.newInstance();

PropertyUtils.copyProperties(newRow, oldRow);

results.add(newRow);

}

事实上DynaClass/DynaBean可以用于很多地方,存储各种类型的数据。自己想吧。嘿嘿。

九、自定义的CustomRowSetDynaClass

两年前写过一个与RowSetDynaClass目标相同的类,不过多一个功能,就是分页,只取需要的数据,

这样内存占用就会减少。

先看一段代码:

String driver="com.mysql.jdbc.Driver";

String url="jdbc:mysql://localhost/2hu?useUnicode=true&characterEncoding=GBK";

String username="root";

String password="";

java.sql.Connection con=null;

PreparedStatement ps=null;

ResultSet rs=null;

try {

Class.forName(driver).newInstance();

con = DriverManager.getConnection(url);

ps=con.prepareStatement("select * from forumlist order by name");

rs=ps.executeQuery();

//第二个参数表示第几页,第三个参数表示页的大小

CustomRowSetDynaClass rsdc = new CustomRowSetDynaClass(rs, 2, 5);

//RowSetDynaClass rsdc = new RowSetDynaClass(rs);

rs.close();

ps.close();

List rows = rsdc.getRows();

for (int i = 0; i

DynaBean b=(DynaBean)rows.get(i);

System.out.println(b.get("name"));

}

} catch (Exception e) {

e.printStackTrace();

}

finally{

try {

con.close();

} catch (Exception e) {

}

}

在这里用到了一个CustomRowSetDynaClass类,构造方法中增加了page和pageSize两个参数,

这样,不管数据库里有多少条记录,最多只取pageSize条记录,若pageSize==-1,则功能和

RowSetDynaClass一样。这在大多数情况下是适用的。该类的代码如下:

package test.jakarta.commons.beanutils;

import java.io.*;

import java.sql.*;

import java.util.*;

import org.apache.commons.beanutils.*;

public class CustomRowSetDynaClass implements DynaClass, Serializable {

// ----------------------------------------------------------- Constructors

public CustomRowSetDynaClass(ResultSet resultSet) throws SQLException {

this(resultSet, true);

}

public CustomRowSetDynaClass(ResultSet resultSet, boolean lowerCase)

throws SQLException {

this(resultSet, 1, -1, lowerCase);

}

public CustomRowSetDynaClass(

ResultSet resultSet,

int page,

int pageSize,

boolean lowerCase)

throws SQLException {

if (resultSet == null) {

throw new NullPointerException();

}

this.lowerCase = lowerCase;

this.page = page;

this.pageSize = pageSize;

introspect(resultSet);

copy(resultSet);

}

public CustomRowSetDynaClass(ResultSet resultSet, int page, int pageSize)

throws SQLException {

this(resultSet, page, pageSize, true);

}

// ----------------------------------------------------- Instance Variables

protected boolean lowerCase = true;

protected int page = 1;

protected int pageSize = -1;

protected DynaProperty properties[] = null;

protected Map propertiesMap = new HashMap();

protected List rows = new ArrayList();

// ------------------------------------------------------ DynaClass Methods

public String getName() {

return (this.getClass().getName());

}

public DynaProperty getDynaProperty(String name) {

if (name == null) {

throw new IllegalArgumentException("No property name specified");

}

return ((DynaProperty) propertiesMap.get(name));

}

public DynaProperty[] getDynaProperties() {

return (properties);

}

public DynaBean newInstance()

throws IllegalAccessException, InstantiationException {

throw new UnsupportedOperationException("newInstance() not supported");

}

// --------------------------------------------------------- Public Methods

public List getRows() {

return (this.rows);

}

// ------------------------------------------------------ Protected Methods

protected void copy(ResultSet resultSet) throws SQLException {

int abs = 0;

int rowsCount = 0;

int currentPageRows = 0;

resultSet.last();

rowsCount = resultSet.getRow();

if (pageSize != -1) {

int totalPages = (int) Math.ceil(((double) rowsCount) / pageSize);

if (page > totalPages)

page = totalPages;

if (page < 1)

page = 1;

abs = (page - 1) * pageSize;

//currentPageRows=(page==totalPages?rowsCount-pageSize*(totalPages-1):pageSize);

} else

pageSize = rowsCount;

if (abs == 0)

resultSet.beforeFirst();

else

resultSet.absolute(abs);

//int

while (resultSet.next() && ++currentPageRows <= pageSize) {

DynaBean bean = new BasicDynaBean(this);

for (int i = 0; i < properties.length; i++) {

String name = properties[i].getName();

bean.set(name, resultSet.getObject(name));

}

rows.add(bean);

}

}

protected void introspect(ResultSet resultSet) throws SQLException {

// Accumulate an ordered list of DynaProperties

ArrayList list = new ArrayList();

ResultSetMetaData metadata = resultSet.getMetaData();

int n = metadata.getColumnCount();

for (int i = 1; i <= n; i++) { // JDBC is one-relative!

DynaProperty dynaProperty = createDynaProperty(metadata, i);

if (dynaProperty != null) {

list.add(dynaProperty);

}

}

// Convert this list into the internal data structures we need

properties =

(DynaProperty[]) list.toArray(new DynaProperty[list.size()]);

for (int i = 0; i < properties.length; i++) {

propertiesMap.put(properties[i].getName(), properties[i]);

}

}

protected DynaProperty createDynaProperty(

ResultSetMetaData metadata,

int i)

throws SQLException {

String name = null;

if (lowerCase) {

name = metadata.getColumnName(i).toLowerCase();

} else {

name = metadata.getColumnName(i);

}

String className = null;

try {

className = metadata.getColumnClassName(i);

} catch (SQLException e) {

// this is a patch for HsqlDb to ignore exceptions

// thrown by its metadata implementation

}

// Default to Object type if no class name could be retrieved

// from the metadata

Class clazz = Object.class;

if (className != null) {

clazz = loadClass(className);

}

return new DynaProperty(name, clazz);

}

protected Class loadClass(String className) throws SQLException {

try {

ClassLoader cl = Thread.currentThread().getContextClassLoader();

if (cl == null) {

cl = this.getClass().getClassLoader();

}

return (cl.loadClass(className));

} catch (Exception e) {

throw new SQLException(

"Cannot load column class '" + className + "': " + e);

}

}

}

大部分代码从BeanUtils的源码中取得,只做了简单的修改,没有加多余的注释。如果要正式使用,

需要再做精加工。


BeanUtils.populate


首先,它是在org.apache.commons.beanutils.BeanUtils包中的一个方法。

方法的作用:用来将一些 key-value 的值(例如 hashmap)映射到 bean 中的属性。


servlet中有这样的使用:

先定义form表单内容的Info对象(当然你要先写一个bean,这个bean中包含form表单中各个对象的属性)

    InsuranceInfo info = new InsuranceInfo();  (这是一个javabean)

    BeanUtilities.populateBean(info, request);

——> populateBean(info, request.getParameterMap());(先将request内容转为Map类型)

——>BeanUtils.populate(info, propertyMap);(调用包中方法映射)


映射的过程就是将页面中的内容先用request获得,然后再将之转换为Map(这里用request.getParameterMap())

最后使用BeanUtils.populate(info,map)方法将页面各个属性映射到bean中。之后我们就可以这样使用bean.getXxxx()来取值了。

你可能感兴趣的:(BeanUtils 以及BeanUtils.populate使用)