Flink CEP

Flink CEP

相关博客：

Flink-复杂事件（CEP）

Flink之CEP(复杂时间处理)

一、基本概念

1.1 什么是CEP

复杂事件处理（Complex Event Processing，简称CEP）

Flink CEP是Flink中实现的复杂事件处理（CEP）库。

CEP允许在无休止的事件流中检测事件模式，让我们有机会掌握数据中重要的部分。

一个或多个由简单事件构成的事件通过一定的规则匹配，然后输出用户想要得到的数据——满足规则的复杂事件。

1.2 CEP的特点

目标：从有序的简单事件流中发现一些高阶特征。

输入：一个或多个由简单事件构成的事件流。

处理：识别简单事件之间的内在联系，多个符合一定规则的简单事件构成复杂事件。

输出：满足规则的复杂事件。

二、Pattern API

处理事件的规则，被叫做“模式”（Pattern）。

Flink CEP提供了Pattern API，用于对输入流数据进行复杂事件规则定义，用来提取符合规则的时间序列

使用CEP的基本流程如下：

// 数据流
DataStream<Event> input = ...

// 1.定义一个Pattern
Pattern<Event, Event> pattern = Pattern.<Event>begin("start").where(...)
  .next("middle").subtype(SubEvent.class).where(...)
  .followedBy("end").where(...);

// 2.将创建好的Pattern应用到输入事件流上
PatternStream<Event> patternStream = CEP.pattern(input,pattern);

// 3.检出匹配事件序列，处理得到结果
DataStream<Alert> result = patternStream.select(...);

2.1 个体模式（Individual Patterns）

组成复杂规则的每一个单独的模式定义，就是“个体模式”

个体模式可以包括“单例(singleton)模式”和“循环(looping)模式”。

单例模式只接受一个事件，而循环模式可以接收多个。

下面介绍一下常用的API：

量词(Quantifier)

可以在一个个个体模式后追加上两次，也就是指定循环次数。

// 匹配出现4次
start.times(4)

// 匹配出现2/3/4次
// greedy 贪婪的，尽可能多的匹配
start.times(2,4).greedy

// 匹配出现0次或者4次
start.times(4).optional

// 匹配出现1次或者多次
start.oneOrMore

// 匹配出现2，3，4次
start.times(2,4)

// 匹配出现0次、2次或者更多次，并且尽可能多的重复匹配
start.timesOrMore(2).optional.greedy

条件(Condition)

每个模式都需要指定触发条件，作为模式是否接受事件进入的判断依据。

CEP中的个体模式主要通过where()，or()和until()来指定条件。

按照不同的调用方式，可以分成以下几类

• 简单条件

  通过where()方法对事件中的字段进行判断筛选，决定是否接受该事件。

  // 判断该事件是否以foo开头
  start.where(new SimpleCondition<Event>){
    @Override
    public boolean filter(Event value) throws Exception{
      return value.getName.startsWith("foo");
    }
  }
  

• 组合条件

  将简单条件进行合并，or()方法表示逻辑或相连，where的直接组合就是and()

  pattern
  	.where(event => ... /* some condition */)
  	.or(event => ... /* or condition */)
  

• 终止条件

  如果使用了oneOrMore或者oneOrMore.optinal，建议使用until()作为终止条件，一遍清理状态。

• 迭代条件

  能够对模式之前所有接收的事件进行处理。

  可以调用ctx.getEventsForPattern("name")

  .where(new IterativeCondition<Event>(){...})
  

2.2 组合模式

组合模式(Combining Patterns)也叫做模式序列

将很多个体模式组合起来，就形成了整个的模式序列。

模式序列必须从一个“初始模式”开始，如下：

Pattern<Event, Event> start = Pattern.<Event>begin("start")

个体模式之间连接有多个选择：

• 严格近邻

  • 所有事件按照严格的顺序出现，中间没有任何不匹配的事件，由next()指定
  • 例如：对于模式"a next b",事件序列[a,c,b1,b2]没有匹配

• 宽松近邻

  • 允许中间出现不匹配的事件，由followedBy()指定
  • 例如：对于模式"a followedBy b",事件序列[a,c,b1,b2]匹配为[a,b1]

• 非确定性宽松近邻

  • 进一步放宽条件，之前已经匹配过的事件也可以再次使用，由followByAny()指定。
  • 例如：对于模式"a followedAny b",事件序列[a,c,b1,b2]匹配为{a,b1},{a,b2}

• 除了以上模式序列以外，还可以定义“不希望出现某种近邻关系”

  • notNext() ：严格的不近邻

  • notFollowedBy() ： 不在两个事件之间发生

    比如：a not FollowedBy c，a Followed By b，a希望之后出现b，且不希望ab之间出现c

• 需要注意的是

  • 所有模式序列必须以begin()开始

  • 模式序列不能以notFollowedBy()结束，必须后面指定与什么事件相邻，比如followedBy()

  • “not”类型的模式不能被optional（0次或多次）所修饰。

  • 此外，还可以为模式指定事件约束，用来要求在多长时间内匹配有效。

    比如：next.within(Time.seconds(10))

2.3 模式组

将一个模式序列作为条件嵌套在一个个体模式里，成为一个模式。

三、模式的检测

在指定要查找的模式序列后，就可以将其应用于输入流以检测潜在匹配。

调用CEP.pattern()，给定输入流和模式，就能得到一个PatternStream

DataStream<Event> input = ...
Pattern<Event, Event> pattern = Pattern.<Event>begin("start").where(...)...

// 进行模式的检测
PatternStream<Event> patternStream = CEP.pattern(input, pattern);

四、匹配事件的提取

创建PatternStream之后，就可以应用select或者flatselect方法，从检测到的事件序列中提取事件了。

select()方法需要输入一个select function作为参数，每成功匹配的事件序列都会调用它。

select()以一个Map<String, List>来 接收匹配到的事件序列，其中Key就是每一个模式的名称，而value就是所有接收到的事件的List类型

public OUT select(Map<String, List<IN>> pattern) throws Exception {
  IN startEvent = pattern.get("start").get(0);
  IN endEvent = pattern.get("end").get(0);
  return new OUT(startEvent, endEvent);
}

五、超时事件的提取

当一个模式通过within关键字定义了检验窗口时间时，部分事件序列可能因为超过窗口长度而被丢弃。为了能够处理这些超时的部分匹配，select和flatSelect API调用允许指定超时处理程序。

超时处理程序会接收目前为止由模式匹配到的所有事件，由一个OutputTag定义接收到的超时事件序列。

PatternStream<Event> patternStream = CEP.pattern(input, pattern);

// 定义一个OutputTag
OutputTag<String> outputTag = new OutputTag<String>("side-output"){};

/**
* 使用Select处理超时事件时，需要传入三个参数
* 第一个：接收超时数据的OutputTag
* 第二个：处理超时数据的规则
* 第三个：处理正常数据的规则
*/
SingleOutputStreamOperator<ComplexEvent> flatResult = 
  patternStream.flatSelect(
  outputTag,
  new PatternFlatTimeoutFunction<Event, TimeoutEvent>() {...},
  new PatternFlatSelectFunction<Event, ComplexEvent>() {...}
);

// 输出超时数据
DataStream<TimeoutEvent> timeoutFlatResult = 
  flatResult.getSideOutput(outputTag);