详情文案的轻量级表达式配置方案

背景###

在订单详情页中，常常有一些业务逻辑，根据不同的条件展示不同的文案。通常的写法是一堆嵌套的 if-else 语句，难以理解和维护。比如待开奖：

if (Objects.equals(PAID, orderState)) {
    if (Objects.equals(LOTTERY, activity) {
        Map<String, Object> extra = orderBO.getExtra();
        if (extra == null || extra.get("LOTTERY") == null) {
            return "待开奖";
        }
    }
}
if (Objects.equals(LOTTERY, activity)
    && Objects.equals(CONFIRM, orderState)
    && isGrouped(orderBO.getExtra())) {
    return "待开奖";
}
return OrderState.getState(orderState);

如何能够更好地表达这些业务呢 ？

在 "业务逻辑配置化的可选技术方案" 一文中，讨论了“Groovy脚本”、“规则引擎”及“条件表达式”三种方案。 本文主要谈谈条件表达式方案的实现。

问题域分析###

经过初步分析可知，问题域涉及：

• 规则：条件与结果。结果主要是字符串和布尔值，而条件则多种多样，涉及到不同业务领域。因此，要着重解决如何表达复合条件的问题。
• 实例匹配。 以什么样的形式将实例传入。 如果以对象传入，那么就需要反射机制来获取字段，反而容易出错，因此，可以将实例转换为 Map 之后传入规则集合。

这里，使用简单表达式来表示规则。 这样，解决域可以建立为： 表达式 - 实例 Map ，表达式为： 条件 - 结果

这里的主要问题是：

• 配置化地表达复合条件。
• 创建易于编写的语法，能够安全可靠地转化为表达式对象。
  
  

设计方案###

基本思路####

仔细分析代码可知， 这些都可以凝练成 if cond then result 模式。 并且 or 可以拆解为单纯的 and 。比如上述代码可以拆解为：

state = PAID, activity = LOTTERY ,  extra is null => "待开奖"

state = PAID, activity = LOTTERY , extra.containsNot(LOTTERY) => “待开奖”

state = CONFIRM , activity = LOTTERY, extra.EXT_STATUS = "prize" => “待开奖”

这样，我们把问题的解决方案再一次化简：

• 条件组合仅支持 and 表达式的组合，足够所需， 值仅支持 数字、字符串 和 列表。
• 结果仅支持字符串和布尔。
  
  

条件表达式####

支持如下操作符：

• isnull / notnull : 是否为 null , 不为 null

• eq ( = ): 等于，比如 state = PAID => 待发货；

• neq ( != )： 不等于，比如 visible != 0 => 可见订单；

• in (IN) : 包含于 ，比如 state in [TOPAY, PAID, TOSEND] => 未关闭订单；

• contains / notcontains (HAS, NCT): 包含， 比如 extra contains BUYER_PHONE

取值： 从 Map 中获取。支持支持点分比如 extra.EXT_STATUS 。 还可以提供一些计算函数，基于这个值做进一步的计算。

配置语法与解析####

有两种可选配置语法：

• JSON 形式。 比如 {"conditions": [{"field": "activity", "op":"eq", "value":"LOTTERU"},{"field": "state", "op":"eq", "value":"CONFIRM"},{"field": "extra.EXT_STATUS", "op":"eq", "value":"prize"}] , "result":"待开奖"} , 这种形式比较正规，不过有点繁琐，容易因为配置的一点问题出错。

• 简易形式。 比如 activity= LOTTERY && state = CONFIRM && extra.EXT_STATUS = "prize" ， 写起来顺手，这样需要一套DSL 语法和解析代码， 解析会比较复杂一点。

经讨论后，使用 JSON 编写表达式比较繁琐，因此考虑使用简易形式。在简易形式中，规定：

• 条件与结果用 => 分开；
• 每个条件用 逗号 && 分开；
• 每个表达式之间用 ； 区分。
  
  

测试用例####

JSON 的语法配置：

class ExpressionJsonTest extends Specification {

    ExrepssionJsonParser expressionJsonParser = new ExrepssionJsonParser()

    @Test
    def "testOrderStateExpression"() {
        expect:
        SingleExpression singleExpression = expressionJsonParser.parseSingle(singleOrderStateExpression)
        singleExpression.getResult(["state":value]) == result

        where:
        singleOrderStateExpression  | value | result
        '{"cond": {"field": "state", "op":"eq", "value":"PAID"}, "result":"待发货"}' | "PAID" | '待发货'
    }

    @Test
    def "testOrderStateCombinedExpression"() {
        expect:
        String combinedOrderStateExpress = '''
            {"conditions": [{"field": "activity", "op":"eq", "value":"LOTTERY"},{"field": "state", "op":"eq", "value":"PAID"}, {"field": "extra", "op":"isnull"}], "result":"待开奖"} 
                '''
        CombinedExpression combinedExpression = expressionJsonParser.parseCombined(combinedOrderStateExpress.trim())
        combinedExpression.getResult(["state":"PAID", "activity":"LOTTERY"]) == "待开奖"

    }

    @Test
    def "testOrderStateCombinedExpression2"() {
        expect:
        String combinedOrderStateExpress = '''
            {"conditions": [{"field": "activity", "op":"eq", "value":"LOTTERY"},{"field": "state", "op":"eq", "value":"PAID"}, 
                      {"field": "extra", "op":"notcontains", "value":"LOTTERY"}], "result":"待开奖"} 
                '''
        CombinedExpression combinedExpression = expressionJsonParser.parseCombined(combinedOrderStateExpress.trim())
        combinedExpression.getResult(["state":"PAID", "activity":"LOTTERY", "extra":[:]]) == "待开奖"
    }

    @Test
    def "testOrderStateCombinedExpression3"() {
        expect:
        String combinedOrderStateExpress = '''
            {"conditions": [{"field": "activity", "op":"eq", "value":"LOTTERY"},{"field": "state", "op":"eq", "value":"CONFIRM"}, 
                      {"field": "extra.EXT_STATUS", "op":"eq",  "value":"prize"}], "result":"待开奖"} 
                '''
        CombinedExpression combinedExpression = expressionJsonParser.parseCombined(combinedOrderStateExpress.trim())
        combinedExpression.getResult(["state":"CONFIRM", "activity":"LOTTERY", "extra":['EXT_STATUS':'prize']]) == "待开奖"
    }

    @Test
    def "testWholeExpressions"() {
       expect:
       String wholeExpressionStr = '''
            [{"cond": {"field": "state", "op":"eq", "value":"PAID"}, "result":"待发货"},
             {"conditions": [{"field": "activity", "op":"eq", "value":"LOTTERY"},{"field": "state", "op":"eq", "value":"CONFIRM"}], "result":"待开奖"}]
                '''

       WholeExpressions wholeExpressions = expressionJsonParser.parseWhole(wholeExpressionStr)
       wholeExpressions.getResult(["state":"PAID"]) == "待发货"
       wholeExpressions.getResult(["state":"CONFIRM", "activity":"LOTTERY"]) == "待开奖"

    }
}

简易语法的测试用例：

class ExpressionSimpleTest extends Specification {

    ExpressionSimpleParser expressionSimpleParser = new ExpressionSimpleParser()

    @Test
    def "testOrderStateExpression"() {
        expect:
        SingleExpression singleExpression = expressionSimpleParser.parseSingle(singleOrderStateExpression)
        singleExpression.getResult(["state":value]) == result

        where:
        singleOrderStateExpression  | value | result
        'state = PAID => 待发货'  | "PAID" | '待发货'
    }

    @Test
    def "testOrderStateCombinedExpression"() {
        expect:
        String combinedOrderStateExpress = '''
           activity = LOTTERY && state = PAID && extra isnull => 待开奖
    '''
        CombinedExpression combinedExpression = expressionSimpleParser.parseCombined(combinedOrderStateExpress.trim())
        combinedExpression.getResult(["state":"PAID", "activity":"LOTTERY"]) == "待开奖"

    }

    @Test
    def "testOrderStateCombinedExpression2"() {
        expect:
        String combinedOrderStateExpress = '''
               activity = LOTTERY && state = PAID && extra NCT LOTTERY => 待开奖
        '''
        CombinedExpression combinedExpression = expressionSimpleParser.parseCombined(combinedOrderStateExpress.trim())
        combinedExpression.getResult(["state":"PAID", "activity":"LOTTERY", "extra":[:]]) == "待开奖"
    }

    @Test
    def "testOrderStateCombinedExpression3"() {
        expect:
        String combinedOrderStateExpress = '''
           activity = LOTTERY && state = CONFIRM && extra.EXT_STATUS = "prize" => 待开奖
        '''
        CombinedExpression combinedExpression = expressionSimpleParser.parseCombined(combinedOrderStateExpress.trim())
        combinedExpression.getResult(["state":"CONFIRM", "activity":"LOTTERY", "extra":['EXT_STATUS':'prize']]) == "待开奖"
    }

    @Test
    def "testWholeExpressions"() {
        expect:
        String wholeExpressionStr = '''
         activity = LOTTERY && state = PAID && extra NCT LOTTERY => 待开奖 ;
         state = PAID => 待发货 ; activity = LOTTERY && state = CONFIRM && extra.EXT_STATUS = "prize" => 待开奖 ;
         
        '''

        WholeExpressions wholeExpressions = expressionSimpleParser.parseWhole(wholeExpressionStr)
        wholeExpressions.getResult(["state":"PAID"]) == "待发货"
        wholeExpressions.getResult(["state":"PAID", "activity":"LOTTERY"]) == "待开奖"
        wholeExpressions.getResult(["state":"CONFIRM", "activity":"LOTTERY", "extra":['EXT_STATUS':'prize']]) == "待开奖"

    }
}

实现###

STEP1: 定义条件测试接口 Condition 及表达式接口 Expression

public interface Condition {

  /**
   * 传入的 valueMap 是否满足条件对象
   * @param valueMap 值对象
   * 若 valueMap 满足条件对象，返回 true , 否则返回 false .
   */
  boolean satisfiedBy(Map<String, Object> valueMap);
}

public interface Expression {

  /**
   * 获取满足条件时要返回的值
   */
  String getResult(Map<String, Object> valueMap);

}

STEP2: 条件的实现

@Data
public class BaseCondition implements Condition {

  private String field;
  private Op op;
  private Object value;

  public BaseCondition() {}

  public BaseCondition(String field, Op op, Object value) {
    this.field = field;
    this.op = op;
    this.value = value;
  }

  public boolean satisfiedBy(Map<String, Object> valueMap) {
    try {
      if (valueMap == null || valueMap.size() == 0) {
        return false;
      }
      Object passedValue = MapUtil.readVal(valueMap, field);
      switch (this.getOp()) {
        case isnull:
          return passedValue == null;
        case notnull:
          return passedValue != null;
        case eq:
          return Objects.equals(value, passedValue);
        case neq:
          return !Objects.equals(value, passedValue);
        case in:
          if (value == null || !(value instanceof Collection)) {
            return false;
          }
          return ((Collection)value).contains(passedValue);
        case contains:
          if (passedValue == null || !(passedValue instanceof Map)) {
            return false;
          }
          return ((Map)passedValue).containsKey(value);
        case notcontains:
          if (passedValue == null || !(passedValue instanceof Map)) {
            return true;
          }
          return !((Map)passedValue).containsKey(value);
        default:
          return false;
      }
    } catch (Exception ex) {
      return false;
    }
  }
}

@Data
public class CombinedCondition implements Condition {

  private List<BaseCondition> conditions;

  public CombinedCondition() {
    this.conditions = new ArrayList<>();
  }

  public CombinedCondition(List<BaseCondition> conditions) {
    this.conditions = conditions;
  }

  @Override
  public boolean satisfiedBy(Map<String, Object> valueMap) {
    if (CollectionUtils.isEmpty(conditions)) {
      return true;
    }
    for (BaseCondition condition: conditions) {
       if (!condition.satisfiedBy(valueMap)) {
        return false;
      }
    }
    return true;
  }

}

public enum Op {

  isnull("isnull"),
  notnull("notnull"),
  eq("="),
  neq("!="),
  in("IN"),
  contains("HAS"),
  notcontains("NCT"),
  ;

  String symbo;

  Op(String symbo) {
    this.symbo = symbo;
  }

  public String getSymbo() {
    return symbo;
  }

  public static Op get(String name) {
    for (Op op: Op.values()) {
      if (Objects.equals(op.symbo, name)) {
        return op;
      }
    }
    return null;
  }

  public static Set<String> getAllOps() {
    return Arrays.stream(Op.values()).map(Op::getSymbo).collect(Collectors.toSet());
  }
}

STEP3: 表达式的实现

@Data
public class SingleExpression implements Expression {

  private BaseCondition cond;
  protected String result;

  public SingleExpression() {}

  public SingleExpression(BaseCondition cond, String result) {
    this.cond = cond;
    this.result = result;
  }

  public static SingleExpression getInstance(String configJson) {
    return JSON.parseObject(configJson, SingleExpression.class);
  }

  @Override
  public String getResult(Map<String, Object> valueMap) {
    return cond.satisfiedBy(valueMap) ? result : "";
  }
}

public class CombinedExpression implements Expression {

  private CombinedCondition conditions;
  private String result;

  public CombinedExpression() {}

  public CombinedExpression(CombinedCondition conditions, String result) {
    this.conditions = conditions;
    this.result = result;
  }

  @Override
  public String getResult(Map<String, Object> valueMap) {
    return conditions.satisfiedBy(valueMap) ? result : "";
  }

  public static CombinedExpression getInstance(String configJson) {
    try {
      JSONObject jsonObject = JSON.parseObject(configJson);
      String result = jsonObject.getString("result");
      JSONArray condArray = jsonObject.getJSONArray("conditions");
      List<BaseCondition> conditionList = new ArrayList<>();

      if (condArray != null || condArray.size() >0) {
        conditionList = condArray.stream().map(cond -> JSONObject.toJavaObject((JSONObject)cond, BaseCondition.class)).collect(Collectors.toList());
      }
      CombinedCondition combinedCondition = new CombinedCondition(conditionList);
      return new CombinedExpression(combinedCondition, result);
    } catch (Exception ex) {
      return null;
    }
  }
}

@Data
public class WholeExpressions implements Expression {

  private List<Expression> expressions;

  public WholeExpressions() {
    this.expressions = new ArrayList<>();
  }

  public WholeExpressions(List<Expression> expressions) {
    this.expressions = expressions;
  }

  public void addExpression(Expression expression) {
    this.expressions.add(expression);
  }

  public void addExpressions(List<Expression> expression) {
    this.expressions.addAll(expression);
  }

  public String getResult(Map<String,Object> valueMap) {
    for (Expression expression: expressions) {
      String result = expression.getResult(valueMap);
      if (StringUtils.isNotBlank(result)) {
        return result;
      }
    }
    return "";
  }

}

STEP4: 解析器的实现

public interface ExpressionParser {
  Expression parseSingle(String configJson);
  Expression parseCombined(String configJson);
  Expression parseWhole(String configJson);
}

/**
 * 解析 JSON 格式的表达式
 *
 * SingleExpression: 单条件的一个表达式
 * {"cond": {"field": "state", "op":"eq", "value":"PAID"}, "result":"待发货"}
 *
 * CombinedExpression: 多条件的一个表达式
 * {"conditions": [{"field": "activity", "op":"eq", "value":"LOTTERY"},{"field": "state", "op":"eq", "value":"PAID"}, {"field": "extra", "op":"isnull"}], "result":"待开奖"}
 *
 * WholeExpression: 多个表达式的集合
 * '''
 *   [{"cond": {"field": "state", "op":"eq", "value":"PAID"}, "result":"待发货"},
 *    {"conditions": [{"field": "activity", "op":"eq", "value":"LOTTERY"},{"field": "state", "op":"eq", "value":"CONFIRM"}], "result":"待开奖"}]
 * '''
 *
 */
public class ExrepssionJsonParser implements ExpressionParser {

  @Override
  public Expression parseSingle(String configJson) {
    return JSON.parseObject(configJson, SingleExpression.class);
  }

  @Override
  public Expression parseCombined(String configJson) {
    try {
      JSONObject jsonObject = JSON.parseObject(configJson);
      String result = jsonObject.getString("result");
      JSONArray condArray = jsonObject.getJSONArray("conditions");
      List<BaseCondition> conditionList = new ArrayList<>();

      if (condArray != null || condArray.size() >0) {
        conditionList = condArray.stream().map(cond -> JSONObject.toJavaObject((JSONObject)cond, BaseCondition.class)).collect(Collectors.toList());
      }
      CombinedCondition combinedCondition = new CombinedCondition(conditionList);
      return new CombinedExpression(combinedCondition, result);
    } catch (Exception ex) {
      return null;
    }
  }

  @Override
  public Expression parseWhole(String configJson) {
    JSONArray jsonArray = JSON.parseArray(configJson);
    List<Expression> expressions = new ArrayList<>();
    if (jsonArray != null && jsonArray.size() > 0) {
      expressions = jsonArray.stream().map(cond -> convertFrom((JSONObject)cond)).collect(Collectors.toList());
    }
    return new WholeExpressions(expressions);
  }

  private static Expression convertFrom(JSONObject expressionObj) {
    if (expressionObj.containsKey("cond")) {
      return JSONObject.toJavaObject(expressionObj, SingleExpression.class);
    }
    if (expressionObj.containsKey("conditions")) {
      return CombinedExpression.getInstance(expressionObj.toJSONString());
    }
    return null;
  }
}

/**
 * 解析简易格式格式的表达式
 *
 * 条件与结果用 => 分开； 每个表达式之间用 ； 区分。
 *
 * SingleExpression: 单条件的一个表达式
 * state = PAID => 待发货
 *
 * CombinedExpression: 多条件的一个表达式
 * activity = LOTTERY && state = PAID && extra = null => 待开奖
 *
 * WholeExpression: 多个表达式的集合
 *
 * state = PAID => 待发货 ; activity = LOTTERY && state = PAID => 待开奖
 *
 *
 */
public class ExpressionSimpleParser implements ExpressionParser {

  // 条件与结果之间的分隔符
  private static final String sep = "=>";

  // 复合条件之间之间的分隔符
  private static final String condSep = "&&";

  // 多个表达式之间的分隔符
  private static final String expSeq = ";";

  // 引号表示字符串
  private static final String quote = """;

  private static Pattern numberPattern = Pattern.compile("\d+");

  private static Pattern listPattern = Pattern.compile("\[(.*,?)+\]");

  @Override
  public Expression parseSingle(String expStr) {
    check(expStr);
    String cond = expStr.split(sep)[0].trim();
    String result = expStr.split(sep)[1].trim();
    return new SingleExpression(parseCond(cond), result);
  }

  @Override
  public Expression parseCombined(String expStr) {
    check(expStr);
    String conds = expStr.split(sep)[0].trim();
    String result = expStr.split(sep)[1].trim();
    List<BaseCondition> conditions = Arrays.stream(conds.split(condSep)).filter(s -> StringUtils.isNotBlank(s)).map(this::parseCond).collect(Collectors.toList());
    return new CombinedExpression(new CombinedCondition(conditions), result);
  }

  @Override
  public Expression parseWhole(String expStr) {
    check(expStr);
    List<Expression> expressionList = Arrays.stream(expStr.split(expSeq)).filter(s -> StringUtils.isNotBlank(s)).map(this::parseExp).collect(Collectors.toList());
    return new WholeExpressions(expressionList);
  }

  private Expression parseExp(String expStr) {
    expStr = expStr.trim();
    return expStr.contains(condSep) ? parseCombined(expStr) : parseSingle(expStr);
  }

  private BaseCondition parseCond(String condStr) {
    condStr = condStr.trim();
    Set<String> allOps = Op.getAllOps();
    Optional<String> opHolder = allOps.stream().filter(condStr::contains).findFirst();
    if (!opHolder.isPresent()) {
      return null;
    }
    String op = opHolder.get();
    String[] fv = condStr.split(op);
    String field = fv[0].trim();
    String value = "";
    if (fv.length > 1) {
      value = condStr.split(op)[1].trim();
    }
    return new BaseCondition(field, Op.get(op), parseValue(value));
  }

  private Object parseValue(String value) {
    if (value.contains(quote)) {
      return value.replaceAll(quote, "");
    }
    if (numberPattern.matcher(value).matches()) {
      // 配置中通常不会用到长整型，因此这里直接转整型
      return Integer.parseInt(value);
    }
    if (listPattern.matcher(value).matches()) {
      String[] valueList = value.replace("[", "").replace("]","").split(",");
      List<Object> finalResult = Arrays.stream(valueList).map(this::parseValue).collect(Collectors.toList());
      return finalResult;
    }
    return value;
  }

  private void check(String expStr) {
    expStr = expStr.trim();
    if (StringUtils.isBlank(expStr) || !expStr.contains(sep)) {
      throw new IllegalArgumentException("expStr must contains => ");
    }
  }
}

STEP5: 配置集成

客户端使用，见 测试用例。 可以与 apollo 配置系统集成，也可以将条件表达式存放在 DB 中。

demo 完。

小结###

本文尝试使用轻量级表达式配置方案，来解决详情文案的多样化复合逻辑问题。 适用于 条件不太复杂并且相互独立的业务场景。

在实际编程实现的时候，不急于着手，而是先提炼出其中的共性和模型，并实现为简易框架，可以得到更好的解决方案。