BeanUtils: 威力和代价(转载)

小程序：扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序

转自：http://blog.sina.com.cn/s/blog_ab3fbf1b0101jbxz.html

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="";

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

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的源码中取得，只做了简单的修改，没有加多余的注释。如果要正式使用，

需要再做精加工。