[工具庫]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
                                        }
                                ]
        }
]