javabean转换Json格式

/**
* Canary.com Inc.
* Copyright (c) 2004-2015 All Rights Reserved.
*/
package com.canary.mobilegw.test.biz.util;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.log4j.Logger;
import org.junit.Test;

import com.canary.mobilegw.javaapp.biz.xaesi.model.XaesiOrderGoodResInfo;

/**
*
* 规范:只能用于多行注释,get方法放在所有成员变量下面才能用
* 注:不支持单行注释的javabean文件
*
*/
public class JsonPatternConvertUtil {

private static final Logger logger   = Logger.getLogger(JsonPatternConvertUtil.class);

public String               filePath = "D:\\wzh_work\\iwutao_mobilegw\\branches\\mobilegw1.0(transport_debug)\\javaapp\\src\\main\\java\\com\\canary\\mobilegw\\javaapp\\biz\\xaesi\\model";

/**
 * javabean转换json格式
 */
@Test
public void convert() {
    XaesiOrderGoodResInfo obj = new XaesiOrderGoodResInfo();
    filePath += "\\XaesiOrderGoodResInfo.java";
    //获取所有成员变量的注释
    List<String> comments = getComments(filePath);
    //将javabean转换为Json格式
    getJsonBean(obj, comments);
}

/**
 * 将javabean转换为Json格式
 * 
 * @param object 任何对象
 * @param comments 成员变量的注释
 */
public static <T> void getJsonBean(T object, List<String> comments) {
    //获取对象
    Class<?> classType = object.getClass();
    try {
        Field[] fields = classType.getDeclaredFields();
        StringBuffer sb = new StringBuffer("{");
        for (int i = 0; i < fields.length; i++) {
            //获取成员变量名字
            String name = fields[i].getName();
            //字段类型
            String typeName = fields[i].getType().getName();
            //截取数据类型
            String[] dataType = typeName.split("\\.");

            sb.append("\"" + name + "\"" + ":" + dataType[dataType.length - 1] + "   "
                      + comments.get(i) + "\n");
        }
        sb.append("}");
        System.out.println(sb.toString());
    } catch (Exception e) {

    }
}

/**
 * 
 * @param filePath 文件路径
 * @return List(所有成员变量的注释)
 */
public static List<String> getComments(String filePath) {
    //成员变量的注释
    List<String> comments = null;
    try {
        FileReader freader = new FileReader(filePath);
        BufferedReader breader = new BufferedReader(freader);
        StringBuilder sb = new StringBuilder();
        try {
            String temp = "";
            /**
             * 读取文件内容，并将读取的每一行后都不加\n
             * 其目的是为了在解析双反斜杠（//）注释时做注释中止符
             */
            while ((temp = breader.readLine()) != null) {
                sb.append(temp);
                sb.append('\n');
            }
            String src = sb.toString();
            /**
             * 1、做/* 注释的正则匹配
             *

             *     通过渐进法做注释的正则匹配，因为/*注释总是成对出现
             * 当匹配到一个/*时总会在接下来的内容中会首先匹配到"*\\/",
             * 因此在获取对应的"*\\/"注释时只需要从当前匹配的/*开始即可，
             * 下一次匹配时只需要从上一次匹配的结尾开始即可
             * （这样对于大文本可以节省匹配效率）——
             * 这就是渐进匹配法
             *

             * */
            //从class开始
            Pattern beginIndex = Pattern.compile("class");
            Matcher beginmatcher = beginIndex.matcher(src);
            beginmatcher.find(0);//开始匹配

            //从Getter结束
            Pattern endIndex = Pattern.compile("Getter");
            Matcher endmatcher = endIndex.matcher(src);
            endmatcher.find(beginmatcher.start());//结束匹配
            //获取新的字符串内容
            src = src.substring(beginmatcher.start(), endmatcher.end() - 30);
            // System.out.println(src);

            //从/*开始获取内容
            Pattern leftpattern = Pattern.compile("/\\*");
            Matcher leftmatcher = leftpattern.matcher(src);
            //从*/结束获取内容
            Pattern rightpattern = Pattern.compile("\\*/");
            Matcher rightmatcher = rightpattern.matcher(src);

            sb = new StringBuilder();
            /**
             * begin 变量用来做渐进匹配的游标 {@value}
             * 初始值为文件开头
             * **/
            //成员变量的注释
            comments = new ArrayList<String>();
            int begin = 0;
            while (leftmatcher.find(begin)) {
                rightmatcher.find(leftmatcher.start());
                String varContent = "//"
                                    + src.substring(leftmatcher.start() + 3,
                                        rightmatcher.end() - 2).trim();
                sb.append(varContent);
                comments.add(varContent);
                /** 为输出时格式的美观 **/
                sb.append('\n');
                begin = rightmatcher.end();

            }
            //System.out.println(sb.toString());
            /**
             * 2、对//注释进行匹配（渐进匹配法）
             * 匹配方法是 // 总是与 \n 成对出现
             * */
            /*begin = 0;
            Pattern leftpattern1 = Pattern.compile("//");
            Matcher leftmatcher1 = leftpattern1.matcher(src);
            Pattern rightpattern1 = Pattern.compile("\n");
            Matcher rightmatcher1 = rightpattern1.matcher(src);
            sb = new StringBuilder();
            while (leftmatcher1.find(begin)) {
                rightmatcher1.find(leftmatcher1.start());
                sb.append(src.substring(leftmatcher1.start(), rightmatcher1.end()));
                begin = rightmatcher1.end();
            }
            System.out.println(sb.toString());*/
        } catch (IOException e) {
            System.out.println("文件读取失败");
        } finally {
            breader.close();
            freader.close();
        }
    } catch (FileNotFoundException e) {
        System.out.println("文件不存在");
    } catch (IOException e) {
        System.out.println("文件读取失败");
    }
    return comments;
}

}