about云开发

 找回密码
 立即注册

QQ登录

只需一步,快速开始

扫一扫,访问微社区

[连载型] Flink难点:彻底明白CEP4,组合模式、循环模式介绍

[复制链接]
pig2 发表于 2019-6-12 12:20:21 | 显示全部楼层 |阅读模式
本帖最后由 pig2 于 2019-6-12 16:27 编辑
问题导读

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


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


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

模式序列必须以初始模式开始,如下所示:

[Java] 纯文本查看 复制代码
Pattern<Event, ?> start = Pattern.<Event>begin("start");

[Scala] 纯文本查看 复制代码
val start : Pattern[Event, _] = Pattern.begin("start")

接下来,可以通过指定它们之间所需的连续条件,为模式序列添加更多模式。 FlinkCEP支持事件之间的以下形式的邻接:

严格连续性(Strict Contiguity):预期所有匹配事件一个接一个地出现,中间没有任何不匹配的事件。

轻松连续性(Relaxed Contiguity):忽略匹配的事件之间出现的不匹配事件。

非确定性松弛邻接(Non-Deterministic Relaxed Contiguity):进一步放宽邻接,允许忽略一些匹配事件的其他匹配。


要在连续模式之间应用它们,可以使用:

next():用于严格连续
followBy():用于宽松连续性
followAyAny(),用于非确定性宽松连续性。

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


注意:模式序列不能以notFollowedBy()结尾。

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

[Java] 纯文本查看 复制代码
// 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(...);


[Scala] 纯文本查看 复制代码
// 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(...)


宽松的连续性(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秒内发生。 处理和事件时间都支持时间模式。

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

[Scala] 纯文本查看 复制代码
next.within(Time.seconds(10))

[Java] 纯文本查看 复制代码
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())。

例如。 像这样的模式:

[Scala] 纯文本查看 复制代码
Pattern.begin("start").where(_.getName().equals("c"))
  .followedBy("middle").where(_.getName().equals("a"))
                       .oneOrMore().consecutive()
  .followedBy("end1").where(_.getName().equals("b"))


[Java] 纯文本查看 复制代码
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())。

例如。 像这样的模式:

[Scala] 纯文本查看 复制代码
Pattern.begin("start").where(_.getName().equals("c"))
  .followedBy("middle").where(_.getName().equals("a"))
                       .oneOrMore().allowCombinations()
  .followedBy("end1").where(_.getName().equals("b"))


[Java] 纯文本查看 复制代码
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


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




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




本帖被以下淘专辑推荐:

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

关闭

推荐上一条 /3 下一条

QQ|小黑屋|about云开发-学问论坛|社区 ( 京ICP备12023829号 )

GMT+8, 2019-8-20 06:42 , Processed in 1.250000 second(s), 30 queries , Gzip On.

Powered by Discuz! X3.4 Licensed

© 2018 Comsenz Inc.Designed by u179

快速回复 返回顶部 返回列表