重写逻辑表达式

最近碰到一个动态查询条件的问题，比如，前端界面上可选择输入姓名、性别、年龄、电话等查询条件，后端根据是否输入来动态构建查询sql where条件（即如果未输入则不作为查询条件）。如果这些条件最终是全and或全or起来则相对容易处理，但如果既有and又有or则动态构建就困难了。

这个问题经抽象可表达为动态重写逻辑表达式，即先写出完整的表达式，然后排除无效部分。例如，对于下面的完整逻辑表达式字符串：

(a) or (b) and (c)

1. 如果 a 无效则重写为 (b) and (c) 
2. 如果 b 无效则重写为 (a) or (c) 
3. 如果 c 无效则重写为 (a) or (b)
4. 如果 a 和 b 都无效则重写为 (c)  
5. ...
6. 如果全都无效则返回null

这个问题如何通用地解决呢？初看起来似乎很难，无从下手，但用ANTLR来解决则简单到出乎你的意料。

1、定义逻辑表达式语法

# LogicExpr.g4文件

grammar LogicExpr;

stat: expr ;

expr: expr AND expr             # and
    | expr OR expr              # or
    | '(' expr ')'              # group
    | VAR                       # var
    ;

VAR : '(' KEY ')' ;

AND: 'and' ;
OR: 'or' ;
KEY: [a-zA-Z0-9_]+ ;
WS: [ 	
]+ -> skip ;

2、用ANTLR工具生成Java代码（略）

3、接着写排除算法

package com.mycomp.antlr4.le;

import java.util.Collection;

import org.antlr.v4.runtime.ANTLRInputStream;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.misc.Interval;

import com.mycomp.antlr4.le.LogicExprParser.AndContext;      // 以下5个import是ANTLR生成的代码
import com.mycomp.antlr4.le.LogicExprParser.GroupContext;
import com.mycomp.antlr4.le.LogicExprParser.OrContext;
import com.mycomp.antlr4.le.LogicExprParser.StatContext;
import com.mycomp.antlr4.le.LogicExprParser.VarContext;

public class LogicExprRewriter extends LogicExprBaseVisitor<String> {

    public static String rewrite(String le, Collection<String> invalidKeys) {
        ANTLRInputStream input = new ANTLRInputStream(le);

        LogicExprLexer lexer = new LogicExprLexer(input);
        CommonTokenStream tokens = new CommonTokenStream(lexer);

        LogicExprParser parser = new LogicExprParser(tokens);
        StatContext tree = parser.stat();

        LogicExprRewriter rewriter = new LogicExprRewriter(invalidKeys);
        return rewriter.visit(tree);
    }

    /** 无效的逻辑键集合 */
    private final Collection<String> invalidKeys;

    /**
     * 创建{@link LogicExprRewriter}对象。
     *
     * @param invalidKeys 无效的逻辑键集合。
     */
    private LogicExprRewriter(Collection<String> invalidKeys) {
        this.invalidKeys = invalidKeys;
    }

    @Override
    public String visitAnd(AndContext ctx) {
        String left = visit(ctx.expr(0));
        String right = visit(ctx.expr(1));

        String result;
        if (left == null) {
            result = (right == null) ? null : right;
        }
        else {
            if (right == null) {
                result = left;
            }
            else {
                Interval interval = Interval.of(ctx.expr(0).getStop().getStopIndex() + 1, ctx.expr(1).getStart().getStartIndex() - 1);
                String and = ctx.getStart().getInputStream().getText(interval);
                result = left + and + right;
            }
        }

        return result;
    }

    @Override
    public String visitOr(OrContext ctx) {
        String left = visit(ctx.expr(0));
        String right = visit(ctx.expr(1));

        String result;
        if (left == null) {
            result = (right == null) ? null : right;
        }
        else {
            if (right == null) {
                result = left;
            }
            else {
                Interval interval = Interval.of(ctx.expr(0).getStop().getStopIndex() + 1, ctx.expr(1).getStart().getStartIndex() - 1);
                String and = ctx.getStart().getInputStream().getText(interval);
                result = left + and + right;
            }
        }

        return result;
    }

    @Override
    public String visitVar(VarContext ctx) {
        // 去掉左右的括号。例如(a) => a
        String key = ctx.getText().substring(1, ctx.getText().length() - 1);
        boolean invalid = isInvalidKey(key);
        return invalid ? null : ctx.getText();
    }

    @Override
    public String visitGroup(GroupContext ctx) {
        String expr = visit(ctx.expr());
        return (expr == null) ? null : "(" + expr + ")";
    }

    private boolean isInvalidKey(String key) {
        return invalidKeys.contains(key);
    }

}

 4、最后看看单元测试

package com.mycomp.antlr4.le;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;

import java.util.Arrays;
import java.util.Collections;

import org.junit.Test;

public class LogicExprRewriterTest {

    @Test
    public void 无无效键值时_应原样输出() {
        String le = "(a) and (b) and ((c) or (d) and (e))";
        String result = LogicExprRewriter.rewrite(le, Collections.emptyList());
        assertEquals(le, result);
    }

    @Test
    public void 全部都为无效键值时_应输出null() {
        String le = "(a) and (b) and ((c) or (d) and (e))";
        String result = LogicExprRewriter.rewrite(le, Arrays.asList("a", "b", "c", "d", "e"));
        assertNull(result);
    }

    @Test
    public void 保留空白字符() {
        String le = "(a) 	
 and (b) or (c)";
        String result = LogicExprRewriter.rewrite(le, Collections.emptyList());
        assertEquals(le, result);
    }

    @Test
    public void 对于and操作_如果左边无效_则只返回右边() {
        String le = "(a) and (b)";
        String result = LogicExprRewriter.rewrite(le, Arrays.asList("b"));
        assertEquals("(a)", result);
    }

    @Test
    public void 对于and操作_如果右边无效_则只返回左边() {
        String le = "(a) and (b)";
        String result = LogicExprRewriter.rewrite(le, Arrays.asList("a"));
        assertEquals("(b)", result);
    }

    @Test
    public void 对于or操作_如果左边无效_则只返回右边() {
        String le = "(a) or (b)";
        String result = LogicExprRewriter.rewrite(le, Arrays.asList("b"));
        assertEquals("(a)", result);
    }

    @Test
    public void 对于or操作_如果右边无效_则只返回左边() {
        String le = "(a) or (b)";
        String result = LogicExprRewriter.rewrite(le, Arrays.asList("a"));
        assertEquals("(b)", result);
    }

    @Test
    public void 各类值组合测试() {
        String le = "(a) and (b) and ((c) or (d) and (e))";
        String result;

        result = LogicExprRewriter.rewrite(le, Arrays.asList("c", "e"));
        assertEquals("(a) and (b) and ((d))", result);

        result = LogicExprRewriter.rewrite(le, Arrays.asList("a", "b", "e"));
        assertEquals("((c) or (d))", result);
    }

}

就这么简单！