Flink难点：彻底明白CEP5，组模式以及组操作【api】

问题导读

1.通过什么操作，可以实现定义模式开始？
2.如果事件之间严格连续，需要使用哪个函数？
3.宽松模式该如何实现？

上一篇：
Flink难点：彻底明白CEP4，组合模式、循环模式介绍
http://www.aboutyun.com/forum.php?mod=viewthread&tid=27308



可以将模式序列定义为begin，followBy，followByAny和next的条件。 模式序列将被视为匹配条件。可以应用oneOrMore（），times（#ofTimes），times（＃fromTimes，＃toTimes），optional（），consecutive（）， allowCombinations（）到GroupPattern。

[mw_shl_code=scala,true]val start: Pattern[Event, _] = Pattern.begin(
Pattern.begin[Event]("start").where(...).followedBy("start_middle").where(...)
)

// strict contiguity
val strict: Pattern[Event, _] = start.next(
Pattern.begin[Event]("next_start").where(...).followedBy("next_middle").where(...)
).times(3)

// relaxed contiguity
val relaxed: Pattern[Event, _] = start.followedBy(
Pattern.begin[Event]("followedby_start").where(...).followedBy("followedby_middle").where(...)
).oneOrMore()

// non-deterministic relaxed contiguity
val nonDetermin: Pattern[Event, _] = start.followedByAny(
Pattern.begin[Event]("followedbyany_start").where(...).followedBy("followedbyany_middle").where(...)
).optional()[/mw_shl_code]

[mw_shl_code=java,true]Pattern<Event, ?> start = Pattern.begin(
Pattern.<Event>begin("start").where(...).followedBy("start_middle").where(...)
);

// strict contiguity
Pattern<Event, ?> strict = start.next(
Pattern.<Event>begin("next_start").where(...).followedBy("next_middle").where(...)
).times(3);

// relaxed contiguity
Pattern<Event, ?> relaxed = start.followedBy(
Pattern.<Event>begin("followedby_start").where(...).followedBy("followedby_middle").where(...)
).oneOrMore();

// non-deterministic relaxed contiguity
Pattern<Event, ?> nonDetermin = start.followedByAny(
Pattern.<Event>begin("followedbyany_start").where(...).followedBy("followedbyany_middle").where(...)
).optional();[/mw_shl_code]

组操作
begin(#name)：作用定义一个开始模式
[mw_shl_code=scala,true]val start = Pattern.begin[Event]("start")
[/mw_shl_code]

[mw_shl_code=java,true]Pattern<Event, ?> start = Pattern.<Event>begin("start");
[/mw_shl_code]

begin(#pattern_sequence)：作用定义一个开始模式


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

[mw_shl_code=scala,true]val start = Pattern.begin(
Pattern.begin[Event]("start").where(...).followedBy("middle").where(...)
)[/mw_shl_code]

next(#name)：        添加新模式（匹配）。 匹配事件必须直接接替先前的匹配事件（严格连续性）：
[mw_shl_code=scala,true]val next = start.next("middle")
[/mw_shl_code]
[mw_shl_code=java,true]Pattern<Event, ?> next = start.next("middle");
[/mw_shl_code]

next(#pattern_sequence)：        添加新模式。 一系列匹配事件必须直接接替先前的匹配事件（严格连续性）：
[mw_shl_code=scala,true]val next = start.next(
Pattern.begin[Event]("start").where(...).followedBy("middle").where(...)
)[/mw_shl_code]
[mw_shl_code=java,true]Pattern<Event, ?> next = start.next(
Pattern.<Event>begin("start").where(...).followedBy("middle").where(...)
);[/mw_shl_code]

followedBy(#name)： 添加新模式。 匹配事件和先前匹配事件（轻松连续）之间可能发生其他事件：
[mw_shl_code=scala,true]val followedBy = start.followedBy("middle")
[/mw_shl_code]
[mw_shl_code=java,true]Pattern<Event, ?> followedBy = start.followedBy("middle");
[/mw_shl_code]

followedBy(#pattern_sequence)：添加新模式。 在一系列匹配事件和先前匹配事件（宽松连续）之间可能发生其他事件：
[mw_shl_code=scala,true]val followedBy = start.followedBy(
Pattern.begin[Event]("start").where(...).followedBy("middle").where(...)
)[/mw_shl_code]        

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


followedByAny(#name)：加新模式。 匹配事件和先前匹配事件之间可能发生其他事件，并且将为每个可选匹配事件提供可选匹配（非确定性宽松连续性）：
[mw_shl_code=scala,true]val followedByAny = start.followedByAny("middle")
[/mw_shl_code]
[mw_shl_code=java,true]Pattern<Event, ?> followedByAny = start.followedByAny("middle");
[/mw_shl_code]


followedByAny(#pattern_sequence)：         添加新模式。 在一系列匹配事件和先前匹配事件之间可能发生其他事件，将为每个匹配事件的可选序列提供可选匹配（非确定性宽松连续性）：
[mw_shl_code=java,true]Pattern<Event, ?> followedByAny = start.followedByAny(
Pattern.<Event>begin("start").where(...).followedBy("middle").where(...)
);[/mw_shl_code]
[mw_shl_code=scala,true]val followedByAny = start.followedByAny(
Pattern.begin[Event]("start").where(...).followedBy("middle").where(...)
)[/mw_shl_code]

notNext():        添加新的否定模式。 匹配（否定）事件必须直接成功执行先前的匹配事件（严格连续性）才能丢弃部分匹配：
[mw_shl_code=scala,true]val notNext = start.notNext("not")
[/mw_shl_code]
[mw_shl_code=java,true]Pattern<Event, ?> notNext = start.notNext("not");
[/mw_shl_code]
总结：意思是在匹配中找不到不符合的内容，然后丢弃掉。

notFollowedBy()：添加新的否定（不符合）模式。 即使在匹配（否定）事件和先前匹配事件（轻松连续性）之间发生其他事件，也将丢弃部分匹配事件序列：
[mw_shl_code=java,true]Pattern<Event, ?> notFollowedBy = start.notFollowedBy("not");
[/mw_shl_code]
[mw_shl_code=scala,true]val notFollowedBy = start.notFollowedBy("not")
[/mw_shl_code]

总结：notNext(),notFollowedBy()，更像是在符合条件中过滤掉不符合的数据。


within(time)：定义事件序列与模式匹配的最大时间间隔。 如果未完成的事件序列超过此时间，则将其丢弃：
[mw_shl_code=scala,true]pattern.within(Time.seconds(10))
[/mw_shl_code]
[mw_shl_code=text,true]pattern.within(Time.seconds(10));
[/mw_shl_code]


总结
对于begin是定义模式开始，对于next，followedBy，followedByAny则是添加新模式，并且定义了相邻模式的关系。

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

About云 VIP会员套餐介绍

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

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

写的非常棒，学习了

1.通过什么操作，可以实现定义模式开始？
- begin(#name)：作用定义一个开始模式
- begin(#pattern_sequence)：作用定义一个开始模式

2.如果事件之间严格连续，需要使用哪个函数？
- next(#name) 添加新模式（匹配）。 匹配事件必须直接接替先前的匹配事件（严格连续性）
- next(#pattern_sequence)：        添加新模式。 一系列匹配事件必须直接接替先前的匹配事件（严格连续性）
- notNext():  添加新的否定模式。 匹配（否定）事件必须直接成功执行先前的匹配事件（严格连续性）才能丢弃部分匹配

3.宽松模式该如何实现？

- followedBy(#name)： 添加新模式。 匹配事件和先前匹配事件（宽松连续）之间可能发生其他事件
- followedBy(#pattern_sequence)：添加新模式。 在一系列匹配事件和先前匹配事件（宽松连续）之间可能发生其他事件
- notFollowedBy()：添加新的否定（不符合）模式。 即使在匹配（否定）事件和先前匹配事件（宽松连续）之间发生其他事件，也将丢弃部分匹配事件序列