BeanUtils

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 (InvocationTargetExceptio n 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 UnsupportedOperationExce ption("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的源码中取得，只做了简单的修改，没有加多余的注释。如果要正式使用，
需要再做精加工。