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

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

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

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

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

 

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

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

 

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

源码如下：

package com.wangjie.extrautil.jojsonbuilder;

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-14 上午10:49:59
 */
public class JOJSONBuilder {
    private List<?> list; // 传入的List数据
    private StringBuilder result = null;
    private List<String> includes = null; // 要包含的属性列表
    private List<String> excludes = null; // 要排除的属性列表
    
    /**
     * 默认构造方法。<br>
     * 使用此默认的构造方法之后必须要调用setList()传入List
     */
    public JOJSONBuilder() {
        
    }
    /**
     * 此构造方法会把list中每项的所有属性信息都会生成在json中。
     * @param list 所要生成Json的List数据源
     */
    public JOJSONBuilder(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中每项的所有属性信息都会生成在json中
     * </ol>
     * @param list 所要生成Json的List数据源。
     * @param includes 所要包含的属性名称数组。
     * @param excludes 所要排除的属性名称数组。
     */
    public JOJSONBuilder(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);
    }
    /**
     * 获得正在进行生成json文件的信息来源List。
     * @author wangjie
     * @return 返回正在进行生成json文件的信息来源List
     */
    public List<?> getList() {
        return list;
    }
    /**
     * 可使用此方法来传入、替换JOJSONBuilder对象中的List对象。
     * @author wangjie
     * @param list 所要生成Json的List数据源。
     * @return 返回当前JOJSONBuilder对象
     */
    public JOJSONBuilder setList(List<?> list) {
        this.list = list;
        return this;
    }
    /**
     * 设置包含的属性信息。
     * @author wangjie
     * @param incFieldName 要包含的属性名
     * @return 返回当前JOJSONBuilder对象
     */
    public JOJSONBuilder setIncludes(String... incFieldName) {
        this.includes = null == incFieldName || incFieldName.length == 0 ? null : Arrays.asList(incFieldName);
        return this;
    }
    /**
     * 设置排除的属性信息。
     * @author wangjie
     * @param excFieldName 要排除的属性名
     * @return 返回当前JOJSONBuilder对象
     */
    public JOJSONBuilder setExcludes(String... excFieldName) {
        this.excludes = null == excFieldName || excFieldName.length == 0 ? null : Arrays.asList(excFieldName);
        return this;
    }
    /**
     * 获得指定Class类型的所有属性，并打印在控制台上。
     * @author wangjie
     * @param clazz 要获取的属性的类的Class对象。
     * @return 返回该Class对象的所有属性。
     */
    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中的对象来生成对应的json文件。
     * @author wangjie
     * @return 返回生成的Json字符串。
     * @throws Exception 如果List检验不通过，则抛出异常。
     */
    public StringBuilder jsonBuild() throws Exception{
        //检验传入的List是否有效
        checkValidityList();
        //json文件开始生成-------------------------
        result = new StringBuilder();
        jsonSubBuild(list); // 递归生成
        return result;
    }
    /**
     * 生成json可递归部分的子数据（根据某些对象组成的List来生成属性json文件）
     * @author wangjie
     * @param list 
     */
    private void jsonSubBuild(List<?> list){
//        Class<?> clazz = list.get(0).getClass(); // 获取对应的Class对象
        Object curObj = null; // 每次循环当前的类对象（资源）
        int listLength = list.size(); // 类对象个数
//        String simpleName = clazz.getSimpleName(); // 获取类名（不含包名）
        
        result.append("["); // 根标签开始
        
        for(int i = 0; i < listLength; i++){
            if(i != 0){
                result.append(",");
            }
            curObj = list.get(i);
            jsonSubSubBuild(curObj, list); // 子数据递归
        }
        
        result.append("]"); // 根标签结束
    }
    /**
     * 生成json可递归部分的子子数据（根据某个对象来生成属性json文件）
     * @author wangjie
     * @param curObj 要生成json文件的那个对象 
     * @param list curObj参数属于的那个List
     */
    private void jsonSubSubBuild(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; // 类对象的属性数量
        
        result.append("{");
        int offset = 0; // 包含的第一个属性偏移量
        int temp = 0;
        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;
                    }
                }
                // 记录第一个包含的属性的索引
                if(0 == temp){
                    offset = j;
                    temp++;
                }
//                offset = 0 == temp++ ? j : 0;
            }
            
            methodName = getGetterMethodNameByFieldName(fields[j]);
            try {
                method = clazz.getDeclaredMethod(methodName, new Class[]{});
                method.setAccessible(true);
                value = method.invoke(curObj, new Object[]{});
                //*********************************************************
                if(j != offset){ // 第一个属性前面不加","
                    result.append(",");
                }
                result.append("'" + fieldName + "':");
                if(fields[j].getType() == List.class){ // 如果属性是List类型
                    List<?> subList = (List<?>)value;
                    jsonSubBuild(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());
                    }
                    jsonSubBuild(subList); // 子数据递归
                }
                // 如果ClassLoader不是null表示该类不是启动类加载器加载的，不是Java API的类，是自己写的java类
                else if(null != fields[j].getType().getClassLoader()){ 
                    jsonSubSubBuild(value, null); // 子子数据递归
                }
                else{ // 其它类型都认为是普通文本类型
                    // 添加子元素（类属性）标签
                    if(value.getClass() == String.class){
                        result.append("'" + value + "'");
                    }else{
                        result.append(value.toString());
                    }
                    
                }
                
                //*********************************************************
            } catch (Exception e) {
                e.printStackTrace();
            }
            
        }
        result.append("}");
    }
    
    /**
     * <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转换为Json：

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

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

//完整数据版（不使用includes和excludes）
JOJSONBuilder jsonBuilder = new JOJSONBuilder(list);
String content = jsonBuilder.jsonBuild().toString();

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

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

 

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

[
        {
                'name':'hello',
                'age':23,
                'isBoy':true,
                'books':[
                                        {
                                                'name':'book1',
                                                'author':'author1',
                                                'number':123,
                                                'length':23.5,
                                                'width':18.0,
                                                'isBorrowed':true
                                        },
                                        {
                                                'name':'book2',
                                                'author':'author2',
                                                'number':43,
                                                'length':42.23,
                                                'width':30.57,
                                                'isBorrowed':false
                                        }
                                ]
        },

        {
                'name':'world',
                'age':22,
                'isBoy':false,
                'books':[
                                        {
                                                'name':'book1',
                                                'author':'author1',
                                                'number':123,
                                                'length':23.5,
                                                'width':18.0,
                                                'isBorrowed':true
                                        },
                                        {
                                                'name':'book3',
                                                'author':'author3',
                                                'number':875,
                                                'length':20.59,
                                                'width':15.08,
                                                'isBorrowed':false
                                        },
                                        {
                                                'name':'book4',
                                                'author':'author4',
                                                'number':165,
                                                'length':22.75,
                                                'width':19.61,
                                                'isBorrowed':true
                                        }
                                ]
        }
]