一.什么是CEP？
复杂事件处理: Complex Event Processing。
是Flink中实现复杂事件处理的库。
CEP允许在无限的事件流中检测事件模式。
一个或多个由简单事件构成的事件流，通过一定的规则匹配，输出用户想得到的数据——满足规则的复杂事件。
二.CEP的特点
目标：从有序的简单事件流中发现一些高阶特征。
输入：一个或多个由简单事件构成的事件流。
处理：识别简单事件之间的内在联系，多个符合一定规则的简单事件构成复杂事件。
输出：满足规则的复杂事件。
三.Pattern API
处理时间的规则，被叫做“模式”（pattern）。
Flink CEP提供了Pattern API，用于对输入流数据进行复杂事件规则定义，用来提取符合规则的事件序列。
//定义一个pattern
val pattern = Pattern.begin[Event]("start").where(_.getId == 42)
.next("middle").subtype(classOf[SubEvent]).where(_.getTemp >= 10.0)
.followedBy("end").where(_.getName == "end")
//将创建好的pattern应用到输入事件流上
val patternStream = CEP.pattern(inputDataSteam, pattern)
//获取事件序列，得到处理结果
val result: DataStream[Alert] = patternStream.select(createAlert(_))
个体模式 (Individual Patterns)
组成复杂规则的每一个单独的模式定义，就是“个体模式”。
start.times(3).where(_.behavior.startsWith("fav"))
组合模式 (combining Patterns, 也叫模式序列)
很多个体模式组合起来，就形成了整个的模式序列。
模式序列必须以一个“初始模式”开始：
val start = pattern.begin("start")
模式组（groups of patterns）
将一个模式序列作为条件嵌套在个体模式里，成为一组模式。
1.个体模式
个体模式可以包括“单例模式”和“循环模式”。
单例模式只接收一个事件，而循环模式可以接收多个。
（1）量词：可以在一个个体模式后追加量词，也就是指定循环次数。
//匹配出现4次
start.times(4)
//匹配出现0或4次
start.times(4).optional
//匹配出现2，3或者4次
start.times(2,4)
//匹配出现2，3或者4次，并且尽可能多地重复匹配
start.times(2, 4).greedy
//匹配出现1次或多次
start.oneOrMore
（2）条件
每个模式都需要指定触发条件，作为模式是否接受事件进入的判断依据。
CEP中的个体模式主要通过.where() .or() .until()来指定条件。
按照不同的调用方式，可以分成以下几类：
简单条件
通过.where() 方法对事件中的字段进行判断筛选，决定是否接受该事件。
start.where(event => event.getName.startsWith("foo"))
组合条件
//或
pattern.where(event => ...).or(event => ...)
//与
pattern.where(event => ...).where(event => ...)
终止条件
如果使用了oneOrMore或者oneOrMore.optional，建议用.until()作为终止条件，以便清理状态。
迭代条件
能够对模式之前所有接收的事件进行处理
调用.where((value, ctx) => {...})，可以调用ctx.getEventsForPattern("name")。
2.组合模式
不同“近邻模式”。
严格近邻
所有事件按照严格的顺序出现，中间没有任何不匹配的事件，由.next()指定。
例如对于模式“a next b”，事件序列[a,c,b1,b2]没有匹配。
宽松近邻
允许中间出现不匹配的事件，由.followedBy()指定。
例如对于模式“a followedBy b”，事件序列[a,c,b1,b2]匹配为{a,b1}。
非确定性宽松近邻
进一步放宽条件，之前已匹配过的事件也可以再次使用，由.followedByAny()指定。
例如对于模式“a followedByAny b”。事件序列[a,c,b1,b2]匹配为{a,b1}，{a,b2}。
除了以上组合模式，还可以定义“不希望出现某种近邻关系”：
.notNext() —— 不想让某个事件严格近邻前一个事件发生
.notFollowedBy()—— 不想让某个事件在两个事件之间发生
需要注意
- 所有组合模式必须以.begin()开始
- 组合模式不能以.notFollowedBy()结束
- "not"类型的模式不能被optional所修饰
- 此外，还可以为模式指定时间约束，用来要求在多长时间内匹配有效：
next.within(Time.seconds(10))
3.API使用规范
模式检测
指定要查找的模式序列后，就可以将其应用于输入流以检测潜在匹配。
val input: DataStream[Event] = ...
val pattern: Pattern[Event, _] = ...
val patternStream: PatternStream[Event] = CEP.pattern(input, pattern)
匹配事件的提取
创建PatternStream后，可以应用select 或fastselect方法，从检测到的事件序列中提取事件了。
select方法需要输入一个select function 作为参数，每个成功匹配的事件序列都会调用它。
select以一个Map[String, Iterable[IN]]来接收匹配到的事件序列，其中key就是每个模式的名称，而value就是所有接收到的事件的Iterable类型。
超时事件的提取
当一个模式通过within定义了检测窗口时间时，部分事件序列可能因为超过窗口长度而被丢弃；为了能够处理这些超时的部分匹配，select和flatSelect API调用允许指定超时处理程序。
超时处理程序会接收到目前为止由模式匹配到的所有事件，由一个OutputTag定义接收到的超时事件序列。
val patternStream: PatternStream[Event] = CEP.pattern(input, pattern)
val outputTag = OutputTag[String]("side-output")
val result = patternStream.select(outputTag){
(pattern: Map[String, Iterable[Event]], timestamp: Long) => TimeoutEvent()
} {
pattern: Map[String, Iterable[Event]] => ComplexEvent()
}
val timeoutResult: DataStream = result.getSideOutput(outputTag)
三.例子
//输入的登陆事件样例类
case class LoginEvent(userId: Long, ip: String, eventType: String, eventTime: Long)
//输出的异常报警信息样例类
case class Warning(userId: Long, firstFailTime: Long, lastFailTime: Long, warningMsg: String)
object LoginFailWithCep {
def main(args: Array[String]): Unit = {
val env = StreamExecutionEnvironment.getExecutionEnvironment
env.setParallelism(1)
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
// 1.读取事件数据，创建简单事件流
val resource = getClass.getResource("/LoginLog.csv")
val loginEventStream = env.readTextFile(resource.getPath)
.map(data => {
val dataArray = data.split(",")
LoginEvent(dataArray(0).trim.toLong, dataArray(1).trim, dataArray(2).trim, dataArray(3).trim.toLong)
})
.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[LoginEvent](Time.seconds(5)) {
override def extractTimestamp(t: LoginEvent): Long = {
t.eventTime * 1000L
}
}).keyBy(_.userId)
// 2.定义对应模式
val loginFailPattern = Pattern.begin[LoginEvent]("begin").where(_.eventType == "fail")
.next("next").where(_.eventType == "fail")
.within(Time.seconds(2))
// 3.在流上应用模式
val patternStream = CEP.pattern(loginEventStream, loginFailPattern)
// 4.从patternStream上应用select function，检出匹配的事件序列
val loginFailStream = patternStream.select(new LoginFailMatch())
loginFailStream.print()
env.execute("login fail with cep job")
}
}
class LoginFailMatch() extends PatternSelectFunction[LoginEvent, Warning] {
override def select(map: util.Map[String, util.List[LoginEvent]]): Warning = {
// 从map中按照名称取出对应的事件
val firstFail = map.get("begin").iterator().next()
val lastFail = map.get("next").iterator().next()
Warning(firstFail.userId, firstFail.eventTime, lastFail.eventTime, "login fail!")
}
}