博客

1.java里可以使用Spring的 Spel或者Google的Aviator

如果使用 Aviator 则添加以下依赖

      <dependency>
          <groupId>com.googlecode.aviator</groupId>
          <artifactId>aviator</artifactId>
          <version>4.1.2</version>
      </dependency>

不过,


推荐使用Spel

一般的规则匹配最终都会采用如下表达式来计算

如   (

{status} in “2,3” && ({level} in “p1,p2” || {times} in “1,9”))

但是存储在DB中一般采用 List<Model>的方式来存储,这样方便管理界面的前端的渲染 (当然也不排除直接存储表达式的,不过前端的渲染就有些难度了)

整个解析过程实现过程有以下几步

1.存储的List中的规则转换为表达式

1.1 增加括号

1.2 替换变量

1.3 构造spel表达式

1.4 连接下一个规则

2.计算表达式

代码如下:

import com.google.common.collect.ImmutableMap;


import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@NoArgsConstructor
    @AllArgsConstructor
    @Data
    static class RuleItem {
        /**
         * 左变量
         */
        private String left;

        /**
         * 比较表达式
         */
        private ComparelOpration comparelOpration;

        /**
         * 右变量或者常量
         */
        private String right;

        /**
         * 连接下一个表达式的逻辑运算符
         */
        private LogicalOpration logicalOpra;
    }


    @NoArgsConstructor
    @AllArgsConstructor
    @Data
    static class RuleModel {
        /**
         * 规则列表
         */
        private List<RuleItem> ruleItems;

        /**
         * 左括号放在第几个Item之前
         */
        private List<Integer> leftParenthesesIndex;

        /**
         * 右括号放在第几个Item之后
         */
        private List<Integer> rightParenthesesIndex;
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class SpelResult {
        private String express;
        private StandardEvaluationContext context;
    }

使用的两个连接器(比较连接和逻辑连接)

enum ComparelOpration {
        In,
        NotIn,
        GreaterThan,
        LessThan,
        GreaterEqualThan,
        LessEqualThan,
        Equal,
        NotEqual;

        public static boolean isDecimalCompareLogicalOpration(ComparelOpration opration) {
            return opration.ordinal() == ComparelOpration.GreaterThan.ordinal()
                    || opration.ordinal() == ComparelOpration.GreaterEqualThan.ordinal()
                    || opration.ordinal() == ComparelOpration.LessEqualThan.ordinal()
                    || opration.ordinal() == ComparelOpration.LessThan.ordinal();
        }

        public static boolean isEqualLogicalOpration(ComparelOpration opration) {
            return opration.ordinal() == ComparelOpration.Equal.ordinal()
                    || opration.ordinal() == ComparelOpration.NotEqual.ordinal()
                    ;
        }
    }

    enum LogicalOpration {
        None,
        And,
        Or;

        static String toStr(LogicalOpration logicalOpration) {
            return logicalOpration.ordinal() == LogicalOpration.None.ordinal()
                    ? ""
                    : (logicalOpration.ordinal() ==