Flink难点：彻底明白CEP4，组合模式、循环模式介绍
问题导读1.组合模式需要哪些函数？
2.事件之间的关系有哪三种？
3.循环模式如何表示？
4.循环模式中默认是哪个模式？
上一篇：
Flink难点：彻底明白CEP3：独立模式【Patterns】操作Pattern Operation
http://www.aboutyun.com/forum.php?mod=viewthread&tid=27300
现在你已经看到了独立模式的样子，现在是时候看看如何将它们组合成一个完整的模式序列。
模式序列必须以初始模式开始，如下所示：
Pattern<Event, ?> start = Pattern.<Event>begin("start");
val start : Pattern = Pattern.begin("start")
接下来，可以通过指定它们之间所需的连续条件，为模式序列添加更多模式。 FlinkCEP支持事件之间的以下形式的邻接：
严格连续性（Strict Contiguity）：预期所有匹配事件一个接一个地出现，中间没有任何不匹配的事件。
轻松连续性（Relaxed Contiguity）：忽略匹配的事件之间出现的不匹配事件。
非确定性松弛邻接（Non-Deterministic Relaxed Contiguity）：进一步放宽邻接，允许忽略一些匹配事件的其他匹配。
要在连续模式之间应用它们，可以使用：
next（）：用于严格连续
followBy（）：用于宽松连续性
followAyAny（），用于非确定性宽松连续性。
或则：
notNext（），如果不希望事件类型直接跟随另一个
notFollowedBy（），如果不希望事件类型在两个其他事件类型之间的任何位置。
注意：模式序列不能以notFollowedBy（）结尾。
注意：NOT模式不能以可选模式开头。
// 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(...);
// strict contiguity
val strict: Pattern = start.next("middle").where(...)
// relaxed contiguity
val relaxed: Pattern = start.followedBy("middle").where(...)
// non-deterministic relaxed contiguity
val nonDetermin: Pattern = start.followedByAny("middle").where(...)
// NOT pattern with strict contiguity
val strictNot: Pattern = start.notNext("not").where(...)
// NOT pattern with relaxed contiguity
val relaxedNot: Pattern = start.notFollowedBy("not").where(...)
宽松的连续性（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秒内发生。 处理和事件时间都支持时间模式。
注意模式：序列只能有一个时间约束。 如果在不同的单独模式上定义了多个这样的约束，则应用最小的约束。
next.within(Time.seconds(10))
next.within(Time.seconds(10));
循环模式中的连续性
可以在循环模式中应用与上一节中讨论的相同的连续条件。 连续性将应用于接受到这种模式的元素之间。 为了举例说明上述情况，模式序列“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（））。
例如。 像这样的模式：
Pattern.begin("start").where(_.getName().equals("c"))
.followedBy("middle").where(_.getName().equals("a"))
.oneOrMore().consecutive()
.followedBy("end1").where(_.getName().equals("b"))
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");
}
});
将为输入序列生成以下匹配项：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（））。
例如。 像这样的模式：
Pattern.begin("start").where(_.getName().equals("c"))
.followedBy("middle").where(_.getName().equals("a"))
.oneOrMore().allowCombinations()
.followedBy("end1").where(_.getName().equals("b"))
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");
}
});
将为输入序列生成以下匹配项：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
最新经典文章，欢迎关注公众号http://www.aboutyun.com/data/attachment/forum/201903/18/215536lzpn7n3u7m7u90vm.jpg
About云 VIP会员套餐介绍http://www.aboutyun.com/forum.php?mod=viewthread&tid=27305
加入About云知识星球，获取更多实用资料
http://www.aboutyun.com/data/attachment/forum/201906/10/162109faj7o1z2qobr83jd.png
写的非常棒，学习了 1.组合模式需要哪些函数？
- next（）：用于严格连续
- followBy（）：用于宽松连续性
- followAyAny（），用于非确定性宽松连续性。
- notNext（），如果不希望事件类型直接跟随另一个
- notFollowedBy（），如果不希望事件类型在两个其他事件类型之间的任何位置。
2.事件之间的关系有哪三种？
- 严格连续性（Strict Contiguity）：预期所有匹配事件一个接一个地出现，中间没有任何不匹配的事件。
- 轻松连续性（Relaxed Contiguity）：忽略匹配的事件之间出现的不匹配事件。
- 非确定性松弛邻接（Non-Deterministic Relaxed Contiguity）：进一步放宽邻接，允许忽略一些匹配事件的其他匹配。
3.循环模式如何表示？
- consecutive() 严格连续性
- allowCombinations() 非确定性的松散连续性
4.循环模式中默认是哪个模式？
- 默认是宽松的连续性。
页:
[1]