Json相关工具类

Json工具类：

package com.zhihua.Json;

import java.lang.reflect.Type;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.google.gson.Gson;
import com.zhihua.string.StringUtils;

/**
 * Json相关工具类
 * <请替换成功能描述> <br>
 * <请替换成详细描述>
 * @author caizh
 * @since [1.0.0]
 * @version [1.0.0,2017年2月13日]
 */
public class JsonUtils {

    private static final Gson gson = new Gson();

    /**
     * 
     * <请替换成功能描述> <br>
     * <请替换成详细描述>
     * @param obj
     * @return
     * @author caizh
     * @since [1.0.0]
     * @version [1.0.0,2017年2月13日]
     */
    public static String toJson(Object obj){
        return gson.toJson(obj);
    }

    /**
     * 反序列化对象
     * <请替换成功能描述> <br>
     * <请替换成详细描述>
     * @param json
     * @param clazz
     * @return
     * @author caizh
     * @since [1.0.0]
     * @version [1.0.0,2017年2月13日]
     */
    public static <T> T fromJson(String json,Class<T> clazz){
        return gson.fromJson(json, clazz);
    }

    /**
     * 反序列化对象
     * <请替换成功能描述> <br>
     * <请替换成详细描述>
     * @param json
     * @param type
     * @return
     * @author caizh
     * @since [1.0.0]
     * @version [1.0.0,2017年2月13日]
     */
    public static Object fromJson(String json,Type type){
        return gson.fromJson(json, type);
    }

    /**
     * 验证一个字符串是否是合法的JSON 串
     * <请替换成功能描述> <br>
     * <请替换成详细描述>
     * @param json 要验证的字符串
     * @return
     * @author caizh
     * @since [1.0.0]
     * @version [1.0.0,2017年2月13日]
     */
    public static boolean validate(String json){
        return (new JsonValidator()).validate(json);
    }

    /**
     * 检验是否为get方式提交的参数
     * <请替换成功能描述> <br>
     * <请替换成详细描述>
     * @param paras
     * @return
     * @author caizh
     * @since [1.0.0]
     * @version [1.0.0,2017年2月13日]
     */
    public static boolean validateModel(String paras){
        return Pattern.compile("\\w*[^&=]*=\\w*[^&=]*&?").matcher(paras).find();
    }

    /**
     * 格式化为json格式
     * <请替换成功能描述> <br>
     * <请替换成详细描述>
     * @param result
     * @return
     * @author caizh
     * @since [1.0.0]
     * @version [1.0.0,2017年2月13日]
     */
    public static String fmtToJson(String result){
        if(validate(result)){
            return result;
        }
        result = result.replaceAll(">\\s*<", "><").replaceAll("<\\?([^>|^\\?]*)\\?>", "");
        String json = result;
        Matcher matcher = Pattern.compile("<([^>|^/]*)>").matcher(result);
        while(matcher.find()){
            for(int i=0;i<matcher.groupCount();i++){
                String s = matcher.group(i+1);
                json = json.replaceAll("<"+s+">([^<|^\"]*)</"+s+">", "\""+s+"\":\"$1\",");
            }
        }
        json = "{"+json.replaceAll(",?</([^<]*)>", "},").replaceAll("<([^<]*)>", "\"$1\":{")+"}";
        json =json.replaceAll(",}","}").replaceAll("(\\s*\\w*)=\"(\\w*)\"\\s*\"?", "\"$1\":\"$2\",")
                .replaceAll("\\s+([^{]*),:" ,  ":{\"@attributes\":{\"$1},").replace("},{", "},")
                .replaceAll("},([^}|^\"]*)}", "},\"@value\":\"$1\"}");
        return json;
    }

    /**
     * 格式化为XML格式
     * <请替换成功能描述> <br>
     * <请替换成详细描述>
     * @param json
     * @return
     * @author caizh
     * @since [1.0.0]
     * @version [1.0.0,2017年2月13日]
     */   
    public static String fmtToXml(String json){
        return fmtToXml(json,"root");
    }

    private static String fmtToXml(String json, String rootEle) {
        if(!validate(json)){
            return fmtToXml(fmtToJson(json),rootEle);
        }
        rootEle = rootEle.replaceAll("\\W", "");
        rootEle = StringUtils.isNullOrEmpty(rootEle)? "root": rootEle;
        //去掉@attributes和@value
        Pattern pattern = Pattern.compile("\"@attributes\":\\{([^}]*)}");
        Matcher matcher = pattern.matcher(json);
        while(matcher.find()){
            String s = "";
            for (int i = 0; i < matcher.groupCount(); i++) {
                s = matcher.group(i+1);
                s = s.replaceAll("\"(\\w*)\":\"([^\"]*)\",?", " $1=$2");
            }
            json = json.replaceAll("[^,]\"(\\w*)\":\\{\"@attributes\":\\{[^}]*},?","{\"$1"+s+"\":{");
            //matcher = pattern.matcher(json);
        }
        json = json.replaceAll("\\{\"@value\":\"([^\"]*)\"}", "\"$1\"");

        //处理嵌套
        json = json.replaceAll("\"([\\w|\\s|=]*)\":\"([^\",{}]+)\",?", "<$1>$2</$1>");
        pattern = Pattern.compile("\"(\\w*)\":\\{([^{}]*)},?");
        while(pattern.matcher(json).find()){
            json = pattern.matcher(json).replaceAll("<$1>$2</$1>");
        }

        pattern = Pattern.compile("\"([\\w|\\s|=]*)\":([^}\"]*)},?");
        while(pattern.matcher(json).find()){
            json = pattern.matcher(json).replaceAll("<$1>$2</$1>");
        }

        json = json.replaceAll("(\\w*)=(\\w*)", "$1=\"$2\"").replaceAll("/(\\w*)\\s[\\w*)=\"\\w*\"\\s?]*", "/$1").replaceAll("[{|}]", "");
        json = "<?xml version=\"1.0\" ?><"+rootEle+">"+json+"</"+rootEle+">";
        return json;
    }

    public static void main(String[] args) {
        String str = "<Response a=\"123\" b=\"000\">"
                + "<status  c=\"123\" d=\"000\">201</status>"
                + "<A><status1>201</status1><message1>APP被用户自己禁用</message1></A>"
                + "<A2><status1>201</status1><message1>APP被用户自己禁用</message1></A2>"
                + "<B>"
                + " <BB><status1>201</status1><message1>APP被用户自己禁用</message1></BB>"
                + "</B>"
                + "<message>APP被用户自己禁用，请在控制台解禁</message>"
                + "<C><status1>201</status1><message1>APP被用户自己禁用</message1></C>"
                + "</Response>";

        String json = fmtToJson(str);
        String xml = fmtToXml(json);
        System.out.println("xml转化为json：" + json);
        System.out.println("json转化为xml：" + xml);
    }
}

json格式校验类：

package com.zhihua.Json;

import java.text.CharacterIterator;
import java.text.StringCharacterIterator;

/**
 * json格式校验类
 * <请替换成功能描述> <br>
 * <请替换成详细描述>
 * @author caizh
 * @since [1.0.0]
 * @version [1.0.0,2017年2月13日]
 */
public class JsonValidator {

    private CharacterIterator it;
    private char c;
    private int col;

    public JsonValidator(){

    }

    /**
     * 验证一个字符串是否是合法的JSON串
     * <请替换成功能描述> <br>
     * <请替换成详细描述>
     * @param input
     * @return
     * @author caizh
     * @since [1.0.0]
     * @version [1.0.0,2017年2月13日]
     */
    public boolean validate(String input){
        input = input.trim();
        boolean ret = valid(input);
        return ret;
    }

    private boolean valid(String input) {
        if("".equals(input))
            return true;
        boolean ret = true;
        it = new StringCharacterIterator(input);
        c = it.first();
        col = 1;
        if(!value()){
            ret = error("value",1);
        }else{
            skipWhiteSpace();
            if(c!=CharacterIterator.DONE){
                ret = error("end",col);
            }
        }
        return ret;
    }

    private boolean value() {
        return literal("true") || literal("false") || literal("null") || string() || number() || object() || array();
    }

    private boolean number() {
        if(!Character.isDigit(c) && c!='-'){
            return false;
        }
        int start = col;
        if(c=='-')
            nextCharacter();
        else if(Character.isDigit(c)){
            while(Character.isDigit(c)){
                nextCharacter();
            }
        }else{
            return error("number",start);
        }
        if(c == '.'){
            nextCharacter();
            if(Character.isDigit(c)){
                while(Character.isDigit(c)){
                    nextCharacter();
                }
            }else{
                return error("number",start);
            }
        }
        if (c == 'e' || c == 'E') {
            nextCharacter();
            if (c == '+' || c == '-') {
                nextCharacter();
            }
            if (Character.isDigit(c)) {
                while (Character.isDigit(c))
                    nextCharacter();
            } else {
                return error("number", start);
            }
        }
        return false;
    }

    private boolean object() {
        return aggregate('{', '}', true);
    }

    private boolean array() {
        return aggregate('[', ']', false);
    }

    private boolean aggregate(char entryCharacter, char exitCharacter, boolean prefix) {
        if(c!=entryCharacter)
        {
            return false;
        }
        nextCharacter();
        skipWhiteSpace();
        if(c==exitCharacter){
            nextCharacter();
            return true;
        }
        for(;;){
            if(prefix){
                int start = col;
                if(!string())
                    return error("string", start);
                skipWhiteSpace();
                if (c != ':') 
                    return error("colon", col);
                nextCharacter();
                skipWhiteSpace();
            }
            if(value()){
                skipWhiteSpace();
                if (c == ',') {
                    nextCharacter();
                } else if (c == exitCharacter) {
                    break;
                } else {
                    return error("comma or " + exitCharacter, col);
                } 
            }else{
                return error("value",col);
            }
            skipWhiteSpace();
        }
        nextCharacter();
        return true;
    }

    private boolean string() {

        if (c != '"') 
            return false;
        int start = col;
        boolean escaped = false;
        for (nextCharacter(); c != CharacterIterator.DONE; nextCharacter()) {
            if (!escaped && c == '\\') {
                escaped = true;
            } else if (escaped) {
                if (!escape()) {
                    return false;
                }
                escaped = false;
            } else if (c == '"') {
                nextCharacter();
                return true;
            }
        }
        return error("quoted string", start);
    }

    private boolean escape() {
        int start = col - 1;
        if (" \\\"/bfnrtu".indexOf(c) < 0) {
            return error("escape sequence  \\\",\\\\,\\/,\\b,\\f,\\n,\\r,\\t  or  \\uxxxx ", start);
        }
        if (c == 'u') {
            if (!ishex(nextCharacter()) || !ishex(nextCharacter()) || !ishex(nextCharacter())
                    || !ishex(nextCharacter())) {
                return error("unicode escape sequence  \\uxxxx ", start);
            }
        }
        return true;
    }

    private boolean ishex(char nextCharacter) {
        return "0123456789abcdefABCDEF".indexOf(c) >= 0;
    }

    private boolean literal(String text) {
        CharacterIterator ci = new StringCharacterIterator(text);
        char t = ci.first();
        if(c!=t){
            return false;
        }
        int start = col;
        boolean ret = true;
        for (t = ci.next(); t != CharacterIterator.DONE; t = ci.next()) {
            if (t != nextCharacter()) {
                ret = false;
                break;
            }
        }
        nextCharacter();
        if(!ret){
            error("literal " + text, start);
        }
        return ret;
    }

    private char nextCharacter() {
        c = it.next();
        ++col;
        return c;
    }

    private void skipWhiteSpace() {
        while (Character.isWhitespace(c)) {
            nextCharacter();
        }
    }

    private boolean error(String type, int col) {
        System.out.printf("type: %s, col: %s%s", type, col, System.getProperty("line.separator"));
        return false;
    }

    public static void main(String[] args) {
        String jsonStr = "{\"website\":\"oschina.net\"}";
        System.out.println(new JsonValidator().validate(jsonStr));
    }
}