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

其他 2019-05-02 00:41:23 阅读次数: 0

背景

在订单详情页中，常常有一些业务逻辑，根据不同的条件展示不同的文案。通常的写法是一堆嵌套的 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 完。

小结

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

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

猜你喜欢

转载自www.cnblogs.com/lovesqcc/p/10801301.html
今日推荐
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
周排行
返回指定时间格式
fopen函数中的mode参数
Java 单例模式探讨
Flex remoteobject工作原理探讨
寻找mplayer的便捷安装方法
30天了解30种技术系列---(26)MySQL自动化运维工具Inception
关于Jboss/Tomcat/Jetty的JNDI定义123
程序减肥，strip，eu-strip 及其符号表
AsyncTask、View.post(Runnable)、ViewTreeObserver三种方式总结frame animation自动启动
Json和Bean的互相转换
每日归档
更多
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022