flow：子规则链组件，用于规则链嵌套。对于复杂的规则链配置，可以通过这种嵌套方式提高规则链的可维护性和重复利用性。

例如：不同的业务类型它的消息结构不一样，可以根据不同的业务类型创建对应的子规则链，然后在根规则链使用路由节点把不同业务路由到对应的子规则链进行业务处理。

另外子规则链组件执行完之后可以接其他组件。用于解决：异步执行A组件和B组件，都执行结束后执行C。那么可以把A和B放到子规则链使用并行的连接方式，然后在根规则链连上C。

配置

字段	类型	是否必填	说明	默认值
targetId	string	是	子规则链ID	无
extend v0.27.0+	bool	false	是否继承子规则输出关系和消息	false

• extend
  • extend=true 子规则链的每一个输出和关系作为下一个节点的输入，不合并结果
  • extend=false 合并子规则所有输出结果，通过Success关系发送到下一个节点。合并后消息格式：[]WrapperMsg

Relation Type

如果extend=true 则子规则链的每一个输出和关系作为下一个节点的输入。否则按以下规则合并子规则链处理结果：

• Success: 子规则链所有分支执行完后，把每个结束链消息合后发送到Success链
• Failure: 找不到子规则链实例或者子规则链某个分支执行失败，把消息发送到Failure链

成功消息合并的消息格式：

• metadata: 合并每个结束节点处理后的metadata，如果相同key则覆盖。
• data: 把每个结束节点处理后的消息封装成WrapperMsg数组。 WrapperMsg:

字段	类型	说明	默认值
msg	types.RuleMsg	消息	无
err	string		""
nodeId	string	最后的处理节点	""

示例

嵌套规则链图

其中 subChain01、subChain02、subChain03、subChainN 是子规则链节点。

定义子规则链（subChain1）配置：

{
  "ruleChain": {
    "id":"subChain01",
    "name": "子规则链"
  },
  "metadata": {
    "nodes": [
      {
        "id": "sub_s1",
        "type": "jsFilter",
        "name": "过滤",
        "debugMode": true,
        "configuration": {
          "jsScript": "return msg=='aa';"
        }
      },
      {
        "id": "sub_s2",
        "type": "jsTransform",
        "name": "转换",
        "debugMode": true,
        "configuration": {
          "jsScript": "metadata['test']='Modified by sub chain';\n metadata['index']=52;\n msgType='TEST_MSG_TYPE2';var msg2={};\n  msg2['bb']=22\n return {'msg':msg2,'metadata':metadata,'msgType':msgType};"
        }
      }
    ],
    "connections": [
      {
        "fromId": "sub_s1",
        "toId": "sub_s2",
        "type": "True"
      }
    ]
  }
}

定义子规则链（subChain2）配置：

//省略

定义子规则链（subChain3）配置：

//省略

定义子规则链（subChainN）配置：

//省略

定义根规则链（rootRule01）配置：

{
  "ruleChain": {
    "id":"rootRule01",
    "name": "测试根规则链"
  },
  "metadata": {
    "nodes": [
      {
        "id": "s1",
        "type": "msgTypeSwitch",
        "name": "消息路由"
      },
      {
        "id": "sub_s1",
        "type": "flow",
        "name": "子节点1",
        "configuration": {
          "targetId": "subChain01"
        }
      },
      {
        "id": "sub_s2",
        "type": "flow",
        "name": "子节点2",
        "configuration": {
          "targetId": "subChain02"
        }
      },
      {
        "id": "sub_s3",
        "type": "flow",
        "name": "子节点3",
        "configuration": {
          "targetId": "subChain03"
        }
      },
      {
        "id": "sub_n",
        "type": "flow",
        "name": "子节点N",
        "configuration": {
          "targetId": "subChainN"
        }
      }
    ],
    "connections": [
      {
        "fromId": "root_s1",
        "toId": "sub_s1",
        "type": "MSG_TYPE1"
      },
      {
        "fromId": "root_s1",
        "toId": "sub_s2",
        "type": "MSG_TYPE2"
      },
      {
        "fromId": "root_s1",
        "toId": "sub_s3",
        "type": "MSG_TYPE3"
      },
      {
        "fromId": "root_s1",
        "toId": "sub_n",
        "type": "MSG_TYPE_N"
      }
    ]
  }
}

始化子规则链和根规则链：

//初始化子规则链
subRuleEngine1, err := rulego.New("subChain01", []byte(subRuleChain01Fille), WithConfig(config))
subRuleEngine2, err := rulego.New("subChain02", []byte(subRuleChain02Fille), WithConfig(config))
subRuleEngine3, err := rulego.New("subChain03", []byte(subRuleChain03Fille), WithConfig(config))
subRuleEngineN, err := rulego.New("subChainN", []byte(subRuleChainNFille), WithConfig(config))
//初始化根规则链
ruleEngine, err := rulego.New("rootRule01", []byte(rootRuleChain), WithConfig(config))

也可以通过加载指定文件夹方式批量初始化规则链:

err := rulego.Load("./chains/", rulego.WithConfig(config))

处理消息：

ruleEngine.OnMsg(msg)