Flink之CEP(复杂时间处理)

Flink 复杂时间处理

CEP概述

• 复杂事件处理(Complex Event Processing,CEP)
• FLink CEP是在Flink中实现的复杂事件处理(CEP)库
• CEP允许在无休止的事件流中检测事件模式,让我们有机会掌握数据中重要的部分
• 一个或多个由简单事件构成的事件流通过一定的规则匹配,然后输出用户想要得到的数据-=-满足规则的复杂事件

CEP的特点

• 目标:从有序的简单事件流中发现的一些高阶特征
• 输入:一个或多个由简单事件构成的事件流
• 处理:识别简单事件之间的内在联系,多个符合一定规则的简单事件构成复杂事件
• 输出:满足规则的复杂事件

pattern API

• 处理事件的规则,被叫做"模式"(Pattern)
• Flink CEP 提供了Pattern API,用于对输入流数据进行复杂时间规则定义,用来提取符合规则的事件序列

// 1. 定义一个匹配模式
val orderPayPattern = Pattern.begin[OrderEvent]("begin").where(_.eventType == "create")
  .followedBy("follow").where(_.eventType == "pay")
  .within(Time.minutes(15))

// 2. 把模式应用到stream上，得到一个pattern stream
val patternStream = CEP.pattern(orderEventStream, orderPayPattern)

// 3. 调用select方法，提取事件序列，超时的事件要做报警提示
val orderTimeoutOutputTag = new OutputTag[OrderResult]("orderTimeout")

val resultStream = patternStream.select(orderTimeoutOutputTag,
  new OrderTimeoutSelect(),
  new OrderPaySelect())

• 个体模式(Individual Patterns)
  组成复杂规则的每一个单独的模式定义,就是"个体模式"

 .followedBy("follow").where(_.eventType == "pay")

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

1. 很多个体模式组合起来,就形成了整个模式序列
2. 模式序列必须以一个"初始模式"开始:

val orderPayPattern = Pattern.begin[OrderEvent]("begin").where(_.eventType == "create")

• 模式组(Groups of patterns)
  将一个模式序列作为条件嵌套在个体模式里,成为一组模式

val orderPayPattern = Pattern.begin[OrderEvent]("begin").where(_.eventType == "create")
  .followedBy("follow").where(_.eventType == "pay")
  .within(Time.minutes(15))

个体模式

个体模式可以包括"单例(sigleton)模式"和"循环(looping)模式",单例模式只能接收一个时间,而循环模式可以接收多个

量词(Quantifier)

可以在一个个体模式后追加量词,也就是指定循环次数

//匹配出现4次
start.times(4)
//匹配出现2/3/4次
start.time(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()来指定条件
• 按不同的调用方式,可以分成一下几类:

1.简单条件(Simple Condition)

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

 Pattern.begin[OrderEvent]("begin").where(_.eventType == "create")

2.组合条件(Combining Condition)

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

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

3.终止条件(Stop Condition)

如果使用了oneOrMore或者oneOrMore.optional,建议使用.until()作为终止条件,以便清理状态

4.迭代条件(Iterative Condition)

能够对模式之前所有接收的时间进行处理;
调用.where((value,ctx)=>{…}),可以调用ctx.getEventsForPattern(“name”)

模式序列

• 不同的近邻模式

上面是严格模式,下面是宽松近邻模式

• 严格近邻(Strict Contiguity)
  所有事件按照严格的顺序出现,中间没有任何不匹配的事件,由.next()指定,例如对于模式"a next b",事件序列[a,c,b1,b2]没有匹配
• 宽松近邻(Relaxed Contiguity)
  允许中间出现不匹配的事件,由.followedBy()指定,例如对于模式"a followedBy b",事件序列[a,c,b1,b2]匹配为[a,b1]
• 非确定性宽松近邻(Non-Deterministic Relaxed Contiguity)
  进一步放宽条件,之前已经匹配过的事件也可以再次使用,由.followByAny()指定,例如对于模式"a followedAny b",事件序列[a,c,b1,b2]匹配为{a,b1},{a,b2}
• 除了以上模式序列外,还可以定义"不希望出现某种近邻关系":
  notNext() 不严格近邻
  .notFollowedBy()不在两个事件之间发生

注意:

• 所有模式序列必须以.begin()开始
• 模式序列不能以.notFollowedBy()结束
• "not "类型的模式不能被optional 所修饰
• 此外,还可以为模式指定事件约束,用来要求在多长事件内匹配有效: next.within(Time.seconds(10))

模式的检测

• 指定要查找的模式序列后,就可以将其应用于输入流以检测潜在匹配
• 调用CEP.pattern(),给定输入流和模式,就能得到一个PatternStream

   val orderEventStream = env.socketTextStream("localhost", 7777)
      .map(data => {
        val dataArray = data.split(",")
        OrderEvent(dataArray(0).trim.toLong, dataArray(1).trim, dataArray(2).trim, dataArray(3).trim.toLong)
      })
      .assignAscendingTimestamps(_.eventTime * 1000L)
      .keyBy(_.orderId)

    // 2. 定义一个匹配模式
    val orderPayPattern = Pattern.begin[OrderEvent]("begin").where(_.eventType == "create")
      .followedBy("follow").where(_.eventType == "pay")
      .within(Time.minutes(15))

    // 3. 把模式应用到stream上，得到一个pattern stream
    val patternStream = CEP.pattern(orderEventStream, orderPayPattern)

事件提取select

匹配事件的提取

• 创建PatternStrean之后,就可以应用select或者flatselect方法,从检测到的事件序列中提取事件了
• select()方法需要输入一个select function作为参数,每个成功匹配的事件序列都会调用它
• select() 以一个Map[String,Iterable[IN]] 来接收匹配到的事件序列,其中Key就是每个模式的名称,而value就是所有接收到的事件的Iterable类型

def delectFn(pattern :Map[String,Iterable[IN]]):OUT={
val startEvent=pattern.get("start").get.next
val endEcent=pattern.get("end").get.next
OUT(startEvent,endEvent)
}

超时事件的提取

• 当一个模式通过within 关键字定义了检测窗口时间时,部分事件序列可能因为超过窗口长度而被丢弃,为了能够处理这些超时的部分匹配,select和flatSelect API调用允许指定超时处理程序
• 超时处理程序会接收到目前为止由模式匹配到的所有事件,由一个OutputTag定义接收到的超时事件序列
• 

select不同的调用方法

这里对第一种举例

// 定义输入订单事件的样例类
case class OrderEvent(orderId: Long, eventType: String, txId: String, eventTime: Long)

// 定义输出结果样例类
case class OrderResult(orderId: Long, resultMsg: String)

object OrderTimeout {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    env.setParallelism(1)

    // 1. 读取订单数据
    val resource = getClass.getResource("/OrderLog.csv")
    //    val orderEventStream = env.readTextFile(resource.getPath)
    val orderEventStream = env.socketTextStream("localhost", 7777)
      .map(data => {
        val dataArray = data.split(",")
        OrderEvent(dataArray(0).trim.toLong, dataArray(1).trim, dataArray(2).trim, dataArray(3).trim.toLong)
      })
      .assignAscendingTimestamps(_.eventTime * 1000L)
      .keyBy(_.orderId)

    // 2. 定义一个匹配模式
    val orderPayPattern = Pattern.begin[OrderEvent]("begin").where(_.eventType == "create")
      .followedBy("follow").where(_.eventType == "pay")
      .within(Time.minutes(15))

    // 3. 把模式应用到stream上，得到一个pattern stream
    val patternStream = CEP.pattern(orderEventStream, orderPayPattern)

    // 4. 调用select方法，提取事件序列，超时的事件要做报警提示
    val orderTimeoutOutputTag = new OutputTag[OrderResult]("orderTimeout")

    val resultStream = patternStream.select(orderTimeoutOutputTag,
      new OrderTimeoutSelect(),
      new OrderPaySelect())

    resultStream.print("payed")
    resultStream.getSideOutput(orderTimeoutOutputTag).print("timeout")

    env.execute("order timeout job")
  }
}

// 自定义超时事件序列处理函数
class OrderTimeoutSelect() extends PatternTimeoutFunction[OrderEvent, OrderResult] {
  override def timeout(map: util.Map[String, util.List[OrderEvent]], l: Long): OrderResult = {
    val timeoutOrderId = map.get("begin").iterator().next().orderId
    OrderResult(timeoutOrderId, "timeout")
  }
}

// 自定义正常支付事件序列处理函数
class OrderPaySelect() extends PatternSelectFunction[OrderEvent, OrderResult] {
  override def select(map: util.Map[String, util.List[OrderEvent]]): OrderResult = {
    val payedOrderId = map.get("follow").iterator().next().orderId
    OrderResult(payedOrderId, "payed successfully")
  }
}