簡單語法解析器實現參考

　　有時候，我們為了遮蔽一些底層的差異，我們會要求上游系統按照某種約定進行傳參。而在我們自己的系統層則會按照具體的底層協議進行適配，這是通用的做法。但當我們要求上游系統傳入的引數非常複雜時，也許我們會有一套自己的語法定義，用以減輕所有引數的不停變化。比如sql協議，就是一個一級棒的語法，同樣是呼叫底層功能，但它可以很方便地讓使用者傳入任意的引數。

　　如果我們自己能夠實現一套類似的東西，想來應該蠻有意思的。

　　不過，我們完全沒有必要要實現一整套完整的東西，我們只是要體驗下這個語法解析的過程，那就好辦了。本文就來給個簡單的解析示例，供看官們參考。

 

1. 實現目標描述

　　目標：

　　　　基於我們自定義的一套語法，我們要實現一套類似於sql解析的工具，它可以幫助我們檢查語法錯誤、應對底層不同的查詢引擎，比如可能是 ES, HIVE, SPARK, PRESTO...  即我們可能將使用者傳入的語法轉換為任意種目標語言的語法，這是我們的核心任務。

　　前提：

　　　　為簡單化起見，我們並不想實現一整套的東西，我們僅處理where條件後面的東西。
　　定義：
　　　　$1234: 定義為欄位資訊, 我們可以通過該欄位查詢出一些更多的資訊;
　　　　and/or/like...: 大部分時候我們都遵循sql語法, 含義一致;
　　　　#{xxx}: 系統關鍵字定義格式, xxx 為具體的關鍵字;
　　　　arr['f1']: 為陣列格式的欄位;

　　示例：

　　　　$15573 = 123 and (my_udf($123568, $82949) = 1) or $39741 = #{day+1} and $35289 like '%ccc'
　　　　將會被翻譯成ES:(更多資訊的欄位替換請忽略)
　　　　$15573 = 123 and ( $123568 = 1 ) or $39741 = '2020-10-07' and $35289 like '%ccc'

　　實際上整個看下來，和一道普通的演算法題差不太多呢。但實際想要完整實現這麼個小東西，也是要費不少精力的。

 

2. 整體實現思路

　　我們要做一個解析器，或者說翻譯器，首先第一步，自然是要從根本上理解原語義，然後再根據目標語言的表達方式，轉換過去就可以了。

　　如果大家有看過一些編譯原理方面的書，就應該知道，整個編譯流程大概分為: 詞法分析；語法分析；語義分析；中間程式碼生成；程式碼優化；目的碼； 這麼幾個過程，而每個過程往往又是非常複雜的，而最複雜的往往又是其上下文關係。不過，我們不想搞得那麼複雜（也搞不了）。

　　雖然我們不像做一個編譯器一樣複雜，但我們仍然可以參考其流程，可以為我們提供比較好的思路。

　　我們就主要做3步就可以了：1. 分詞；2. 語義分析； 3. 目的碼生成；而且為了進一步簡化工作，我們省去了複雜的上下文依賴分析，我們假設所有的語義都可以從第一個關鍵詞中獲得，比如遇到一個函式，我就知道接下來會有幾個引數出現。而且我們不處理巢狀關係。

　　所以，我們的工作就變得簡單起來。

 

3. 具體程式碼實現

　　我們做這個解析器的目的，是為了讓呼叫者方便，它僅僅作為一個工具類存在，所以，我們需要將入口做得非常簡單。

　　這裡主要為分為兩個入口：1. 傳入原始語法，返回解析出的語法樹； 2. 呼叫語法樹的translateTo 方法，將原始語法轉換為目標語法；

具體如下：

    
import com.my.mvc.app.common.helper.parser.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import java.util.*;

/**
 * 功能描述: 簡單語法解析器實現示例
 *
 */
@Slf4j
public class SimpleSyntaxParser {

    /**
     * 嚴格模式解析語法
     *
     * @see #parse(String, boolean)
     */
    public static ParsedClauseAst parse(String rawClause) {
        return parse(rawClause, true);
    }

    /**
     * 解析傳入詞為db可識別的語法
     *
     * @param rawClause 原始語法, 如:
     *                  $15573 = 123 and (my_udf($123568, $82949) = 1) or $39741 like '%abc%' (my_udf($35289)) = -1
     * @param strictMode 是否是嚴格模式, true:是, false:否
     * @return 解析後的結構
     */
    public static ParsedClauseAst parse(String rawClause, boolean strictMode) {
        log.info("開始解析: " + rawClause);
        List<TokenDescriptor> tokens = tokenize(rawClause, strictMode);
        Map<String, Object> idList = enhanceTokenType(tokens);
        return buildAst(tokens, idList);
    }

    /**
     * 構建抽象語法樹物件
     *
     * @param tokens 分詞解析出的tokens
     * @param idList id資訊（解析資料來源參照）
     * @return 構建好的語法樹
     */
    private static ParsedClauseAst buildAst(List<TokenDescriptor> tokens,
                                            Map<String, Object> idList) {
        List<SyntaxStatement> treesFlat = new ArrayList<>(tokens.size());
        Iterator<TokenDescriptor> tokenItr = tokens.iterator();
        while (tokenItr.hasNext()) {
            TokenDescriptor token = tokenItr.next();
            String word = token.getRawWord();
            TokenTypeEnum tokenType = token.getTokenType();
            SyntaxStatement branch;
            switch (tokenType) {
                case FUNCTION_SYS_CUSTOM:
                    String funcName = word.substring(0, word.indexOf('(')).trim();
                    SyntaxStatementHandlerFactory handlerFactory
                            = SyntaxSymbolTable.getUdfHandlerFactory(funcName);
                    branch = handlerFactory.newHandler(token, tokenItr, tokenType);
                    treesFlat.add(branch);
                    break;
                case KEYWORD_SYS_CUSTOM:
                    branch = SyntaxSymbolTable.getSysKeywordHandlerFactory()
                                .newHandler(token, tokenItr, tokenType);
                    treesFlat.add(branch);
                    break;
                case KEYWORD_SQL:
                    branch = SyntaxSymbolTable.getSqlKeywordHandlerFactory()
                                .newHandler(token, tokenItr, tokenType);
                    treesFlat.add(branch);
                    break;
                case WORD_NORMAL:
                case WORD_NUMBER:
                case WORD_STRING:
                case CLAUSE_SEPARATOR:
                case SIMPLE_MATH_OPERATOR:
                case WORD_ARRAY:
                case COMPARE_OPERATOR:
                case FUNCTION_NORMAL:
                case ID:
                case FUNCTION_SQL:
                default:
                    // 未解析的情況，直接使用原始值解析器處理
                    branch = SyntaxSymbolTable.getCommonHandlerFactory()
                                .newHandler(token, tokenItr, tokenType);
                    treesFlat.add(branch);
                    break;
            }
        }
        return new ParsedClauseAst(idList, treesFlat);
    }

    /**
     * 語義增強處理
     *
     *      加強token型別描述，並返回 id 資訊
     */
    private static Map<String, Object> enhanceTokenType(List<TokenDescriptor> tokens) {
        Map<String, Object> idList = new HashMap<>();
        for (TokenDescriptor token : tokens) {
            String word = token.getRawWord();
            TokenTypeEnum newTokenType = token.getTokenType();
            switch (token.getTokenType()) {
                case WORD_NORMAL:
                    if(word.startsWith("$")) {
                        newTokenType = TokenTypeEnum.ID;
                        idList.put(word, word.substring(1));
                    }
                    else if(StringUtils.isNumeric(word)) {
                        newTokenType = TokenTypeEnum.WORD_NUMBER;
                    }
                    else {
                        newTokenType = SyntaxSymbolTable.keywordTypeOf(word);
                    }
                    token.changeTokenType(newTokenType);
                    break;
                case WORD_STRING:
                    // 被引號包圍的關鍵字，如 '%#{monthpart}%'
                    String innerSysCustomKeyword = readSplitWord(
                            word.toCharArray(), 1, "#{", "}");
                    if(innerSysCustomKeyword.length() > 3) {
                        newTokenType = TokenTypeEnum.KEYWORD_SYS_CUSTOM;
                    }
                    token.changeTokenType(newTokenType);
                    break;
                case FUNCTION_NORMAL:
                    newTokenType = SyntaxSymbolTable.functionTypeOf(word);
                    token.changeTokenType(newTokenType);
                    break;
            }
        }
        return idList;
    }

    /**
     * 查詢語句分詞操作
     *
     *      拆分為單個細粒度的詞如:
     *          單詞
     *          分隔符
     *          運算子
     *          陣列
     *          函式
     *
     * @param rawClause 原始查詢語句
     * @param strictMode 是否是嚴格模式, true:是, false:否
     * @return token化的單詞
     */
    private static List<TokenDescriptor> tokenize(String rawClause, boolean strictMode) {
        char[] clauseItr = rawClause.toCharArray();
        List<TokenDescriptor> parsedTokenList = new ArrayList<>();
        Stack<ColumnNumDescriptor> specialSeparatorStack = new Stack<>();
        int clauseLength = clauseItr.length;
        StringBuilder field;
        String fieldGot;
        char nextChar;

        outer:
        for (int i = 0; i < clauseLength; ) {
            char currentChar = clauseItr[i];
            switch (currentChar) {
                case '\'':
                case '\"':
                    fieldGot = readSplitWord(clauseItr, i,
                            currentChar, currentChar);
                    i += fieldGot.length();
                    parsedTokenList.add(
                            new TokenDescriptor(fieldGot, TokenTypeEnum.WORD_STRING));
                    continue outer;
                case '[':
                case ']':
                case '(':
                case ')':
                case '{':
                case '}':
                    if(specialSeparatorStack.empty()) {
                        specialSeparatorStack.push(
                                ColumnNumDescriptor.newData(i, currentChar));
                        parsedTokenList.add(
                                new TokenDescriptor(currentChar,
                                        TokenTypeEnum.CLAUSE_SEPARATOR));
                        break;
                    }
                    parsedTokenList.add(
                            new TokenDescriptor(currentChar,
                                    TokenTypeEnum.CLAUSE_SEPARATOR));
                    char topSpecial = specialSeparatorStack.peek().getKeyword().charAt(0);
                    if(topSpecial == '(' && currentChar == ')'
                            || topSpecial == '[' && currentChar == ']'
                            || topSpecial == '{' && currentChar == '}') {
                        specialSeparatorStack.pop();
                        break;
                    }
                    specialSeparatorStack.push(
                            ColumnNumDescriptor.newData(i, currentChar));
                    break;
                case ' ':
                    // 空格忽略
                    break;
                case '@':
                    nextChar = clauseItr[i + 1];
                    // @{} 擴充套件id, 暫不解析, 原樣返回
                    if(nextChar == '{') {
                        fieldGot = readSplitWord(clauseItr, i,
                                "@{", "}@");
                        i += fieldGot.length();
                        parsedTokenList.add(
                                new TokenDescriptor(fieldGot,
                                        TokenTypeEnum.ID));
                        continue outer;
                    }
                    break;
                case '#':
                    nextChar = clauseItr[i + 1];
                    // #{} 系統關鍵字標識
                    if(nextChar == '{') {
                        fieldGot = readSplitWord(clauseItr, i,
                                "#{", "}");
                        i += fieldGot.length();
                        parsedTokenList.add(
                                new TokenDescriptor(fieldGot,
                                        TokenTypeEnum.KEYWORD_SYS_CUSTOM));
                        continue outer;
                    }
                    break;
                case '+':
                case '-':
                case '*':
                case '/':
                    nextChar = clauseItr[i + 1];
                    if(currentChar == '-'
                            && nextChar >= '0' && nextChar <= '9') {
                        StringBuilder numberBuff = new StringBuilder(currentChar + "" + nextChar);
                        ++i;
                        while ((i + 1) < clauseLength){
                            nextChar = clauseItr[i + 1];
                            if(nextChar >= '0' && nextChar <= '9'
                                    || nextChar == '.') {
                                ++i;
                                numberBuff.append(nextChar);
                                continue;
                            }
                            break;
                        }
                        parsedTokenList.add(
                                new TokenDescriptor(numberBuff.toString(),
                                        TokenTypeEnum.WORD_NUMBER));
                        break;
                    }
                    parsedTokenList.add(
                            new TokenDescriptor(currentChar,
                                    TokenTypeEnum.SIMPLE_MATH_OPERATOR));
                    break;
                case '=':
                case '>':
                case '<':
                case '!':
                    // >=, <=, !=, <>
                    nextChar = clauseItr[i + 1];
                    if(nextChar == '='
                            || currentChar == '<' && nextChar == '>') {
                        ++i;
                        parsedTokenList.add(
                                new TokenDescriptor(currentChar + "" + nextChar,
                                        TokenTypeEnum.COMPARE_OPERATOR));
                        break;
                    }
                    parsedTokenList.add(
                            new TokenDescriptor(currentChar,
                                    TokenTypeEnum.COMPARE_OPERATOR));
                    break;
                default:
                    field = new StringBuilder();
                    TokenTypeEnum tokenType = TokenTypeEnum.WORD_NORMAL;
                    do {
                        currentChar = clauseItr[i];
                        field.append(currentChar);
                        if(i + 1 < clauseLength) {
                            // 去除函式前置名後置空格
                            if(SyntaxSymbolTable.isUdfPrefix(field.toString())) {
                                do {
                                    if(clauseItr[i + 1] != ' ') {
                                        break;
                                    }
                                    ++i;
                                } while (i + 1 < clauseLength);
                            }
                            nextChar = clauseItr[i + 1];
                            if(nextChar == '(') {
                                fieldGot = readSplitWord(clauseItr, i + 1,
                                        nextChar, ')');
                                field.append(fieldGot);
                                tokenType = TokenTypeEnum.FUNCTION_NORMAL;
                                i += fieldGot.length();
                                break;
                            }
                            if(nextChar == '[') {
                                fieldGot = readSplitWord(clauseItr, i + 1,
                                        nextChar, ']');
                                field.append(fieldGot);
                                tokenType = TokenTypeEnum.WORD_ARRAY;
                                i += fieldGot.length();
                                break;
                            }
                            if(isSpecialChar(nextChar)) {
                                // 嚴格模式下，要求 -+ 符號前後必須帶空格, 即會將所有字母后緊連的 -+ 視為字元連線號
                                // 非嚴格模式下, 即只要是分隔符即停止字元解析(非標準分隔)
                                if(!strictMode
                                        || nextChar != '-' && nextChar != '+') {
                                    break;
                                }
                            }
                            ++i;
                        }
                    } while (i + 1 < clauseLength);
                    parsedTokenList.add(
                            new TokenDescriptor(field.toString(), tokenType));
                    break;
            }
            // 正常單字解析迭代
            i++;
        }
        if(!specialSeparatorStack.empty()) {
            ColumnNumDescriptor lineNumTableTop = specialSeparatorStack.peek();
            throw new RuntimeException("檢測到未閉合的符號, near '"
                        + lineNumTableTop.getKeyword()+ "' at column "
                        + lineNumTableTop.getColumnNum());
        }
        return parsedTokenList;
    }

    /**
     * 從源陣列中讀取某類詞資料
     *
     * @param src 資料來源
     * @param offset 要搜尋的起始位置 offset
     * @param openChar word 的開始字元，用於避免迴圈巢狀 如: '('
     * @param closeChar word 的閉合字元 如: ')'
     * @return 解析出的字元
     * @throws RuntimeException 解析不到正確的單詞時丟擲
     */
    private static String readSplitWord(char[] src, int offset,
                                        char openChar, char closeChar)
            throws RuntimeException {
        StringBuilder builder = new StringBuilder();
        for (int i = offset; i < src.length; i++) {
            if(openChar == src[i]) {
                int aroundOpenCharNum = -1;
                do {
                    builder.append(src[i]);
                    // 注意 openChar 可以 等於 closeChar
                    if(src[i] == openChar) {
                        aroundOpenCharNum++;
                    }
                    if(src[i] == closeChar) {
                        aroundOpenCharNum--;
                    }
                } while (++i < src.length
                        && (aroundOpenCharNum > 0 || src[i] != closeChar));
                if(aroundOpenCharNum > 0
                        || (openChar == closeChar && aroundOpenCharNum != -1)) {
                    throw new RuntimeException("syntax error, un closed clause near '"
                            + builder.toString() + "' at column " + --i);
                }
                builder.append(closeChar);
                return builder.toString();
            }
        }
        // 未找到匹配
        return "";
    }

    /**
     * 過載另一版，適用特殊場景 (不支援巢狀)
     *
     * @see #readSplitWord(char[], int, char, char)
     */
    private static String readSplitWord(char[] src, int offset,
                                        String openChar, String closeChar)
            throws RuntimeException {
        StringBuilder builder = new StringBuilder();
        for (int i = offset; i < src.length; i++) {
            if(openChar.charAt(0) == src[i]) {
                int j = 0;
                while (++j < openChar.length() && ++i < src.length) {
                    if(openChar.charAt(j) != src[i]) {
                        break;
                    }
                }
                // 未匹配開頭
                if(j < openChar.length()) {
                    continue;
                }
                builder.append(openChar);
                while (++i < src.length){
                    int k = 0;
                    if(src[i] == closeChar.charAt(0)) {
                        while (++k < closeChar.length() && ++i < src.length) {
                            if(closeChar.charAt(k) != src[i]) {
                                break;
                            }
                        }
                        if(k < closeChar.length()) {
                            throw new RuntimeException("un closed syntax, near '"
                                    + new String(src, i - k, k)
                                    + ", at column " + (i - k));
                        }
                        builder.append(closeChar);
                        break;
                    }
                    builder.append(src[i]);
                }
                return builder.toString();
            }
        }
        // 未找到匹配
        return " ";
    }

    /**
     * 檢測字元是否特殊運算子
     *
     * @param value 給定檢測字元
     * @return true:是特殊字元, false:普通
     */
    private static boolean isSpecialChar(char value) {
        return SyntaxSymbolTable.OPERATOR_ALL.indexOf(value) != -1;
    }

}

　　入口即是 parse() 方法。其中，著重需要說明的是：我們必須要完整解釋出所有語義，所以，我們需要為每個token做型別定義，且每個具體語法需要有相應的處理器進行處理。這些東西，在解析完成時就是固定的了。但具體需要翻譯成什麼語言，需要由使用者進行定義，以便靈活使用。

　　接下來我們來看看如何進行翻譯：

import lombok.extern.slf4j.Slf4j;

import java.util.List;
import java.util.Map;

/**
 * 功能描述: 解析出的各小塊語句
 *
 */
@Slf4j
public class ParsedClauseAst {

    /**
     * id 資訊容器
     */
    private Map<String, Object> idMapping;

    /**
     * 語法樹 列表
     */
    private List<SyntaxStatement> ast;

    public ParsedClauseAst(Map<String, Object> idMapping,
                           List<SyntaxStatement> ast) {
        this.idMapping = idMapping;
        this.ast = ast;
    }

    public Map<String, Object> getidMapping() {
        return idMapping;
    }

    /**
     * 轉換語言表示式
     *
     * @param sqlType sql型別
     * @see TargetDialectTypeEnum
     * @return 翻譯後的sql語句
     */
    public String translateTo(TargetDialectTypeEnum sqlType) {
        StringBuilder builder = new StringBuilder();
        for (SyntaxStatement tree : ast) {
            builder.append(tree.translateTo(sqlType));
        }
        String targetCode = builder.toString().trim();
        log.info("翻譯成目標語言:{}, targetCode: {}", sqlType, targetCode);
        return targetCode;
    }

    @Override
    public String toString() {
        return "ParsedClauseAst{" +
                "idMapping=" + idMapping +
                ", ast=" + ast +
                '}';
    }
}

　　這裡的翻譯過程，實際上就是一個委託的過程，因為所有的語義都已被封裝到具體的處理器中，所以我們只需處理好各細節就可以了。最後將所有小語句拼接起來，就得到我們最終要的目標語言了。所以，具體翻譯的重點工作，需要各自處理，這是很合理的事。

　　大體的思路和實現就是如上，著實也簡單。但可能你還跑不起來以上 demo, 因為還有非常多的細節。

 

4. token型別定義

　　我們需要為每一個token有一個準確的描述，以便在後續的處理中，能夠準確處理。

/**
 * 功能描述: 拆分的token 描述
 *
 */
public class TokenDescriptor {

    /**
     * 原始字串
     */
    private String rawWord;

    /**
     * token型別
     *
     *      用於確定如何使用該token
     *      或者該token是如何被分割出的
     */
    private TokenTypeEnum tokenType;

    public TokenDescriptor(String rawWord, TokenTypeEnum tokenType) {
        this.rawWord = rawWord;
        this.tokenType = tokenType;
    }

    public TokenDescriptor(char rawWord, TokenTypeEnum tokenType) {
        this.rawWord = rawWord + "";
        this.tokenType = tokenType;
    }

    public void changeTokenType(TokenTypeEnum tokenType) {
        this.tokenType = tokenType;
    }

    public String getRawWord() {
        return rawWord;
    }

    public TokenTypeEnum getTokenType() {
        return tokenType;
    }

    @Override
    public String toString() {
        return "T{" +
                "rawWord='" + rawWord + '\'' +
                ", tokenType=" + tokenType +
                '}';
    }
}

// ------------- TokenTypeEnum -----------------
/**
 * 功能描述: 單個不可分割的token 型別定義
 *
 */
public enum TokenTypeEnum {

    LABEL_ID("基礎id如$123"),

    FUNCTION_NORMAL("是函式但型別未知（未解析）"),

    FUNCTION_SYS_CUSTOM("系統自定義函式如my_udf(a)"),

    FUNCTION_SQL("sql中自帶函式如date_diff(a)"),

    KEYWORD_SYS_CUSTOM("系統自定義關鍵字如datepart"),

    KEYWORD_SQL("sql中自帶的關鍵字如and"),

    CLAUSE_SEPARATOR("語句分隔符，如'\"(){}[]"),

    SIMPLE_MATH_OPERATOR("簡單數學運算子如+-*/"),

    COMPARE_OPERATOR("比較運算子如=><!=>=<="),

    WORD_ARRAY("陣列型別欄位如 arr['key1']"),

    WORD_STRING("字元型具體值如 '%abc'"),

    WORD_NUMBER("數字型具體值如 123.4"),

    WORD_NORMAL("普通欄位可以是資料庫欄位也可以是使用者定義的字元"),

    ;

    private TokenTypeEnum(String remark) {
        // ignore...
    }
}

　　如上，基本可以描述各詞的型別了，如果不夠，我們可以視情況新增即可。從這裡，我們可以準確地看出一些分詞的規則。

 

5. 符號表的定義

　　很明顯，我們需要一個統籌所有可被處理的片語的地方，這就是符號表，我們可以通過符號表，準確的查到哪些是系統關鍵詞，哪些是udf，哪些是被支援的方法等等。這是符號表的職責。而且，符號表也可以支援註冊，從而使其可擴充套件。具體如下：

import com.my.mvc.app.common.helper.parser.keyword.SysCustomKeywordAstHandler;
import com.my.mvc.app.common.helper.parser.udf.SimpleUdfAstHandler;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 功能描述: 語法符號表(提供查詢入口)
 */
public class SyntaxSymbolTable {

    /**
     * 所有操作符
     */
    public static final String OPERATOR_ALL = "'\"[ ](){}=+-*/><!";

    /**
     * 所有處理器
     */
    private static final Map<String, SyntaxStatementHandlerFactory> handlers
            = new ConcurrentHashMap<>();

    private static final String SYS_CUSTOM_KEYWORD_REF_NAME = "__sys_keyword_handler";

    private static final String SQL_KEYWORD_REF_NAME = "__sql_keyword_handler";

    private static final String COMMON_HANDLER_REF_NAME = "__common_handler";

    static {
        // 註冊udf, 也可以放到外部呼叫
        registerUdf(
                (masterToken, candidates, handlerType)
                        -> new SimpleUdfAstHandler(masterToken, candidates,
                TokenTypeEnum.FUNCTION_SYS_CUSTOM),
                "my_udf", "fact.my_udf", "default.my_udf");

        // 註冊系統自定義關鍵字處理器
        handlers.putIfAbsent(SYS_CUSTOM_KEYWORD_REF_NAME, SysCustomKeywordAstHandler::new);

        // 註冊兜底處理器
        handlers.putIfAbsent(COMMON_HANDLER_REF_NAME, CommonConditionAstBranch::new);
    }

    /**
     * 判斷給定詞彙的 keyword 型別
     *
     * @param keyword 指定判斷詞
     * @return 系統自定義關鍵字、sql關鍵字、普通字元
     */
    public static TokenTypeEnum keywordTypeOf(String keyword) {
        if("datepart".equals(keyword)) {
            return TokenTypeEnum.KEYWORD_SYS_CUSTOM;
        }
        if("and".equals(keyword)
                || "or".equals(keyword)
                || "in".equals(keyword)) {
            return TokenTypeEnum.KEYWORD_SQL;
        }
        return TokenTypeEnum.WORD_NORMAL;
    }

    /**
     * 註冊一個 udf 處理器例項
     *
     * @param handlerFactory 處理器工廠類
     *              tokens 必要引數列表，說到底自定義
     * @param callNameAliases 函式呼叫別名, 如 wee_diff, fact.my_udf...
     */
    public static void registerUdf(SyntaxStatementHandlerFactory handlerFactory,
                                   String... callNameAliases) {
        for (String alias : callNameAliases) {
            handlers.put(alias, handlerFactory);
        }
    }

    /**
     * 獲取udf處理器的工廠類 （可用於判定系統是否支援）
     *
     * @param udfFunctionName 函式名稱
     * @return 對應的工廠類
     */
    public static SyntaxStatementHandlerFactory getUdfHandlerFactory(String udfFunctionName) {
        SyntaxStatementHandlerFactory factory= handlers.get(udfFunctionName);
        if(factory == null) {
            throw new RuntimeException("不支援的函式操作: " + udfFunctionName);
        }
        return factory;
    }

    /**
     * 獲取系統自定義關鍵字處理器的工廠類  應固定格式為 #{xxx+1}
     *
     * @return 對應的工廠類
     */
    public static SyntaxStatementHandlerFactory getSysKeywordHandlerFactory() {
        return handlers.get(SYS_CUSTOM_KEYWORD_REF_NAME);
    }

    /**
     * 獲取sql關鍵字處理器的工廠類  遵守 sql 協議
     *
     * @return 對應的工廠類
     */
    public static SyntaxStatementHandlerFactory getSqlKeywordHandlerFactory() {
        return handlers.get(COMMON_HANDLER_REF_NAME);
    }

    /**
     * 獲取通用處理器的工廠類（兜底）
     *
     * @return 對應的工廠類
     */
    public static SyntaxStatementHandlerFactory getCommonHandlerFactory() {
        return handlers.get(COMMON_HANDLER_REF_NAME);
    }


    /**
     * 檢測名稱是否是udf 函式字首
     *
     * @param udfFunctionName 函式名稱
     * @return true:是, false:其他關鍵詞
     */
    public static boolean isUdfPrefix(String udfFunctionName) {
        return handlers.get(udfFunctionName) != null;
    }

    /**
     * 判斷給定詞彙的 keyword 型別
     *
     * @param functionFullDesc 函式整體使用方式
     * @return 系統自定義函式，系統函式、未知
     */
    public static TokenTypeEnum functionTypeOf(String functionFullDesc) {
        String funcName = functionFullDesc.substring(0, functionFullDesc.indexOf('('));
        funcName = funcName.trim();
        if("my_udf".equals(funcName)) {
            return TokenTypeEnum.FUNCTION_SYS_CUSTOM;
        }
        return TokenTypeEnum.FUNCTION_NORMAL;
    }

}

　　實際上，整個解析器的完善過程，大部分時候就是符號表的一個完善過程。支援的符號越多了，則功能就越完善了。我們通過一個個的工廠類，實現了具體解析類的細節，遮蔽到內部的變化，從而使變化對上層的無感知。

　　以下為處理器的定義，及工廠類定義：

import java.util.Iterator;

/**
 * 功能描述: 組合標籤語句處理器 工廠類
 *
 *      生產提供各處理器例項
 *
 */
public interface SyntaxStatementHandlerFactory {

    /*
     * 獲取本語句對應的運算元量
     *
     *      其中, 函式呼叫會被解析為單token, 如 my_udf($123) = -1
     *          my_udf($123) 為函式呼叫, 算一個token
     *          '=' 為運算子，算第二個token
     *          '-1' 為右值, 算第三個token
     *      所以此例應返回 3
     *
     * 此實現由具體的 StatementHandler 處理
     *      從 candidates 中獲取即可
     *
     */
    /**
     * 生成一個新的語句處理器例項
     *
     * @param masterToken 主控token, 如關鍵詞，函式呼叫...
     * @param candidates 候選片語（後續片語）, 此實現基於本解析器無全域性說到底關聯性
     * @param handlerType 處理器型別，如函式、關鍵詞、sql...
     * @return 對應的處理器例項
     */
    SyntaxStatement newHandler(TokenDescriptor masterToken,
                               Iterator<TokenDescriptor> candidates,
                               TokenTypeEnum handlerType);
}    
    

// ----------- SyntaxStatement ------------------        
/**
 * 功能描述: 單個小片語處理器
 *
 */
public interface SyntaxStatement {

    /**
     * 轉換成目標語言表示
     *
     * @param targetSqlType 目標語言型別 es|hive|presto|spark
     * @return 翻譯後的語言表示
     */
    String translateTo(TargetDialectTypeEnum targetSqlType);

}

　　有了這符號表和處理器的介面定義，後續的工作明顯方便很多。

　　最後，還有一個行號指示器，需要定義下。它可以幫助我們給出準確的錯誤資訊提示，從而減少排錯時間。

    
/**
 * 功能描述: 行列號指示器
 */
public class ColumnNumDescriptor {

    /**
     * 列號
     */
    private int columnNum;

    /**
     * 關鍵詞
     */
    private String keyword;

    public ColumnNumDescriptor(int columnNumFromZero, String keyword) {
        this.columnNum = columnNumFromZero + 1;
        this.keyword = keyword;
    }

    public static ColumnNumDescriptor newData(int columnNum, String data) {
        return new ColumnNumDescriptor(columnNum, data);
    }
    public static ColumnNumDescriptor newData(int columnNum, char dataChar) {
        return new ColumnNumDescriptor(columnNum, dataChar + "");
    }

    public int getColumnNum() {
        return columnNum;
    }

    public String getKeyword() {
        return keyword;
    }

    @Override
    public String toString() {
        return "Col{" +
                "columnNum=" + columnNum +
                ", keyword='" + keyword + '\'' +
                '}';
    }
}

　　

6. 目標語言定義

　　系統可支援的目標語言是有限的，應當將其定義為列舉型別，以便使用者規範使用。

/**
 * 功能描述: 組合標籤可被翻譯成的 方言列舉
 *
 */
public enum TargetDialectTypeEnum {
    ES,
    HIVE,
    PRESTO,
    SPARK,

    /**
     * 原始語句
     */
    RAW,

    ;
}

　　如果有一天，你新增了一個語言的實現，那你就可以將型別加上，這樣使用者也就可以呼叫了。

 

7. 詞義處理器實現示例

　　解析器的幾大核心之一就是詞義處理器，前面很多的工作都是準備性質的，比如分詞，定義等。前面也看到，我們將詞義處理器統一定義了一個介面: SyntaxStatement . 即所有詞義處理，都只需實現該介面即可。但該詞義至少得獲取到相應的引數，所以通過一個通用的工廠類生成該處理器，也即需要在構造器中處理好上下文關係。

　　首先，我們需要有一個兜底的處理器，以便在未知的情況下，可以保證原語義正確，而非直接出現異常，除非確認所有語義已實現，否則該兜底處理器都是有存在的必要的。

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

/**
 * 功能描述: 通用抽象語法樹處理器（分支）
 *
 */
public class CommonConditionAstBranch implements SyntaxStatement {

    /**
     * 擴充套件片語列表（如 = -1, > xxx ...）
     *
     *      相當於片語上下文
     */
    protected final List<TokenDescriptor> extendTokens = new ArrayList<>();

    /**
     * 型別: 函式, 關鍵詞, 分隔符...
     */
    protected TokenTypeEnum tokenType;

    /**
     * 主控詞（如   and, my_udf($123)）
     *
     *      可用於確定該語義大方向
     */
    protected TokenDescriptor masterToken;


    public CommonConditionAstBranch(TokenDescriptor masterToken,
                                    Iterator<TokenDescriptor> candidates,
                                    TokenTypeEnum tokenType) {
        this.masterToken = masterToken;
        this.tokenType = tokenType;
        for (int i = 0; i < getFixedExtTokenNum(); i++) {
            if(!candidates.hasNext()) {
                throw new RuntimeException("用法不正確: ["
                        + masterToken.getRawWord() + "] 缺少變數");
            }
            addExtendToken(candidates.next());
        }
    }

    /**
     * 新增附加片語，根據各解析器需要新增
     */
    protected void addExtendToken(TokenDescriptor token) {
        extendTokens.add(token);
    }

    @Override
    public String translateTo(TargetDialectTypeEnum targetSqlType) {
        String separator = " ";
        StringBuilder sb = new StringBuilder(masterToken.getRawWord()).append(separator);
        extendTokens.forEach(r -> sb.append(r.getRawWord()).append(separator));
        return sb.toString();
    }

    /**
     * 解析方法固定引數數量，由父類統一解析
     */
    protected int getFixedExtTokenNum() {
        return 0;
    }

    @Override
    public String toString() {
        return "CTree{" +
                "extendTokens=" + extendTokens +
                ", tokenType=" + tokenType +
                ", masterToken=" + masterToken +
                '}';
    }
}

　　該處理器被註冊到符號表中，以 __common_handler 查詢。

　　接下來，我們再另一個處理器的實現: udf。 udf 即使用者自定義函式，這應該是標準sql協議中不存在的關鍵詞，為業務需要而自行實現的函式，它在有的語言裡，可以表現為註冊後的函式，而在有語言裡，我們只能轉換為其他更直接的語法，方可執行。該處理器將作為一種相對複雜些的實現存在，處理的邏輯也是各有千秋。此處僅給一點點提示，大家可按需實現即可。

 

    
import com.my.mvc.app.common.helper.parser.*;

import java.util.Iterator;

/**
 * 功能描述: 自定義函式實現示例
 */
public class SimpleUdfAstHandler
        extends CommonConditionAstBranch
        implements SyntaxStatement {

    public SimpleUdfAstHandler(TokenDescriptor masterToken,
                                 Iterator<TokenDescriptor> candidates,
                                 TokenTypeEnum tokenType) {
        super(masterToken, candidates, tokenType);
    }

    @Override
    protected int getFixedExtTokenNum() {
        // 固定額外引數
        return 2;
    }

    @Override
    public String translateTo(TargetDialectTypeEnum targetSqlType) {
        // 自行實現
        String usage = masterToken.getRawWord();
        int paramStart = usage.indexOf('(');
        StringBuilder fieldBuilder = new StringBuilder();
        for (int i = paramStart; i < usage.length(); i++) {
            char ch = usage.charAt(i);
            if(ch == ' ') {
                continue;
            }
            if(ch == '$') {
                // 示例解析，只需一個id引數處理
                fieldBuilder.append(ch);
                while (++i < usage.length()) {
                    ch = usage.charAt(i);
                    if(ch >= '0' && ch <= '9') {
                        fieldBuilder.append(ch);
                        continue;
                    }
                    break;
                }
                break;
            }
        }
        String separator = " ";
        StringBuilder resultBuilder
                = new StringBuilder(fieldBuilder.toString())
                    .append(separator);
        // 根據各目標語言需要，做特別處理
        switch (targetSqlType) {
            case ES:
            case HIVE:
            case SPARK:
            case PRESTO:
            case RAW:
                extendTokens.forEach(r -> resultBuilder.append(r.getRawWord()).append(separator));
                return resultBuilder.toString();
        }
        throw new RuntimeException("unknown target dialect");
    }
}

　　udf 作為一個重點處理物件，大家按需實現即可。

 

8. 自定義關鍵字的解析實現

　　自定義關鍵字的目的，也許是為了讓使用者使用更方便，也許是為了理解更容易，也許是為系統處理方便，但它與udf實際有異曲同工之妙，不過自定義關鍵字可以儘量定義得簡單些，這也從另一個角度將其與udf區分開來。因此，我們可以將關鍵字處理歸納為一類處理器，簡化實現。

import com.my.mvc.app.common.helper.parser.*;
import com.my.mvc.app.common.util.ClassLoadUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 功能描述: 系統自定義常量解析類
 *
 */
@Slf4j
public class SysCustomKeywordAstHandler
        extends CommonConditionAstBranch
        implements SyntaxStatement {

    private static final Map<String, SysKeywordDefiner>
            keywordDefinerContainer = new ConcurrentHashMap<>();

    static {
        try {
            // 自動發現載入指定路徑下所有關鍵字解析器 keyword 子包
            String currentPackage = SysCustomKeywordAstHandler.class.getPackage().getName();
            ClassLoadUtil.loadPackageClasses(
                    currentPackage + ".custom");
        }
        catch (Throwable e) {
            log.error("載入包路徑下檔案失敗", e);
        }
    }

    public SysCustomKeywordAstHandler(TokenDescriptor masterToken,
                                      Iterator<TokenDescriptor> candidates,
                                      TokenTypeEnum tokenType) {
        super(masterToken, candidates, tokenType);
    }

    @Override
    public String translateTo(TargetDialectTypeEnum targetSqlType) {
        String usage = masterToken.getRawWord();
        String keywordName = parseSysKeywordName(usage);
        SysKeywordDefiner definer = getKeywordDefiner(keywordName);
        List<TokenDescriptor> mergedToken = new ArrayList<>(extendTokens);
        mergedToken.add(0, masterToken);
        if(definer == null) {
//            throw new BizException("不支援的關鍵字: " + keywordName);
            // 在未完全替換所有關鍵字功能之前，不得丟擲以上異常
            log.warn("系統關鍵字[{}]定義未找到,降級使用原始語句,請儘快補充功能.", keywordName);
            return translateToDefaultRaw(mergedToken);
        }
        return definer.translate(mergedToken, targetSqlType);
    }

    /**
     * 獲取關鍵字名稱
     *
     * 檢測關鍵詞是否是 '%%#{datepart}%' 格式的字元
     * @return 關鍵字標識如 datepart
     */
    private String parseSysKeywordName(String usage) {
        if('\'' == usage.charAt(0)) {
            String keywordName = getSysKeywordNameWithPreLikeStr(usage);
            if(keywordName == SYS_CUSTOM_EMPTY_KEYWORD_NAME) {
                throw new RuntimeException("系統關鍵詞定義非法, 請以 #{} 使用關鍵詞2");
            }
            return keywordName;
        }
        return getSysKeywordNameNormal(usage);
    }

    private static final String SYS_CUSTOM_EMPTY_KEYWORD_NAME = "";

    /**
     * 獲取關鍵字名稱（'%#{datepart}%'）
     *
     * @param usage 完整用法
     * @return 關鍵字名稱 如 datepart
     */
    public static String getSysKeywordNameWithPreLikeStr(String usage) {
        if('\'' != usage.charAt(0)) {
            return SYS_CUSTOM_EMPTY_KEYWORD_NAME;
        }
        StringBuilder keywordBuilder = new StringBuilder();
        int preLikeCharNum = 0;
        String separatorChars = " -+(){}[],";
        for (int i = 1; i < usage.length(); i++) {
            char ch = usage.charAt(i);
            if(ch == '%') {
                preLikeCharNum++;
                continue;
            }
            if(ch != '#'
                    || usage.charAt(++i) != '{') {
                return SYS_CUSTOM_EMPTY_KEYWORD_NAME;
            }

            while (++i < usage.length()) {
                ch = usage.charAt(i);
                keywordBuilder.append(ch);
                if(i + 1 < usage.length()) {
                    char nextChar = usage.charAt(i + 1);
                    if(separatorChars.indexOf(nextChar) != -1) {
                        break;
                    }
                }
            }
            break;
        }
        return keywordBuilder.length() == 0
                ? SYS_CUSTOM_EMPTY_KEYWORD_NAME
                : keywordBuilder.toString();
    }


    /**
     * 解析關鍵詞特別用法法為一個個token
     *
     * @param usage 原始使用方式如: #{day+1}
     * @param prefix 字元開頭
     * @param suffix 字元結尾
     * @return 拆分後的token, 已去除分界符 #{}
     */
    public static List<TokenDescriptor> parseSysCustomKeywordInnerTokens(String usage,
                                                                         String prefix,
                                                                         String suffix) {
//        String prefix = "#{day";
//        String suffix = "}";
        String separatorChars = " ,{}()[]-+";
        if (!usage.startsWith(prefix)
                || !usage.endsWith(suffix)) {
            throw new RuntimeException("關鍵字使用格式不正確: " + usage);
        }
        List<TokenDescriptor> innerTokens = new ArrayList<>(2);
        TokenDescriptor token;
        for (int i = prefix.length();
             i < usage.length() - suffix.length(); i++) {
            char ch = usage.charAt(i);
            if (ch == ' ') {
                continue;
            }
            if (ch == '}') {
                break;
            }
            if (ch == '-' || ch == '+') {
                token = new TokenDescriptor(ch, TokenTypeEnum.SIMPLE_MATH_OPERATOR);
                innerTokens.add(token);
                continue;
            }
            StringBuilder wordBuilder = new StringBuilder();
            do {
                ch = usage.charAt(i);
                wordBuilder.append(ch);
                if (i + 1 < usage.length()) {
                    char nextChar = usage.charAt(i + 1);
                    if (separatorChars.indexOf(nextChar) != -1) {
                        break;
                    }
                    ++i;
                }
            } while (i < usage.length());
            String word = wordBuilder.toString();
            TokenTypeEnum tokenType = TokenTypeEnum.WORD_STRING;
            if(StringUtils.isNumeric(word)) {
                tokenType = TokenTypeEnum.WORD_NUMBER;
            }
            innerTokens.add(new TokenDescriptor(wordBuilder.toString(), tokenType));
        }
        return innerTokens;
    }

    /**
     * 解析普通關鍵字定義 #{day+1}
     *
     * @return 關鍵字如: day
     */
    public static String getSysKeywordNameNormal(String usage) {
        if(!usage.startsWith("#{")) {
            throw new RuntimeException("系統關鍵詞定義非法, 請以 #{} 使用關鍵詞");
        }
        StringBuilder keywordBuilder = new StringBuilder();
        for (int i = 2; i < usage.length(); i++) {
            char ch = usage.charAt(i);
            if(ch == ' ' || ch == ','
                    || ch == '+' || ch == '-'
                    || ch == '(' || ch == ')' ) {
                break;
            }
            keywordBuilder.append(ch);
        }
        return keywordBuilder.toString();
    }
    /**
     * 預設使用原始語句返回（）
     *
     * @return 原始關鍵字片語
     */
    private String translateToDefaultRaw(List<TokenDescriptor> tokens) {
        String separator = " ";
        StringBuilder sb = new StringBuilder();
        tokens.forEach(r -> sb.append(r.getRawWord()).append(separator));
        return sb.toString();
    }

    /**
     * 獲取關鍵詞定義處理器
     *
     */
    private SysKeywordDefiner getKeywordDefiner(String keyword) {
        return keywordDefinerContainer.get(keyword);
    }

    /**
     * 註冊新的關鍵詞
     *
     * @param definer 詞定義器
     * @param keywordNames 關鍵詞別名（支援多個，目前只有一個的場景）
     */
    public static void registerDefiner(SysKeywordDefiner definer, String... keywordNames) {
        for (String key : keywordNames) {
            keywordDefinerContainer.putIfAbsent(key, definer);
        }
    }
}

// ----------- SysKeywordDefiner ------------------    
import com.my.mvc.app.common.helper.parser.TargetDialectTypeEnum;
import com.my.mvc.app.common.helper.parser.TokenDescriptor;

import java.util.List;

/**
 * 功能描述: 系統關鍵詞定義介面
 *
 *      （關鍵詞一般被自動註冊，無需另外呼叫）
 *      關鍵詞名稱，如: day, dd, ddpart ...
 *      day
 *      '%#{datepart}%'
 *
 */
public interface SysKeywordDefiner {

    /**
     * 轉換成目標語言表示
     *
     *
     *
     * @param tokens 所有必要片語
     * @param targetSqlType 目標語言型別 es|hive|presto|spark
     * @return 翻譯後的語言表示
     */
    String translate(List<TokenDescriptor> tokens,
                     TargetDialectTypeEnum targetSqlType);

}


// ----------- SyntaxStatement ------------------    

import com.my.mvc.app.common.helper.parser.TargetDialectTypeEnum;
import com.my.mvc.app.common.helper.parser.TokenDescriptor;
import com.my.mvc.app.common.helper.parser.keyword.SysCustomKeywordAstHandler;
import com.my.mvc.app.common.helper.parser.keyword.SysKeywordDefiner;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.List;

/**
 * 功能描述: day 關鍵詞定義
 *
 *      翻譯當天日期，做相應運算
 *
 */
public class DayDefinerImpl implements SysKeywordDefiner {

    private static final String KEYWORD_NAME = "day";

    static {
        // 自動註冊關鍵詞到系統中
        SysCustomKeywordAstHandler.registerDefiner(new DayDefinerImpl(), KEYWORD_NAME);
    }

    @Override
    public String translate(List<TokenDescriptor> tokens,
                            TargetDialectTypeEnum targetSqlType) {
        String separator = " ";
        String usage = tokens.get(0).getRawWord();
        List<TokenDescriptor> innerTokens = SysCustomKeywordAstHandler
                .parseSysCustomKeywordInnerTokens(usage, "#{", "}");
        switch (targetSqlType) {
            case ES:
            case SPARK:
            case HIVE:
            case PRESTO:
                int dayAmount = 0;
                if(innerTokens.size() > 1) {
                    String comparator = innerTokens.get(1).getRawWord();
                    switch (comparator) {
                        case "-":
                            dayAmount = -Integer.valueOf(innerTokens.get(2).getRawWord());
                            break;
                        case "+":
                            dayAmount = Integer.valueOf(innerTokens.get(2).getRawWord());
                            break;
                        default:
                            throw new RuntimeException("day關鍵字不支援的操作符: " + comparator);
                    }
                }
                // 此處格式可能需要由外部傳入，配置化
                return "'"
                        + LocalDate.now().plusDays(dayAmount)
                        .format(DateTimeFormatter.ofPattern("yyyy-MM-dd"))
                        + "'" + separator;
            case RAW:
            default:
                StringBuilder sb = new StringBuilder();
                tokens.forEach(r -> sb.append(r.getRawWord()).append(separator));
                return sb.toString();
        }
    }

}

　　關鍵詞的處理，值得一提是，使用了一個橋接類，且自動發現相應的實現。（可參考JDBC的 DriverManager 的實現） 從而在實現各關鍵字後，直接放入相應包路徑，即可生效。還算優雅吧。

 

9. 單元測試

　　最後一部分，實際也是非常重要的部分，被我簡單化了。我們應該根據具體場景，羅列所有可能的情況，以滿足所有語義，單測通過。樣例如下:

import com.my.mvc.app.common.helper.SimpleSyntaxParser;
import com.my.mvc.app.common.helper.parser.ParsedClauseAst;
import com.my.mvc.app.common.helper.parser.TargetDialectTypeEnum;
import org.junit.Assert;
import org.junit.Test;

public class SimpleSyntaxParserTest {

    @Test
    public void testParse1() {
        String rawClause = "$15573 = 123 and (my_udf($123568, $82949) = 1) or $39741 = #{day+1} and my_udf($35289) = -1";
        ParsedClauseAst clauseAst = SimpleSyntaxParser.parse(rawClause);
        Assert.assertEquals("解析成目標語言ES不正確",
                "$15573 = 123 and ( $123568 = 1 ) or $39741 = '2020-10-07' and $35289 = -1",
                    clauseAst.translateTo(TargetDialectTypeEnum.ES));
    }
}

　　以上，就是一個完整地、簡單的語法解析器的實現了。也許各自場景不同，但相信思想總是相通的。