流程中比较重要的第二个点就是条件判定，流程有了，如果条件判定不行，流程照样执行不下去。理解条件判定在执行过程中是比较重要的，在开发和排查错误中可以有效的减少我们的时间，提升销量

条件判断

条件判断的方式有很多种，最终都可以总结为

  • 等于
  • 大于
  • 小于
  • 包含
  • 不包含

等等上述的几个关系。

在简单判定中可能只有一种，例如金额小于10元可以直接报销，大于10元需要老板审批。
而在复杂判定中，则是由多个简单判定组合而成的，他们的组合条件是 或者 以及 并且 来组合多个简单判定。

example: 

  1. <domain>
  2.     <model trigger="first">
  3.         <rule>
  4.             <case>
  5.                 <condition operator="and">
  6.                     <if var="name" relation="=" value="{userName}"/>
  7.                     <if var="sex" relation="=" value="男"/>
  8.                 </condition>
  9.                 <effect prob="1">
  10.                     <set var="u_m" value="你的性别是: {sex} 姓名是:{name}"/>
  11.                 </effect>
  12.             </case>
  13.             <case>
  14.                 <effect prob="1">
  15.                     <set var="u_m" value="请输入你的姓名和性别哟!"/>
  16.                 </effect>
  17.             </case>
  18.         </rule>
  19.     </model>
  20. </domain>

这个例子逻辑不太恰当，也可以说明提交判定的方式了

  • 如果输入的变量 name 等于 输入的 userName 并且 性别 sex=男
    • 那么将 你的性别是: {sex} 姓名是:{name} 赋值给 u_m 变量
  • 否则执行第二个case，由于第二个case没有condition，则一定会执行
    • 那么将 请输入你的姓名和性别哟! 赋值给 u_m 变量

判定的方式就是这么简单，下面看看代码是如何去组织这一段的。

源码分析

image.png
条件的描述使用接口，分别有一下几个实现

  • BasicCondtion 上边罗列的几个判断方式，例如等于，不等于等等
  • VoidCondition 空判定，总是为true，同编程语言中 else 后边的部分。
  • ComplexConditon 复杂条件，有多个Condition组合而成，多个条件之间的组合关系为 AND 和 OR
  • NegatedCondtion 否定，用的较少。

BasicCondtion

一个基础的条件判断，就是预期的值和实际的值进行比较判定

  • realValue
  • expectValue

Opendial 的处理方式与此相同

  • 提供上下文的变量信息
  • 根据初始化的上下文决定是否需要填槽 ，如果出现{}就意味着是一个占位符，需要进行填槽处理，其实就是做一次 replace

  • 将realValue和expectValue进行对比

    1. @Override
    2. public boolean isSatisfiedBy(Assignment input) {
    3.    //是否支持进行比较了，如果还有槽需要填，是不能进行比较的
    4.    if (!variable.isFilledBy(input) || !templateValue.isFilledBy(input)) {
    5.        return false;
    6.    }
    7.    BasicCondition grounded = new BasicCondition(this, input);
    8.    //从上下文中获取变量variable真实的数据
    9.    Value actualValue = input.getValue(grounded.variable.toString());
    10.    //进行比较
    11.    return grounded.isSatisfied(actualValue);
    12. }
    14. //----------------------------------------------------------------
    15. /**
    16. * Returns true if the relation is satisfied between the actual and expected
    17. * values.
    18. * 
    19. * @param actualValue the actual value
    20. * @return true if satisfied, false otherwise
    21. */
    22. private boolean isSatisfied(Value actualValue) {
    24.    // standard case
    25.    if (groundValue != null) {
    26.        switch (relation) {
    27.        case EQUAL:
    28.            return actualValue.equals(groundValue);
    29.        case UNEQUAL:
    30.            return !actualValue.equals(groundValue);
    31.        case GREATER_THAN:
    32.            return (actualValue.compareTo(groundValue) > 0);
    33.        case LOWER_THAN:
    34.            return (actualValue.compareTo(groundValue) < 0);
    35.        case CONTAINS:
    36.            return actualValue.contains(groundValue);
    37.        case NOT_CONTAINS:
    38.            return !actualValue.contains(groundValue);
    39.        case LENGTH:
    40.            return actualValue.length() == groundValue.length();
    41.        case IN:
    42.            return groundValue.contains(actualValue);
    43.        case NOT_IN:
    44.            return !groundValue.contains(actualValue);
    45.        }
    46.        return false;
    47.    }
    49.    // when regular expressions in the templates
    50.    else {
    51.        switch (relation) {
    52.        case EQUAL:
    53.            return templateValue.match(actualValue.toString()).isMatching();
    54.        case UNEQUAL:
    55.            return !templateValue.match(actualValue.toString()).isMatching();
    56.        case CONTAINS:
    57.            return templateValue.partialmatch(actualValue.toString())
    58.                    .isMatching();
    59.        case NOT_CONTAINS:
    60.            return !templateValue.partialmatch(actualValue.toString())
    61.                    .isMatching();
    62.        case LENGTH:
    63.            return templateValue.match("" + actualValue.length()).isMatching();
    64.        default:
    65.            return false;
    66.        }
    67.    }
    68. }

    ComplexConditon

    ComplexCondition 代表复杂条件，等同于多个List的组合实现

  • 如果是AND，所有Condition都要满足
  • 如果是OR，只要满足其中一个即可
    1.   @Override
    2.   public boolean isSatisfiedBy(Assignment input) {
    3.       for (Condition cond : subconditions) {
    4.           if (operator == BinaryOperator.AND && !cond.isSatisfiedBy(input)) {
    5.               return false;
    6.           }
    7.           else if (operator == BinaryOperator.OR && cond.isSatisfiedBy(input)) {
    8.               return true;
    9.           }
    10.       }
    11.       return (operator == BinaryOperator.AND);
    12.   }

总结

讲述了Condition是如何组成的，以及Condition的处理方式，没有涉及到变量提取是如何操作的。