Flink难点：彻底明白CEP4，组合模式、循环模式介绍

问题导读

1.组合模式需要哪些函数？
2.事件之间的关系有哪三种？
3.循环模式如何表示？
4.循环模式中默认是哪个模式？


上一篇：
Flink难点：彻底明白CEP3：独立模式【Patterns】操作Pattern Operation
http://www.aboutyun.com/forum.php?mod=viewthread&tid=27300


现在你已经看到了独立模式的样子，现在是时候看看如何将它们组合成一个完整的模式序列。

模式序列必须以初始模式开始，如下所示：

[mw_shl_code=java,true]Pattern<Event, ?> start = Pattern.<Event>begin("start");
[/mw_shl_code]
[mw_shl_code=scala,true]val start : Pattern[Event, _] = Pattern.begin("start")
[/mw_shl_code]
接下来，可以通过指定它们之间所需的连续条件，为模式序列添加更多模式。 FlinkCEP支持事件之间的以下形式的邻接：

严格连续性（Strict Contiguity）：预期所有匹配事件一个接一个地出现，中间没有任何不匹配的事件。

轻松连续性（Relaxed Contiguity）：忽略匹配的事件之间出现的不匹配事件。

非确定性松弛邻接（Non-Deterministic Relaxed Contiguity）：进一步放宽邻接，允许忽略一些匹配事件的其他匹配。


要在连续模式之间应用它们，可以使用：

next（）：用于严格连续
followBy（）：用于宽松连续性
followAyAny（），用于非确定性宽松连续性。

或则：
notNext（），如果不希望事件类型直接跟随另一个
notFollowedBy（），如果不希望事件类型在两个其他事件类型之间的任何位置。


注意：模式序列不能以notFollowedBy（）结尾。

注意：NOT模式不能以可选模式开头。

[mw_shl_code=java,true]// strict contiguity
Pattern<Event, ?> strict = start.next("middle").where(...);

// relaxed contiguity
Pattern<Event, ?> relaxed = start.followedBy("middle").where(...);

// non-deterministic relaxed contiguity
Pattern<Event, ?> nonDetermin = start.followedByAny("middle").where(...);

// NOT pattern with strict contiguity
Pattern<Event, ?> strictNot = start.notNext("not").where(...);

// NOT pattern with relaxed contiguity
Pattern<Event, ?> relaxedNot = start.notFollowedBy("not").where(...);[/mw_shl_code]

[mw_shl_code=scala,true]// strict contiguity
val strict: Pattern[Event, _] = start.next("middle").where(...)

// relaxed contiguity
val relaxed: Pattern[Event, _] = start.followedBy("middle").where(...)

// non-deterministic relaxed contiguity
val nonDetermin: Pattern[Event, _] = start.followedByAny("middle").where(...)

// NOT pattern with strict contiguity
val strictNot: Pattern[Event, _] = start.notNext("not").where(...)

// NOT pattern with relaxed contiguity
val relaxedNot: Pattern[Event, _] = start.notFollowedBy("not").where(...)[/mw_shl_code]

宽松的连续性（Relaxed contiguity ）意味着仅匹配第一个匹配事件，而具有非确定性的松弛连续性（non-deterministic relaxed contiguity），将为同一个开始发出多个匹配。 例如模式“a b”，给定事件序列“a”，“c”，“b1”，“b2”将给出以下结果：

“a”和“b”之间的严格连续性：{}（不匹配），“a”之后的“c”导致“a”被丢弃。

“a”和“b”之间的宽松连续性：{a b1}，因为宽松的连续性被视为“跳过非匹配事件直到下一个匹配事件”。

“a”和“b”之间的非确定性宽松邻接：{a b1}，{a b2}，因为这是最一般的形式。

也可以为模式定义时间约束以使其有效。 例如，可以通过pattern.within（）方法定义模式应在10秒内发生。 处理和事件时间都支持时间模式。

注意模式：序列只能有一个时间约束。 如果在不同的单独模式上定义了多个这样的约束，则应用最小的约束。

[mw_shl_code=scala,true]next.within(Time.seconds(10))
[/mw_shl_code]
[mw_shl_code=java,true]next.within(Time.seconds(10));
[/mw_shl_code]

循环模式中的连续性
可以在循环模式中应用与上一节中讨论的相同的连续条件。 连续性将应用于接受到这种模式的元素之间。 为了举例说明上述情况，模式序列“a b + c”（“a”后跟一个或多个“b”的任何（非确定性宽松）序列，后跟“c”），输入“a” “，”“b1”，“d1”，“b2”，“d2”，“b3”“c”将产生以下结果：

严格连续性：{a b3 c}  - “b1”之后的“d1”导致“b1”被丢弃，“b2”因“d2”而发生同样的情况。

宽松的连续性：{a b1 c}，{a b1 b2 c}，{a b1 b2 b3 c}，{a b2 c}，{a b2 b3 c}，{a b3 c}  - “d”被忽略。

非确定性宽松邻接：{a b1 c}，{a b1 b2 c}，{a b1 b3 c}，{a b1 b2 b3 c}，{a b2 c}，{a b2 b3 c}，{a b3 c}  - 注意{a b1 b3 c}，这是宽松“b”之间邻接的结果。

对于循环模式（例如oneOrMore（）和times（）），默认是宽松的连续性。 如果想要严格的连续性，必须使用continuous（）调用显式指定它，如果你想要非确定性的松弛连续性，你可以使用allowCombinations（）调用。

模式操作
1.consecutive()        

与oneOrMore（）和times（）结合使用，并在匹配事件之间强加严格的连续性，即任何不匹配的元素都会中断匹配（像next（））。

如果不应用，则使用松弛的连续性（如followBy（））。

例如。 像这样的模式：

[mw_shl_code=scala,true]Pattern.begin("start").where(_.getName().equals("c"))
  .followedBy("middle").where(_.getName().equals("a"))
                       .oneOrMore().consecutive()
  .followedBy("end1").where(_.getName().equals("b"))[/mw_shl_code]

[mw_shl_code=java,true]Pattern.<Event>begin("start").where(new SimpleCondition<Event>() {
  @Override
  public boolean filter(Event value) throws Exception {
    return value.getName().equals("c");
  }
})
.followedBy("middle").where(new SimpleCondition<Event>() {
  @Override
  public boolean filter(Event value) throws Exception {
    return value.getName().equals("a");
  }
}).oneOrMore().consecutive()
.followedBy("end1").where(new SimpleCondition<Event>() {
  @Override
  public boolean filter(Event value) throws Exception {
    return value.getName().equals("b");
  }
});[/mw_shl_code]

将为输入序列生成以下匹配项：C D A1 A2 A3 D A4 B.

严格连续应用：{C A1 B}，{C A1 A2 B}，{C A1 A2 A3 B}

没有严格连续应用：{C A1 B}，{C A1 A2 B}，{C A1 A2 A3 B}，{C A1 A2 A3 A4 B}


2.allowCombinations()        

与oneOrMore（）和times（）一起使用，并在匹配事件之间强加非确定性的松散连续性（像followAyAny（））。

如果不应用，则使用宽松的连续性（像followBy（））。

例如。 像这样的模式：

[mw_shl_code=scala,true]Pattern.begin("start").where(_.getName().equals("c"))
  .followedBy("middle").where(_.getName().equals("a"))
                       .oneOrMore().allowCombinations()
  .followedBy("end1").where(_.getName().equals("b"))[/mw_shl_code]

[mw_shl_code=java,true]Pattern.<Event>begin("start").where(new SimpleCondition<Event>() {
  @Override
  public boolean filter(Event value) throws Exception {
    return value.getName().equals("c");
  }
})
.followedBy("middle").where(new SimpleCondition<Event>() {
  @Override
  public boolean filter(Event value) throws Exception {
    return value.getName().equals("a");
  }
}).oneOrMore().allowCombinations()
.followedBy("end1").where(new SimpleCondition<Event>() {
  @Override
  public boolean filter(Event value) throws Exception {
    return value.getName().equals("b");
  }
});[/mw_shl_code]

将为输入序列生成以下匹配项：C D A1 A2 A3 D A4 B.

启用combinations：{C A1 B}，{C A1 A2 B}，{C A1 A3 B}，{C A1 A4 B}，{C A1 A2 A3 B}，{C A1 A2 A4 B}，{C A1 A3 A4 B}，{C A1 A2 A3 A4 B}

未启用combinations：{C A1 B}，{C A1 A2 B}，{C A1 A2 A3 B}，{C A1 A2 A3 A4 B}

总结
以上内容如果初次学习，可能会比较难以理解。如大家想学习更快，后期会录制视频放到About云知识星球和VIP群中。


下一篇：Flink难点：彻底明白CEP5，组模式以及组操作【api】
http://www.aboutyun.com/forum.php?mod=viewthread&tid=27311

最新经典文章，欢迎关注公众号

About云 VIP会员套餐介绍

http://www.aboutyun.com/forum.php?mod=viewthread&tid=27305

加入About云知识星球，获取更多实用资料

写的非常棒，学习了

1.组合模式需要哪些函数？

- next（）：用于严格连续
- followBy（）：用于宽松连续性
- followAyAny（），用于非确定性宽松连续性。
- notNext（），如果不希望事件类型直接跟随另一个
- notFollowedBy（），如果不希望事件类型在两个其他事件类型之间的任何位置。

2.事件之间的关系有哪三种？
- 严格连续性（Strict Contiguity）：预期所有匹配事件一个接一个地出现，中间没有任何不匹配的事件。
- 轻松连续性（Relaxed Contiguity）：忽略匹配的事件之间出现的不匹配事件。
- 非确定性松弛邻接（Non-Deterministic Relaxed Contiguity）：进一步放宽邻接，允许忽略一些匹配事件的其他匹配。


3.循环模式如何表示？
- consecutive()   严格连续性
- allowCombinations()   非确定性的松散连续性   

4.循环模式中默认是哪个模式？
- 默认是宽松的连续性。