JsonAnalyzer2 1.01版

本版的改进主要在字符串的处理,前版不允许出现[]{},:等,现在都可以了,做出的修改主要在Lexer类,另外Token类增加1了下标,TreeBuilder类的不合语法处也做出一定修改.

测试用例:https://www.cnblogs.com/heyang78/p/12956735.html

代码下载地址:https://files.cnblogs.com/files/heyang78/JsonAnalyzer2-20200525-2.zip

主要代码:

Token类,Json文本最终会被变成Token的链表:

package com.heyang;

/**
 * Tokens in json format
 * @author Heyang
 *
 */
public class Token {
    public static final int TYPE_OPEN_BRACE=0;        // {
    public static final int TYPE_CLOSE_BRACE=1;        // }
    public static final int TYPE_TEXT=2;            // text
    public static final int TYPE_COMMA=3;            // ,
    public static final int TYPE_COLON=4;            // :
    public static final int TYPE_OPEN_BRACKET=5;    // [
    public static final int TYPE_CLOSE_BRACKET=6;    // ]

    private int type;
    private String text;
    private int index;// Used to remember location

    public Token(char c,int type) {
        this.text=String.valueOf(c);
        this.type=type;
    }

    public Token(String word,int type) {
        this.text=word;
        this.type=type;
    }

    public String toString() {
        return String.format("token(text=%s,type=%d,index=%d)", text,type,index);
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }
}

Lexer类,此类用于将json文本分成token:

package com.heyang;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang.StringUtils;

/**
 * Parse json string to tokens
 * @author Heyang
 *
 */
public class Lexer {
    private List<Token> tokens;

    public Lexer(String jsonTxt) {
        tokens = new ArrayList<Token>();

        String bundle = "";
        for (int i = 0; i < jsonTxt.length(); i++) {
            char c = jsonTxt.charAt(i);

            if(c==':') {
                char t=c;
                char p=t;
                c=p;
            }

            if (Character.isWhitespace(c)) {
                continue;
            } else if (c == '{') {
                tokens.add(new Token(c, Token.TYPE_OPEN_BRACE));
            } else if (c == '}') {
                if (StringUtils.isNotEmpty(bundle)) {
                    tokens.add(new Token(bundle, Token.TYPE_TEXT));
                    bundle = "";
                }

                tokens.add(new Token(c, Token.TYPE_CLOSE_BRACE));
            } else if (c == '[') {
                tokens.add(new Token(c, Token.TYPE_OPEN_BRACKET));
            } else if (c == ']') {
                if (StringUtils.isNotEmpty(bundle)) {
                    tokens.add(new Token(bundle, Token.TYPE_TEXT));
                    bundle = "";
                }

                tokens.add( new Token(c, Token.TYPE_CLOSE_BRACKET));
            } else if (c == ',') {
                if (StringUtils.isNotEmpty(bundle)) {
                    tokens.add(new Token(bundle, Token.TYPE_TEXT));
                    bundle = "";
                }

                tokens.add(new Token(c, Token.TYPE_COMMA));
            } else if (c == ':') {
                if (StringUtils.isNotEmpty(bundle)) {
                    tokens.add(new Token(bundle, Token.TYPE_TEXT));
                    bundle = "";
                }

                tokens.add(new Token(c, Token.TYPE_COLON));
            }else if(c == '\"') {
                int idx=i+1;

                while(idx<jsonTxt.length()) {
                    char cEnd = jsonTxt.charAt(idx);

                    if (cEnd == '\"') {
                        break;
                    }

                    idx++;
                }

                String sub=jsonTxt.substring(i, idx+1);
                tokens.add(new Token(sub, Token.TYPE_TEXT));
                i=idx;
            } else {
                bundle += c;
            }
        }

        setTokenIndexes();
    }

    public void setTokenIndexes() {
        int idx = 0;
        for (Token t : tokens) {
            idx++;
            t.setIndex(idx);
        }
    }

    public void printTokens() {
        int idx = 0;
        for (Token t : tokens) {
            idx++;
            t.setIndex(idx);
            System.out.println("#" + idx + " " + t.getText());
        }
    }

    public String getCompactJsonTxt() {
        StringBuilder sb=new StringBuilder();

        for (Token t : tokens) {
            sb.append(t.getText());
        }

        return sb.toString();
    }

    public List<Token> getTokenList() {
        return tokens;
    }
}

Node类,代表json节点:

package com.heyang;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

/**
 * Json Node
 * @author Heyang
 *
 */
public class Node implements Comparable<Node>{

    // There are value types
    public static final int Type_String=1;
    public static final int Type_Array=2;
    public static final int Type_List=3;

    // Key always is String
    private String key;
    private Node parent;

    // There are three types of value
    private int valueType;
    private String valueString;
    private List<Node> valueList;

    // indent depth
    private int depth;

    public Node() {

    }

    public Node(String key,String value) {
        this.key=key;
        this.valueType=Type_String;
        this.valueString=value;
        this.depth=0;
    }

    public Node(String key,int type) {
        this.key=key;
        this.valueType=type;
        this.valueList=new LinkedList<Node>();
    }

    public void addChild(Node child) {
        if(valueList!=null) {
            valueList.add(child);
            child.parent=this;

            adjustDepth();
        }
    }

    private void adjustDepth() {
        if(valueType==Type_List || valueType==Type_Array) {
            for(Node json:valueList) {
                json.depth=this.depth+1;
                json.adjustDepth();
            }
        }
    }

    public String toString() {
        StringBuilder sb=new StringBuilder();

        // key
        String tabs=getIndentSpace();
        sb.append(tabs);

        if(key!=null) {
            sb.append(key);
            sb.append(":");
        }

        // value
        if(valueType==Type_String) {
            sb.append(valueString);
        }else if(valueType==Type_Array) {
            sb.append("[\n");

            int n=valueList.size();
            for(int i=0;i<n;i++) {
                Node json=valueList.get(i);
                if(i!=n-1) {
                    sb.append(json.toString()+",\n");
                }else {
                    sb.append(json.toString()+"\n");
                }
            }

            sb.append(tabs+"]");
        }else if(valueType==Type_List) {
            sb.append("{\n");

            Collections.sort(valueList);

            int n=valueList.size();
            for(int i=0;i<n;i++) {
                Node json=valueList.get(i);
                if(i!=n-1) {
                    sb.append(json.toString()+",\n");
                }else {
                    sb.append(json.toString()+"\n");
                }
            }

            sb.append(tabs+"}");
        }

        return sb.toString();
    }

    public int compareTo(Node other) {
        return this.key.compareTo(other.key);
    }

    private String getIndentSpace() {
        return String.join("", Collections.nCopies(this.depth, "    "));
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public Node getParent() {
        return parent;
    }

    public void setParent(Node parent) {
        this.parent = parent;
    }

    public List<Node> getValueList() {
        return valueList;
    }
}

TreeBuilder类,用于构建一棵Node节点树:

package com.heyang;

import java.util.List;

public class TreeBuilder {
    private Node root;
    private List<Token> tokens;
    private int tokenIdx;

    public TreeBuilder(List<Token> tokens)  throws Exception{
        this.tokens=tokens;
        this.tokenIdx=0;

        root=new Node(null,Node.Type_List);
        parse_object(root);
    }

    private void parse_object(Node parent) throws Exception{
        Token token;

        token=fetchToken();
        if(token.getType()!=Token.TYPE_OPEN_BRACE) {
            throw new Exception("Expected:'{' actual:"+token.getText()+" "+token);
        }

        for(;;) {
            token=fetchToken();
            if(token.getType()!=Token.TYPE_TEXT) {
                returnToken();
                break;
            }
            String key=token.getText();

            token=fetchToken();
            if(token.getType()!=Token.TYPE_COLON) {
                throw new Exception("Expected:':' actual:"+token.getText()+" "+token);
            }

            token=fetchToken();
            if(token.getType()==Token.TYPE_TEXT) {
                String value=token.getText();
                parent.addChild(new Node(key,value));
            }else if(token.getType()==Token.TYPE_OPEN_BRACE){
                Node node=new Node(key,Node.Type_List);
                parent.addChild(node);
                returnToken();
                parse_object(node);
            }else if(token.getType()==Token.TYPE_OPEN_BRACKET) {
                Node node=new Node(key,Node.Type_Array);
                parse_array(node);
                parent.addChild(node);
            }else {
                throw new Exception("value should be string/object/array but not.");
            }

            token=fetchToken();
            if(token.getType()==Token.TYPE_COMMA) {
                continue;
            }else {
                returnToken();
                break;
            }
        }

        token=fetchToken();
        if(token.getType()!=Token.TYPE_CLOSE_BRACE) {
            throw new Exception("Expected:'}' actual:"+token.getText()+" "+token);
        }
    }

    private void parse_array(Node parent) throws Exception {
        Token token;

        for(;;) {
            token=fetchToken();
            if(token.getType()==Token.TYPE_TEXT) {
                String value=token.getText();
                Node node=new Node(null,value);
                parent.addChild(node);
            }else if(token.getType()==Token.TYPE_OPEN_BRACE) {
                Node node=new Node(null,Node.Type_List);
                parent.addChild(node);

                returnToken();
                parse_object(node);
            }else {
                returnToken();
            }

            token=fetchToken();
            if(token.getType()==Token.TYPE_COMMA) {
                continue;
            }else {
                returnToken();
                break;
            }
        }

        token=fetchToken();
        if(token.getType()!=Token.TYPE_CLOSE_BRACKET) {
            throw new Exception("Expected:']' actual:"+token.getText()+" "+token);
        }
    }

    private Token fetchToken() {
        if(tokenIdx>=tokens.size()) {
            return null;
        }else {
            Token t=tokens.get(tokenIdx);
            tokenIdx++;
            return t;
        }
    }

    private void returnToken() {
        if(tokenIdx>0) {
            tokenIdx--;
        }
    }

    public Node getRoot() {
        return root;
    }
}

运行起来:

package com.heyang;

import com.heyang.util.BracketChecker;
import com.heyang.util.CommonUtil;
import com.heyang.util.Renderer;

public class EntryPoint {
    public static void main(String[] args) {
        try {
            // Read context from file
            String jsonTxt=CommonUtil.readTextFromFile("C:\\hy\\files\\json\\01.json");
            System.out.println("原文="+jsonTxt);

            // Is brackets balanced
            BracketChecker checker=new BracketChecker();
            boolean isBalanced=checker.isBalanced(jsonTxt);
            if(isBalanced==false) {
                System.out.println(Renderer.paintBrown(checker.getErrMsg()));
                return;
            }

            // Parse json to tokens
            Lexer lex=new Lexer(jsonTxt);
            //System.out.println("紧缩文本="+lex.getCompactJsonTxt());
            //lex.printTokens();

            // Build tree
            TreeBuilder builder=new TreeBuilder(lex.getTokenList());
            Node root=builder.getRoot();
            System.out.println("内部排序后文本:\n"+root);
        }catch(Exception ex) {
            System.out.println(Renderer.paintBrown(ex.getMessage()));
            ex.printStackTrace();
        }
    }
}

运行效果:

原文={    "type": "object",    "properties": {        "first_name": { "type": "string" },        "last_name": { "type": "string" },        "age": { "type": "integer" },        "club": {            "type": "object",            "properties": {                "name": { "type": "string" },                "founded": { "type": "integer" }            },            "required": ["name"]        }    },    "required": ["first_name", "last_name", "age", "club"]}
内部排序后文本:
{
    "properties":{
        "age":{
            "type":"integer"
        },
        "club":{
            "properties":{
                "founded":{
                    "type":"integer"
                },
                "name":{
                    "type":"string"
                }
            },
            "required":[
                "name"
            ],
            "type":"object"
        },
        "first_name":{
            "type":"string"
        },
        "last_name":{
            "type":"string"
        }
    },
    "required":[
        "first_name",
        "last_name",
        "age",
        "club"
    ],
    "type":"object"
}

--2020年5月25日--