栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

查询SQL解析成java对象工具

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

查询SQL解析成java对象工具

场景

这个工具是将查询sql where条件,拆分成数组对象,具体效果如下
例如

select * from dual where id=1 and name between 2 and 4 or (value =3 and stash in('we'))

解析为:

[
    {
        "values":[
            "1"
        ],
        "column":"id",
        "operator":"="
    },
    {
        "link":"AND"
    },
    {
        "values":[
            "2",
            "4"
        ],
        "column":"name",
        "operator":"BETWEEN"
    },
    {
        "link":"OR"
    },
    [
        {
            "values":[
                "3"
            ],
            "column":"value",
            "operator":"="
        },
        {
            "link":"AND"
        },
        {
            "values":[
                "'we'"
            ],
            "column":"stash",
            "operator":"IN"
        }
    ]
]
代码
  • 依赖包:
com.github.jsqlparser:jsqlparser:0.9.4
  • 解析工具类
import com.google.common.base.Joiner;
import com.google.common.base.Splitter;
import com.google.common.collect.Lists;
import com.madai.rong.common.Assert;
import net.sf.jsqlparser.expression.*;
import net.sf.jsqlparser.expression.operators.conditional.Andexpression;
import net.sf.jsqlparser.expression.operators.conditional.Orexpression;
import net.sf.jsqlparser.expression.operators.relational.*;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;
import org.apache.commons.lang.StringUtils;


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



public class expressionVisitorCondition extends expressionVisitorAdapter {


    
    private static final String HADES_F_EXISTS = "HADES_F_EXISTS";


    private static final String HAVE_OPERATOR = "HAVE_ANY";
    private static final String NOT_HAVE_OPERATOR = "NOT_HAVE";


    private WhereItem whereItem;
    
    private Character sign;
    private List expressionItems;


    private Function function;




    private expressionVisitorCondition(WhereItem whereItem) {
        super();
        this.whereItem = whereItem;
    }


    public expressionVisitorCondition(List expressionItems) {
        super();
        this.expressionItems = expressionItems;
    }


    @Override
    public void visit(NullValue nullValue) {
        addValue(nullValue.toString(), RuleItemValuesTypeEnum.O.name());
    }


    @Override
    public void visit(Doublevalue doublevalue) {
        addValue(doublevalue.toString(), RuleItemValuesTypeEnum.N.name());
    }


    @Override
    public void visit(LongValue longValue) {
        addValue(longValue.getStringValue(), RuleItemValuesTypeEnum.N.name());
    }


    @Override
    public void visit(StringValue stringValue) {
        //除去两边的''
        addValue(stringValue.getValue(), RuleItemValuesTypeEnum.A.name());
    }


    @Override
    public void visit(Signedexpression expr) {
        
        sign = expr.getSign();
        expr.getexpression().accept(this);
    }


    @Override
    public void visit(Andexpression andexpression) {


        addOrexpression(andexpression);
    }


    @Override
    public void visit(Orexpression orexpression) {
        addOrexpression(orexpression);
    }


    
    private void addOrexpression(Binaryexpression binaryexpression) {
        binaryexpression.getLeftexpression().accept(this);
        //设置连接符
        expressionItems.add(linkOperator.builder().link(binaryexpression.getStringexpression()).build());
        binaryexpression.getRightexpression().accept(this);
    }




    
    private void relateexpression(Binaryexpression binaryexpression) {
        WhereItem item = WhereItem.builder().build();
        expressionItems.add(item);
        //设置操作符
        item.setOperator(binaryexpression.getStringexpression());


        expressionVisitor expressionVisitor = new expressionVisitorCondition(item);
        binaryexpression.getLeftexpression().accept(expressionVisitor);
        binaryexpression.getRightexpression().accept(expressionVisitor);
    }


    @Override
    public void visit(Between between) {
        WhereItem item = WhereItem.builder().build();
        expressionItems.add(item);


        expressionVisitor expressionVisitor = new expressionVisitorCondition(item);
        between.getLeftexpression().accept(expressionVisitor);
        if (between.isNot()) {
            appendOperator("NOT BETWEEN");
        } else {
            item.setOperator("BETWEEN");
        }


        between.getBetweenexpressionStart().accept(expressionVisitor);
        between.getBetweenexpressionEnd().accept(expressionVisitor);
    }




    @Override
    public void visit(Inexpression inexpression) {
        WhereItem item = WhereItem.builder().build();
        expressionItems.add(item);
        expressionVisitorCondition expressionVisitor = new expressionVisitorCondition(item);


        if (inexpression.getLeftexpression() == null) {
            inexpression.getLeftItemsList().accept(expressionVisitor);
        } else {
            inexpression.getLeftexpression().accept(expressionVisitor);


        }
        if (inexpression.isNot()) {
            item.setOperator("NOT IN");
        } else {
            item.setOperator("IN");
        }
        inexpression.getRightItemsList().accept(expressionVisitor);
    }


    @Override
    public void visit(IsNullexpression isNullexpression) {
        WhereItem item = WhereItem.builder().build();
        expressionItems.add(item);


        expressionVisitorCondition expressionVisitor = new expressionVisitorCondition(item);
        isNullexpression.getLeftexpression().accept(expressionVisitor);
        if (isNullexpression.isNot()) {
            item.setOperator("IS NOT NULL");
        } else {
            item.setOperator("IS NULL");
        }
    }




    @Override
    public void visit(EqualsTo equalsTo) {
        relateexpression(equalsTo);
    }


    @Override
    public void visit(GreaterThan greaterThan) {
        relateexpression(greaterThan);
    }


    @Override
    public void visit(GreaterThanEquals greaterThanEquals) {
        relateexpression(greaterThanEquals);
    }


    @Override
    public void visit(MinorThan minorThan) {
        relateexpression(minorThan);
    }


    @Override
    public void visit(MinorThanEquals minorThanEquals) {
        relateexpression(minorThanEquals);
    }


    @Override
    public void visit(NotEqualsTo notEqualsTo) {
        relateexpression(notEqualsTo);
    }


    @Override
    public void visit(Column tableColumn) {
        //查询条件使用表别名
        final Table table = tableColumn.getTable();
        String tableName = null;
        if (table != null) {
            if (table.getAlias() != null) {
                tableName = table.getAlias().getName();
            } else {
                tableName = table.getFullyQualifiedName();
            }
        }
        writeColumn(StringUtils.isNotBlank(tableName) ? Joiner.on(".").join(tableName, tableColumn.getColumnName()) : tableColumn.getColumnName());
    }


    @Override
    public void visit(expressionList expressionList) {
        //解析表达式例如: a IN (1,2,3)
        for (Iterator iter = expressionList.getexpressions().iterator(); iter.hasNext(); ) {
            expression expression = iter.next();
            expression.accept(this);
        }
    }


    @Override
    public void visit(Parenthesis parenthesis) {
        //解析表达式例如: a =1 OR (b =2 AND c = 3)
        List list = Lists.newArrayList();
        expressionItems.add(list);
        parenthesis.getexpression().accept(new expressionVisitorCondition(list));
    }


    @Override
    public void visit(Function function) {
        this.function = function;


        String functionName = function.getName();
        Assert.that("HADES_F_EXISTS".equals(functionName), "只支持自定义函数:HADES_F_EXISTS,当前函数不支持:" + functionName);


        List expressions = function.getParameters().getexpressions();
        String sourceStr = expressions.get(0).toString();
        String targetStr = expressions.get(1).toString();


        Assert.that(StringUtils.isNotBlank(sourceStr), "HADES_F_EXISTS函数sourceStr参数为空");
        Assert.that(StringUtils.isNotBlank(targetStr), "HADES_F_EXISTS函数targetStr参数为空");


        //设置查询条件,和值
        whereItem.setColumn(targetStr);
        whereItem.setValues(Splitter.on(",").splitToList(sourceStr.subSequence(1, sourceStr.length() - 1)));
    }


    
    private void appendOperator(String operator) {
        whereItem.setOperator(operator);
    }


    
    private void addValue(String value, String valuesType) {
        if (whereItem.getValues() == null) {
            whereItem.setValues(Lists.newArrayList());
        }


        //针对HADES_F_EXISTS自定义函数特殊处理
        if (function != null && HADES_F_EXISTS.equals(function.getName())) {
            //如果对应函数值为1,将操作符设置为HAVE,否则设置为NOT HAVE
            String operator = "1".equals(value) ? HAVE_OPERATOR : NOT_HAVE_OPERATOR;
            whereItem.setOperator(operator);
            whereItem.setValuesType(RuleItemValuesTypeEnum.A.name());
            return;
        }


        Assert.that(StringUtils.isNotBlank(valuesType), "column类型为空");
        whereItem.setValuesType(valuesType);
        //如果值前面有'-' 或 '+' 则在值前面加上
        whereItem.getValues().add(sign == null ? value : sign + value);
    }


    
    private void writeColumn(String column) {
        Assert.that(StringUtils.isNotBlank(column), "column为空");
        whereItem.setColumn(column);
    }


    @Builder
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class linkOperator{
        private String link;
    }


    @Builder
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class WhereItem {
        
        private String column;
        
        private String operator;
        private String valuesType;
        private List values;
    }


    public enum RuleItemValuesTypeEnum {
        A("字符"), N("数值"), O("对象");


        private String desc;


        RuleItemValuesTypeEnum(String desc) {
            this.desc = desc;


        }


        public String getDesc() {
            return desc;
        }
    }
}

 
  • 测试类
@Slf4j
public class SqlUtil {
    
    public static List parseSQLBody(String sql){
        //解析sql
        Select select;
        try {
            select = (Select) CCJSqlParserUtil.parse(sql);
        } catch (JSQLParserException e) {
            log.error(Logger.formatMessage("解析sql失败:{}", sql), e);
            throw new RuntimeException(e);
        }
        //SELECT
        PlainSelect plain = (PlainSelect) select.getSelectBody();
        expression where_expression = plain.getWhere();


        if(where_expression == null){
            return Lists.newArrayList();
        }


        List list = Lists.newArrayList();
        //自定义解析器
        expressionVisitorCondition expressionDeParser = new expressionVisitorCondition(list);
        where_expression.accept(expressionDeParser);
        log.info("sql:{},解析为:{}", sql, JSONArray.toJSON(list));
        return list;
    }
}

转载请注明:文章转载自 www.mshxw.com
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号