[工具库]JOXMLBuilder工具类——一键把多个bean对象数据转换为XML格式数据

本人大四即将毕业的准程序员（JavaSE、JavaEE、android等）一枚，小项目也做过一点，于是乎一时兴起就写了一些工具。

我会在本博客中陆续发布一些平时可能会用到的工具。

代码质量可能不是很好，大家多担待！

代码或者思路有不妥之处，还希望大牛们能不吝赐教哈！

以下代码为本人原创，转载请注明：

本文转载，来自：http://www.cnblogs.com/tiantianbyconan/archive/2013/02/19/2917398.html

JOXMLBuilder工具类：一键把多个域对象数据转换为XML格式数据，方便用于数据的传输和交互。功能类似于通过Gson来生成Json数据。

源码如下：

package com.wangjie.extrautil.joxmlbuilder;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

/**
 * 
 * @author wangjie
 * @version 创建时间：2013-2-3 下午3:49:59
 */
public class JOXMLBuilder {
    private List<?> list; // 传入的List数据
    private StringBuilder result = null;
    private List<String> includes = null; // 要包含的属性列表
    private List<String> excludes = null; // 要排除的属性列表
    
    /**
     * 默认构造方法。<br>
     * 使用此默认的构造方法之后必须要调用setList()传入List
     */
    public JOXMLBuilder() {
        
    }
    /**
     * 此构造方法会把list中每项的所有属性信息都会生成在xml中。
     * @param list 所要生成xml的List数据源。
     */
    public JOXMLBuilder(List<?> list) {
        this.list = list;
    }
    /**
     * 此构造方法提供list中每项属性信息的<b>包含</b>和<b>排除</b>。<br>
     * <ol>
     * <li>使用includes，不使用excludes：只生成在includes中的信息<br>
     * <li>不使用includes，使用excludes：只生成不在excludes中的信息<br>
     * <li>既使用includes，又使用exclude(不建议)：<br>
     *  - 如果includes中和excludes中的信息不冲突，则生成不在excludes中的信息<br>
     *  - 如果includes中和excludes中的信息冲突(某个属性都出现在这两个数组中)，则冲突部分的信息还是会生成<br>
     * <li>includes和excludes都不使用，则会把list中每项的所有属性信息都会生成在xml中
     * </ol>
     * @param list 所要生成Json的List数据源。
     * @param includes 所要包含的属性名称数组。
     * @param excludes 所要排除的属性名称数组。
     */
    public JOXMLBuilder(List<?> list, String[] includes, String[] excludes) {
        this.list = list;
        this.includes = null == includes || includes.length == 0 ? null : Arrays.asList(includes);
        this.excludes = null == excludes || excludes.length == 0 ? null : Arrays.asList(excludes);
    }
    /**
     * 返回正在进行生成xml文件的信息来源List。
     * @author wangjie
     * @return 返回正在进行生成xml文件的信息来源List。
     */
    public List<?> getList() {
        return list;
    }
    /**
     * 可使用此方法来传入、替换JOXMLBuilder对象中的List对象。
     * @author wangjie
     * @param list 所要生成xml的List数据源。
     * @return 返回当前JOXMLBuilder对象
     */
    public JOXMLBuilder setList(List<?> list) {
        this.list = list;
        return this;
    }
    /**
     * 设置包含的属性信息。
     * @author wangjie
     * @param incFieldName 要包含的属性名
     * @return 返回当前JOXMLBuilder对象
     */
    public JOXMLBuilder setIncludes(String... incFieldName) {
        this.includes = null == incFieldName || incFieldName.length == 0 ? null : Arrays.asList(incFieldName);
        return this;
    }
    /**
     * 设置排除的属性信息。
     * @author wangjie
     * @param excFieldName 要排除的属性名
     * @return 返回当前JOXMLBuilder对象
     */
    public JOXMLBuilder setExcludes(String... excFieldName) {
        this.excludes = null == excFieldName || excFieldName.length == 0 ? null : Arrays.asList(excFieldName);
        return this;
    }
    /**
     * 获得指定Class类型的所有属性，并打印在控制台上。
     * @author wangjie
     */
    public Field[] getFields(Class<?> clazz) {
        Field[] fields = clazz.getDeclaredFields();
        System.out.print("fields of the class that named " + clazz.getName() + ": ");
        for(Field field : fields){
            System.out.print(field.getName() + ", ");
        }
        System.out.println();
        return fields;
    }
    
    /**
     * 根据list中的对象来生成对应的xml文件。
     * @author wangjie
     * @return 返回生成的xml字符串。
     * @throws Exception 如果List检验不通过，则抛出异常
     */
    public StringBuilder xmlBuild() throws Exception{
        //检验传入的List是否有效
        checkValidityList();
        //XML文件开始生成-------------------------
        result = new StringBuilder("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
        xmlSubBuild(list); // 递归生成
        return result;
    }
    /**
     * 生成xml可递归部分的子数据（根据某些对象组成的List来生成属性xml文件）。
     * @author wangjie
     * @param list 
     */
    private void xmlSubBuild(List<?> list){
        Class<?> clazz = list.get(0).getClass(); // 获取对应的Class对象
        Object curObj = null; // 每次循环当前的类对象（资源）
        int listLength = list.size(); // 类对象个数
        String simpleName = clazz.getSimpleName(); // 获取类名（不含包名）
        
        result.append("<" + simpleName + "All>"); // 根标签开始
        
        for(int i = 0; i < listLength; i++){
            curObj = list.get(i);
            xmlSubSubBuild(curObj, list); // 子数据递归
        }
        
        result.append("</" + simpleName + "All>"); // 根标签结束
    }
    /**
     * 生成xml可递归部分的子子数据（根据某个对象来生成属性xml文件）。
     * @author wangjie
     * @param curObj 要生成xml文件的那个对象 
     * @param list curObj参数属于的那个List
     */
    private void xmlSubSubBuild(Object curObj, List<?> list){
        String fieldName = ""; // 每次要调用的属性名
        String methodName = ""; // 每次要调用的方法名
        Method method = null;; // 每次要调用的方法
        Object value = ""; // 每次要获得的属性值（子标签）
        
        Class<?> clazz = curObj.getClass();
        Field[] fields = getFields(clazz); // 获得对应类型的所有变量
        int fieldsLength = fields.length; // 类对象的属性数量
        
        String simpleName = clazz.getSimpleName(); // 获取类名（不含包名）
        
        result.append("<" + simpleName + ">");
        
        
        for(int j = 0; j < fieldsLength; j++){
            fieldName = fields[j].getName(); // 获取对应属性名
            
            if(list == this.list){ // 只在最外层的类的属性中进行排除包含
                // 使用includes，不使用excludes：只生成在includes中的信息
                if(null != includes && null == excludes){
                    if(!includes.contains(fieldName)){
                        continue;
                    }
                }
                
                //不使用includes，使用excludes：只生成不在excludes中的信息
                if(null == includes && null != excludes){ // 只使用了不包含
                    if(excludes.contains(fieldName)){
                        continue;
                    }
                }
                
                //既使用includes，又使用exclude(不建议)：
                //- 如果includes中和excludes中的信息不冲突，则生成不在excludes中的信息
                //- 如果includes中和excludes中的信息冲突(某个属性都出现在这两个数组中)，则冲突部分的信息还是会生成
                if(null != includes && null != excludes){ // 既使用了包含，又使用了不包含
                    if(!includes.contains(fieldName) && excludes.contains(fieldName)){
                        continue;
                    }
                }
            }
            
            methodName = getGetterMethodNameByFieldName(fields[j]);
            try {
                method = clazz.getDeclaredMethod(methodName, new Class[]{});
                method.setAccessible(true);
                value = method.invoke(curObj, new Object[]{});
                //*********************************************************
                if(fields[j].getType() == List.class){ // 如果属性是List类型
                    List<?> subList = (List<?>)value;
                    xmlSubBuild(subList); // 子数据递归
                }else if(fields[j].getType() == Set.class){ // 如果属性是Set类型的
                    Set<?> subSet = (Set<?>)value;
                    Iterator<?> iter = subSet.iterator();
                    List<Object> subList = new ArrayList<Object>(); 
                    while(iter.hasNext()){
                        subList.add(iter.next());
                    }
                    xmlSubBuild(subList); // 子数据递归
                }
                // 如果ClassLoader不是null表示该类不是启动类加载器加载的，不是Java API的类，是自己写的java类
                else if(null != fields[j].getType().getClassLoader()){ 
                    xmlSubSubBuild(value, null); // 子子数据递归
                }
                else{ // 其它类型都认为是普通文本类型
                    value = value.toString();
                    // 添加子元素（类属性）标签
                    result.append("<" + fieldName + ">")
                            .append(value)
                            .append("</" + fieldName + ">");
                }
                //*********************************************************
            } catch (Exception e) {
                e.printStackTrace();
            }
            
        }
        result.append("</" + simpleName + ">");
    }
    
    /**
     * <ol>通过属性Field对象来获取getter方法的方法名。<br>
     * 如果是boolean或Boolean类型(正则表达式来判断):isBorrow-->isBorrow();isborrow-->isIsborrow();<br>
     * 否则:borrow-->getBorrow();
     * </ol>
     * @author wangjie
     * @param field 要生成getter方法的对应属性对象。
     * @return 返回getter方法的方法名。
     */
    private String getGetterMethodNameByFieldName(Field field){
        String methodName = null;
        String fieldName = field.getName();
        // 解析属性对应的getter方法名
        // 判断是否是boolean或Boolean类型:isBorrow-->isBorrow();isborrow-->isIsborrow()
        if(field.getType() == boolean.class || field.getType() == Boolean.class){
            if(fieldName.matches("^is[A-Z].*")){
                methodName = fieldName;
            }else{
                methodName = "is" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
            }
        }else{
            methodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
        }
        return methodName;
    }
    
    /**
     * 检验传入的List的合法性（List是不是为null、长度是不是为0、是不是每项都是同一个类型）。
     * @author wangjie
     * @throws Exception 如果List为null, 或者长度为, 或者每项不是同一个类型, 抛出异常
     */
    private void checkValidityList() throws Exception{
        if(null == list){
            throw new Exception("请保证传入的List不为null");
        }
        int size = list.size();
        if(list.size() == 0){
            throw new Exception("请保证传入的List长度不为0");
        }
        for(int i = 1; i < size; i++){
            if(list.get(0).getClass() != list.get(i).getClass()){
                throw new Exception("请保证传入的List每项都是同一个类型");
            }
        }
        
    }
    
    
}

使用方法如下：
例如:
Student类(该类有属性name，age，isBoy，books等属性；其中books属性是一个List，存放Book对象)：

private String name;
private int age;
private boolean isBoy;
private List<Book> books;
//并实现getter和setter方法；

Book类(该类有属性name，author，number，length，width，isBorrowed等属性)：

private String name;
private String author;
private int number;
private float length;
private float width;
private boolean isBorrowed;
//并实现getter和setter方法；

现在有一个List<Student>类型的数据，通过以下代码把该List转换为xml：

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

//构建几个Student对象，放入list中
//……

//完整数据版（不使用includes和excludes）
JOXMLBuilder jOXMLBuilder = new JOXMLBuilder(list);
jOXMLBuilder.xmlBuild().toString();

//或者使用包括/排除：
JOXMLBuilder jOXMLBuilder = new JOXMLBuilder(list, new String[]{"name", "age"}, null);
jOXMLBuilder.xmlBuild().toString();

//或者使用方法链风格：
new JOXMLBuilder().setExcludes("name", "age").xmlBuild().toString();

转换之后的xml（完整数据版（不使用includes和excludes））：

<?xml version="1.0" encoding="utf-8"?>
<StudentAll>
        <Student>
                <name>hello</name>
                <age>23</age>
                <isBoy>true</isBoy>
                <BookAll>
                        <Book>
                                <name>book1</name>
                                <author>author1</author>
                                <number>123</number>
                                <length>23.5</length>
                                <width>18.0</width>
                                <isBorrowed>true</isBorrowed>
                        </Book>
                        <Book>
                                <name>book2</name>
                                <author>author2</author>
                                <number>43</number>
                                <length>42.23</length>
                                <width>30.57</width>
                                <isBorrowed>false</isBorrowed>
                        </Book>
                </BookAll>
        </Student>

        <Student>
                <name>world</name>
                <age>22</age>
                <isBoy>false</isBoy>
                <BookAll>
                         <Book>
                                <name>book1</name>
                                <author>author1</author>
                                <number>123</number>
                                <length>23.5</length>
                                <width>18.0</width>
                                <isBorrowed>true</isBorrowed>
                        </Book>
                        <Book>
                                <name>book3</name>
                                <author>author3</author>
                                <number>875</number>
                                <length>20.59</length>
                                <width>15.08</width>
                                <isBorrowed>false</isBorrowed>
                        </Book>
                        <Book>
                                <name>book4</name>
                                <author>author4</author>
                                <number>165</number>
                                <length>22.75</length>
                                <width>19.61</width>
                                <isBorrowed>true</isBorrowed>
                        </Book>
                </BookAll>
        </Student>
</StudentAll>