用Castor 处理XML文档

——Castor可以完成Java和XML的相互转换

前面有介绍过json-lib这个框架，在线博文：http://www.cnblogs.com/hoojo/archive/2011/04/21/2023805.html

以及Jackson这个框架，在线博文：http://www.cnblogs.com/hoojo/archive/2011/04/22/2024628.html

它们都可以完成Java对象到XML的转换，但是还不是那么的完善。还有XStream对JSON及XML的支持，它可以对JSON或XML的完美转换。在线博文：

http://www.cnblogs.com/hoojo/archive/2011/04/22/2025197.html

这 里将介绍Castor来完成Java对象到xml的相互转换。它是怎么样转换的？和前面不同的是castor可以用一个mapping.xml文件来描述 转换后的Java对象的xml基本形态，类似于xStream的annotation，这点还是非常不错的。下面我们就来看看Castor是怎么样完成 Java对象到XML之间的相互转换吧。

一、 准备工作

1、 官方资源

本示例会运用到如下依赖包（jar包）：

资源及jar包下载：http://www.castor.org/download.html

junit jar下载地址：

https://github.com/KentBeck/junit/downloads

关于官方提供的mapping配置相关示例、文档：

http://www.castor.org/xml-mapping.html

ibm提供的castor方面的文档资料：

http://www.google.com.hk/search?hl=zh-CN&newwindow=1&safe=strict&client=aff-cs-360se&hs=Gon&biw=1349&bih=603&q=castor+site%3Awww.ibm.com%2Fdeveloperworks%2Fcn%2Fxml%2F&aq=f&aqi=&aql=&oq =

2、 程序测试运行代码

package
 com.hoo.test;

import
 java.io.IOException;

import
 java.io.StringReader;

import
 java.io.StringWriter;

import
 java.util.ArrayList;

import
 java.util.HashMap;

import
 java.util.List;

import
 java.util.Map;

import
 org.exolab.castor.mapping.Mapping;

import
 org.exolab.castor.mapping.MappingException;

import
 org.exolab.castor.xml.MarshalException;

import
 org.exolab.castor.xml.Marshaller;

import
 org.exolab.castor.xml.Unmarshaller;

import
 org.exolab.castor.xml.ValidationException;

import
 org.junit.After;

import
 org.junit.Before;

import
 org.junit.Test;

import
 com.hoo.entity.Account;

import
 com.hoo.entity.AccountArray;

import
 com.hoo.entity.Birthday;

import
 com.hoo.entity.ListBean;

import
 com.hoo.entity.MapBean;

/**

 * <b>function:</b>Castor完成Java对象到XML的相互转换

 * 依赖jar: castor-1.3.jar 

 * castor-1.3-core.jar 

 * junit-4.8.2.jar 

 * log4j-1.2.16.jar 

 * commons-logging.jar

 * @author hoojo

 * @createDate 2011-4-21 下午07:57:26

 * @file CastorTest.java

 * @package com.hoo.test

 * @project WebHttpUtils

 * @blog http://blog.csdn.net/IBM_hoojo

 * @email [e-mail]

 * @version 1.0

 */

public
 class
 CastorTest {

    private
 Account bean = null;

    private
 Mapping mapping = new
 Mapping();

    private
 StringWriter writer = null;

    private
 StringReader reader = null;

    @Before

    public
 void
 init() {

        bean = new
 Account();

        bean.setAddress("北京"
);

        bean.setEmail("email"
);

        bean.setId(1);

        bean.setName("jack"
);

        Birthday day = new
 Birthday();

        day.setBirthday("2010-11-22"
);

        bean.setBirthday(day);

        try
 {

            /**

             * 加载mapping.xml，此文件是对需要转换的Java对象的配置描述，

             * 即：转换后的Java对象的xml内容的转换规则

             */

            mapping.loadMapping(System.getProperty("user.dir"
) + "\\src\\mapping.xml"
);

        } catch
 (IOException e) {

            e.printStackTrace();

        } catch
 (MappingException e) {

            e.printStackTrace();

        }

    }

    @After

    public
 void
 destory() {

        bean = null;

        mapping = null;

        try
 {

            if
 (writer != null) {

                writer.flush();

                writer.close();

            }

            if
 (reader != null) {

                reader.close();

            }

        } catch
 (IOException e) {

            e.printStackTrace();

        }

        System.gc();

    }

    public
 void
 fail(Object o) {

        System.out.println(o);

    }

    public
 void
 failRed(Object o) {

        System.err.println(o);

    }

}

Mapping对象可以完成Java对象到XML的编组和解组，它需要先设定一个mapping.xml，通过xml对JavaObject的描述。来完成JavaObject的编组、解组工作。

3、 看看即将被转换的JavaEntity代码

Account

package
 com.hoo.entity;

public
 class
 Account {

    private
 int
 id;

    private
 String name;

    private
 String email;

    private
 String address;

    private
 Birthday birthday;

    //setter、getter

    @Override

    public
 String toString() {

        return
 this
.id + "#"
 + this
.name + "#"
 + this
.email + "#"
 + this
.address + "#"
 + this
.birthday;

    }

}

Birthday

package
 com.hoo.entity;

public
 class
 Birthday {

    private
 String birthday;

    public
 Birthday(String birthday) {

        super
();

        this
.birthday = birthday;

    }

    //getter、setter

    public
 Birthday() {}

    @Override

    public
 String toString() {

        return
 this
.birthday;

    }

}

AccountArray

package
 com.hoo.entity;

public
 class
 AccountArray {

    private
 Account[] accounts;

    private
 int
 size;

    public
 int
 getSize() {

        size = accounts.length;

        return
 size;

    }

    public
 void
 setSize(int
 size) {

        this
.size = size;

    }

    public
 Account[] getAccounts() {

        return
 accounts;

    }

    public
 void
 setAccounts(Account[] accounts) {

        this
.accounts = accounts;

    }

}

ListBean

package
 com.hoo.entity;

import
 java.util.List;

public
 class
 ListBean {

    private
 String name;

    private
 List list;

    //setter、getter

}

MapBean

package
 com.hoo.entity;

import
 java.util.Map;

public
 class
 MapBean {

    private
 Map<String, Object> map;

    public
 Map<String, Object> getMap() {

        return
 map;

    }

    public
 void
 setMap(Map<String, Object> map) {

        this
.map = map;

    }

}

二、 编组 JavaObject 到 XML

1、 将JavaBean编组，转换成XML

/**

 * <b>function:</b>将Javabean编组，转换成XML

 * @author hoojo

 * @createDate 2011-4-22 下午12:08:48

 */

@Test

public
 void
 writeBean2XML() {

    writer = new
 StringWriter();

    try
 {

        //编组

        Marshaller.marshal(bean, writer);

        fail(writer);

    } catch
 (MarshalException e) {

        e.printStackTrace();

    } catch
 (Exception e) {

        e.printStackTrace();

    }

}

代码很简单，通过Marshaller的marshal方法来完成Java对象到XML的编组（序列化、转换）工作。

运行后的结果如下：

<?xml version="1.0"
 encoding="UTF-8"
?>

<account id="1"
><address>北京</address><email>email</email><name>jack</name>

<birthday><birthday>2010-11-22</birthday></birthday></account>

2、 将List集合转换成XML

/**

 * <b>function:</b>将List转换成xml

 * @author hoojo

 * @createDate 2011-4-22 下午12:11:00

 */

@Test

public
 void
 writeList2XML() {

    writer = new
 StringWriter();

    List<Account> list = new
 ArrayList<Account>();

    list.add(bean);

    bean = new
 Account();

    bean.setName("tom"
);

    bean.setId(223);

    list.add(bean);

    try
 {

        Marshaller.marshal(list, writer);

        fail(writer);

    } catch
 (MarshalException e) {

        e.printStackTrace();

    } catch
 (Exception e) {

        e.printStackTrace();

    }

}

运行后，结果如下：

<?xml version="1.0"
 encoding="UTF-8"
?>

<array-list>

<account xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:java="http://java.sun.com"
 id="1"
 xsi:type="java:com.hoo.entity.Account"
>

<address>北京</address><email>email</email><name>jack</name><birthday><birthday>2010-11-22</birthday></birthday></account>

<account xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:java="http://java.sun.com"
 id="223"
 xsi:type="java:com.hoo.entity.Account"
>

<name>tom</name>

</account>

</array-list>

怎么样，List存放的是2个Account吧。

3、 将Array数组转换成XML

/**

 * <b>function:</b>将Array数组转换成XML

 * @author hoojo

 * @createDate 2011-4-22 下午12:11:25

 */

@Test

public
 void
 writeArray2XML() {

    writer = new
 StringWriter();

    Account[] acc = new
 Account[2];

    acc[0] = bean;

    bean = new
 Account();

    bean.setName("tom"
);

    bean.setId(223);

    acc[1] = bean;

    try
 {

        Marshaller.marshal(acc, writer);

        fail(writer);

    } catch
 (MarshalException e) {

        e.printStackTrace();

    } catch
 (Exception e) {

        e.printStackTrace();

    }

}

结果如下：

<?xml version="1.0"
 encoding="UTF-8"
?>

<array><account id="1"
><address>北京</address><email>email</email><name>jack</name>

<birthday><birthday>2010-11-22</birthday></birthday></account>

<account id="223"
><name>tom</name></account></array>

4、 转换其他Java类型

/**

 * <b>function:</b>将Java常用类型编组成xml

 * @author hoojo

 * @createDate 2011-4-22 下午12:11:44

 */

@Test

public
 void
 writeObject2XML() {

    writer = new
 StringWriter();

    try
 {

        Marshaller.marshal(true, writer);

        Marshaller.marshal(9527, writer);

        Marshaller.marshal(2.2f, writer);

        Marshaller.marshal(1.11d, writer);

        Marshaller.marshal("lucy"
, writer);

        Marshaller.marshal("hello castor"
.getBytes(), writer);

        Marshaller.marshal(new
 char
[] { 'a'
, 'b'
, 'c'
 }, writer);

        Marshaller.marshal(new
 String[] { "hi"
, "spring"
, "castor"
 }, writer);

        fail(writer);

    } catch
 (MarshalException e) {

        e.printStackTrace();

    } catch
 (Exception e) {

        e.printStackTrace();

    }

}

结果如下：

<?xml version="1.0"
 encoding="UTF-8"
?>

<boolean
>true</boolean
><?xml version="1.0"
 encoding="UTF-8"
?>

<integer>9527</integer><?xml version="1.0"
 encoding="UTF-8"
?>

<float
>2.2</float
><?xml version="1.0"
 encoding="UTF-8"
?>

<double
>1.11</double
><?xml version="1.0"
 encoding="UTF-8"
?>

<string>lucy</string><?xml version="1.0"
 encoding="UTF-8"
?>

<[-b>aGVsbG8gY2FzdG9y</[-b><?xml version="1.0"
 encoding="UTF-8"
?>

<array><character>a</character><character>b</character><character>c</character></array><?xml version="1.0"
 encoding="UTF-8"
?>

<array><string>hi</string><string>spring</string><string>castor</string></array>

都是类型为节点名称，值为text。但是这里并没有出现Map，如果转换Map需要mapping进行配置。下面再慢慢道来-.-

5、 将xml解组成JavaBean

/**

 * <b>function:</b>将XML内容，解组成JavaBean

 * @author hoojo

 * @createDate 2011-4-22 下午12:12:14

 */

@Test

public
 void
 readXML2Bean() {

    String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
 +

                    "<account id=\"1\"><address>北京</address>"
 +

                    "<name>jack</name><email>email</email>"
 +

                    "<birthday><birthday>2010-11-22</birthday></birthday></account>"
;

    reader = new
 StringReader(xml);

    try
 {

        //解组

        Account account = (Account) Unmarshaller.unmarshal(Account.class
, reader);

        fail(account);

    } catch
 (MarshalException e) {

        e.printStackTrace();

    } catch
 (ValidationException e) {

        e.printStackTrace();

    }

}

结果如下：

1#jack#email#北京#2010-11-22

其他的类型，如：map、list、array都不能成功解组。因为这些类型里面有很多系统默认的xml描述。但是利用mapping和自定义JavaBean就可以成功编组和解组了。下面看看mapping是怎么玩转这些类型的。

三、 利用 mapping 配置，编组 JavaObject 、解组 XML

最开始的init方法就提供了mapping，让我们对mapping这个配置有了大概的了解。下面我们将详细介绍mapping是个什么：

1、 在此之前我们设置过mapping.xml。如果不设置，肯定是不能转换成我们想要的XML的。那么，mapping.xml配置文件是怎么配置Account这个对象的呢？

mapping.xml配置如下：

<?
xml
 version
="1.0"
 encoding
="UTF-8"
?>

<!
DOCTYPE
 mapping
 PUBLIC
 "-//EXOLAB/Castor Mapping DTD Version 1.0//EN"
 "http://castor.org/mapping.dtd"
>

<
mapping
>

    <
class
 name
="com.hoo.entity.Account"
 auto-complete
="true"
>
   

        <
map-to
 xml
="Account"
/>

        <
field
 name
="id"
 type
="integer"
>

            <
bind-xml
 name
="id"
 node
="attribute"
 />

        </
field
>

        <
field
 name
="name"
 type
="string"
>

            <
bind-xml
 name
="name"
 node
="element"
 />

        </
field
>

        <
field
 name
="email"
 type
="string"
>

            <
bind-xml
 name
="email"
 node
="element"
 />

        </
field
>

        <
field
 name
="address"
 type
="string"
>

            <
bind-xml
 name
="address"
 node
="element"
 />

        </
field
>

        <
field
 name
="birthday"
 type
="com.hoo.entity.Birthday"
>

            <
bind-xml
 name
="生日"
 node
="element"
 />

        </
field
>

    </
class
>

    <
class
 name
="com.hoo.entity.Birthday"
>

        <
map-to
 xml
="birthday"
 />

        <
field
 name
="birthday"
 type
="string"
>

            <
bind-xml
 name
="birthday"
 node
="attribute"
 />

        </
field
>

    </
class
>

</
mapping
>

首先，看看这个xml文档的根元素是mapping，在mapping中可以配置class。也就是我们要转换的JavaObject的配置描述了。

class元素的name属性就是配置的JavaObject的classpath路径了。

关于class元素的auto-complate属性，如果这个属性的值为ture。那么编组后的xml，castor会自动给没有在 mapping配置文件进行配置的属性自动编组（转换）到xml中。如果为false，那么在mapping配置文件中出现的属性将在编组后不现在在编组 后的xml中。

map-to就是当前class编组后的xml文档的节点元素名称。

field就是描述JavaObject中的属性，name是Java对象的属性名称，type是类型。关于配置的type类型也有规定，你可以参考：http://www.castor.org/xml-mapping.html的field 配置讲解。

而field还有其他的属性配置，如get-method应该是getter方法、set-method应该是setter的方法、 has-mehtod应该是hashCode方法，有时候我们不一定要提高getter、setter方法，我们需要用自己的方法名称来代替 setter、getter。如果当前field配置的是集合类型，那么你需要给field元素配置collection属性。

bind-xml就是绑定（编组）成xml后的xml内容的描述，name就是编组后xml的节点元素名称，node有2个值，分别是 attribute、element。attribute是属性，它会在节点元素的属性中显示，例如：<account id=”2”></account>

而element则是单独的一个元素，例如：<account><id>2</id></account>

就这个样子的。

mapping.xml还可以有其他标签，如：

<include href="other_mapping_file.xml"/>

导入外部xml文件，可以分多个配置。

好了，先将这么多的mapping方面的内容。我们还是看看实际运行的示例吧，代码如下：

/**

 * <b>function:</b>将XML内容解组成Java对象

 * @author hoojo

 * @createDate 2011-4-22 下午12:13:28

 */

@Test

public
 void
 bean4Mapping2XML() {

    writer = new
 StringWriter();

    try
 {

        //编组

        Marshaller mar = new
 Marshaller(writer);

        mar.setMapping(mapping);

        mar.marshal(bean);

        fail(writer);

        //解组

        reader = new
 StringReader(writer.toString());

        Unmarshaller unmar = new
 Unmarshaller(Account.class
);

        unmar.setMapping(mapping);

        Account account = (Account) unmar.unmarshal(reader);

        fail(account);

    } catch
 (MarshalException e) {

        e.printStackTrace();

    } catch
 (Exception e) {

        e.printStackTrace();

    }

}

运行后结果如下：

<?xml version="1.0"
 encoding="UTF-8"
?>

<Account id="1"
><name>jack</name><email>email</email><address>北京</address><生日 birthday="2010-11-22"
/></Account>

1#jack#email#北京#2010-11-22

上面的xml的根节点是Account，这个功劳就来源于mapping配置中的map-to元素，而根节点的id属性是有field和bind- xml来完成的。当bind-xml的node值为attribute时，就会以属性的方式显示。当node为element时，就会像后面name、 email一样，以元素名称显示。

再看看上面的mapping文件中的Account的配置，有个auto-complate属性，如果把这个属性的值设置成false，会怎么样？那我们赶紧试试。

没有发现上面异样，但是当我们删除下面配置的filed的时候，就发现有变化了。

结果如下：

<?xml version="1.0"
 encoding="UTF-8"
?>

<Account><name>jack</name><email>email</email><address>北京</address><生日 birthday="2010-11-22"
/></Account>

0#jack#email#北京#2010-11-22

发现id没有显示在xml中，那么我们再将auto-complate的属性设置true，会有什么惊喜？

结果如下：

<?xml version="1.0"
 encoding="UTF-8"
?>

<Account id="1"
><name>jack</name><email>email</email><address>北京</address><生日 birthday="2010-11-22"
/></Account>

1#jack#email#北京#2010-11-22

发现id又回来了，但是Account的配置中并没有配置id的field。这是为什么，其实auto-comlate在上面已经讲过了。 Castor在编组时会自动将int类型的属性，显示在父元素的属性中。并且JavaObject中有的属性没有在mapping配置文件中配 置，castor也会自动将其编组在xml中。

下面我们看看map-to配置的用法，map-to的主要属性是name，也就是我们把当前根元素重命名的名称。Map-to还有2个属性 可以用，分别是ns-uri、ns-prefix。看名称就知道它大概的意识，一个是命名空间的uri另一个则是命名空间的前缀。我们给上面 mapping加上这两个属性看看。

<map-to xml="Account" ns-uri="http://hoojo.cnblogs.com" ns-prefix="castor"/>

结果如下：

<?xml version="1.0"
 encoding="UTF-8"
?>

<castor:Account xmlns:castor="http://hoojo.cnblogs.com"
 id="1"
><castor:name>jack</castor:name><castor:email>email</castor:email>

<castor:address>北京</castor:address><castor:生日 birthday="2010-11-22"
/></castor:Account>

1#jack#email#北京#2010-11-22

发现了什么？节点元素都带上了ns-prefix的值，而根元素则有了xml的ns。

2、 将一段XML格式字符串转换成JavaBean

@Test

public
 void
 readBean4Mapping2XML() {

    String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
 +

                "<Account id=\"2241\"><name>jack</name><email>email</email><address>北京</address><生日 birthday=\"2010-11-22\"/></Account>"
;

    try
 {

        reader = new
 StringReader(xml);

        Unmarshaller unmar = new
 Unmarshaller(Account.class
);

        unmar.setMapping(mapping);

        Account account = (Account) unmar.unmarshal(reader);

        fail(account);

    } catch
 (MarshalException e) {

        e.printStackTrace();

    } catch
 (Exception e) {

        e.printStackTrace();

    }

}

运行后结果如下：

2241#jack#email#北京#2010-11-22

3、 将XML内容解组成Java的Array

/**

 * <b>function:</b>将XML内容解组成Java的Array

 * @author hoojo

 * @createDate 2011-4-22 下午12:14:50

 */

@Test

public
 void
 array4Mapping2XML() {

    writer = new
 StringWriter();

    Account[] acc = new
 Account[2];

    acc[0] = bean;

    bean = new
 Account();

    bean.setName("tom"
);

    bean.setId(223);

    acc[1] = bean;

    AccountArray array = new
 AccountArray();

    array.setAccounts(acc);

    try
 {

        Marshaller mar = new
 Marshaller(writer);

        mar.setMapping(mapping);

        mar.marshal(array);

        fail(writer);

        reader = new
 StringReader(writer.toString());

        Unmarshaller unmar = new
 Unmarshaller(AccountArray.class
);

        unmar.setMapping(mapping);

        array = (AccountArray) unmar.unmarshal(reader);

        fail(array.getSize());

        fail(array.getAccounts()[0]);

        fail(array.getAccounts()[1]);

    } catch
 (MarshalException e) {

        e.printStackTrace();

    } catch
 (Exception e) {

        e.printStackTrace();

    }

}

AccountArray的mapping配置如下：

<
class
 name
="com.hoo.entity.AccountArray"
>

    <
map-to
 xml
="account-array"
/>

    <
field
 name
="size"
 type
="int"
 />

    <
field
 name
="accounts"
 collection
="array"
 type
="com.hoo.entity.Account"
>

        <
bind-xml
 name
="accounts"
 auto-naming
="deriveByClass"
/>

    </
field
>

</
class
>

collection表示是数组，auto-maming有2中值，一种是类driverByClass，另一种则是driverByField是属性。

运行后，结果如下：

<?xml version="1.0"
 encoding="UTF-8"
?>

<account-array><size>2</size><Account id="1"
><name>jack</name><email>email</email><address>北京</address>

<生日 birthday="2010-11-22"
/></Account><Account id="223"
><name>tom</name></Account></account-array>

2

1#jack#email#北京#2010-11-22

223#tom#null#null#null

4、 将Map编组、解组成JavaObject

/**

 * <b>function:</b>xml转换成Java的Map

 * @author hoojo

 * @createDate 2011-4-22 下午12:15:18

 */

@Test

public
 void
 map4Mapping2XML() {

    writer = new
 StringWriter();

    MapBean mapBean = new
 MapBean();

    Map<String, Object> map = new
 HashMap<String, Object>();

    map.put("No1"
, bean);

    bean = new
 Account();

    bean.setName("tom"
);

    bean.setId(223);

    map.put("No2"
, bean);

    mapBean.setMap(map);

    try
 {

        Marshaller mar = new
 Marshaller(writer);

        mar.setMapping(mapping);

        mar.marshal(mapBean);

        fail(writer);

        reader = new
 StringReader(writer.toString());

        Unmarshaller unmar = new
 Unmarshaller(MapBean.class
);

        unmar.setMapping(mapping);

        mapBean = (MapBean) unmar.unmarshal(reader);

        fail(mapBean.getMap());

    } catch
 (MarshalException e) {

        e.printStackTrace();

    } catch
 (Exception e) {

        e.printStackTrace();

    }

}

Mapping配置

<
class
 name
="com.hoo.entity.MapBean"
>

    <
field
 name
="map"
 collection
="map"
>

        <
bind-xml
 name
="map"
>

            <
class
 name
="org.exolab.castor.mapping.MapItem"
>

                <
field
 name
="key"
 type
="java.lang.String"
>

                    <
bind-xml
 name
="key"
 node
="attribute"
 />

                </
field
>

                <
field
 name
="value"
 type
="com.hoo.entity.Account"
>

                    <
bind-xml
 name
="value"
 auto-naming
="deriveByClass"
/>

                </
field
>

            </
class
>

        </
bind-xml
>

    </
field
>

</
class
>

上面的map配置必须这样配置，利用org.exolab.castor.mapping.MapItem 这个class，完成key、value的配置。

结果如下：

<?xml version="1.0"
 encoding="UTF-8"
?>

<map-bean><map key="No2"
><Account id="223"
><name>tom</name></Account></map>

<map key="No1"
><Account id="1"
><name>jack</name><email>email</email><address>北京</address>

<生日 birthday="2010-11-22"
/></Account></map></map-bean>

{No2=223#tom#null#null#null, No1=1#jack#email#北京#2010-11-22}

5、 JavaList编组、解组XML

/**

 * <b>function:</b>List到XML的相互转换

 * @author hoojo

 * @createDate 2011-4-22 下午12:16:04

 */

@SuppressWarnings("unchecked"
)

@Test

public
 void
 listForMapping2XML() {

    writer = new
 StringWriter();

    List<Account> list = new
 ArrayList<Account>();

    list.add(bean);

    bean = new
 Account();

    bean.setName("tom"
);

    bean.setId(223);

    list.add(bean); 

    ListBean listBean = new
 ListBean();

    listBean.setList(list);

    try
 {

        Marshaller mar = new
 Marshaller(writer);

        mar.setMapping(mapping);

        mar.marshal(listBean);

        fail(writer);

        reader = new
 StringReader(writer.toString());

        Unmarshaller unmar = new
 Unmarshaller(ListBean.class
);

        unmar.setMapping(mapping);

        listBean = (ListBean) unmar.unmarshal(reader);

        fail(listBean.getList().size());

        for
 (Account acc : (List<Account>)listBean.getList()) {

            fail(acc);

        }

    } catch
 (MarshalException e) {

        e.printStackTrace();

    } catch
 (Exception e) {

        e.printStackTrace();

    }

}

Mapping配置

<
class
 name
="com.hoo.entity.ListBean"
>

    <
map-to
 xml
="listBean"
/>

    <
field
 name
="list"
 collection
="arraylist"
 type
="com.hoo.entity.Account"
>

        <
bind-xml
 name
="beans"
 auto-naming
="deriveByClass"
/>

    </
field
>

</
class
>

结果：

<?xml version="1.0"
 encoding="UTF-8"
?>

<listBean><Account id="1"
><name>jack</name><email>email</email><address>北京</address>

<生日 birthday="2010-11-22"
/></Account><Account id="223"
><name>tom</name></Account></listBean>

2

1#jack#email#北京#2010-11-22

223#tom#null#null#null