Flink 从0 到 1 学习—— 第 十一 章 Flink的复杂事件处理机制CEP

最新推荐文章于 2022-06-17 06:24:55 发布
最新推荐文章于 2022-06-17 06:24:55 发布
阅读量378 收藏
点赞数 1
分类专栏： 大数据 flink 文章标签： flink 大数据 flinkcep
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dwjf321/article/details/109829672
版权

文章目录

1. CEP概念

CEP 是 Complex Event Processing 三个单词的缩写，表示复杂事件处理，是一种基于流处理的技术，CEP 是 Flink 专门为我们提供的一个基于复杂事件监测处理的库，CEP通过一个或多个由简单事件构成的事件流通过一定的规则匹配，然后输出用户想得到的数据，满足规则的复杂事件。

CEP复杂事件处理主要应用于防范网络欺诈、设备故障检测、风险规避和智能营销等领域。Flink 基于 DataStrem API 提供了 FlinkCEP 组件栈，专门用于对复杂事件的处理，帮助用户从流式数据中发掘有价值的信息。

  • 例如下图，我们就可以通过CEP实现我们对复杂事件的匹配处理

在这里插入图片描述

2. CEP的主要特点

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

    • 输入：一个或多个由简单事件构成的事件流
    • 处理：识别简单事件之间的内在联系，多个符合一定规则的简单事件构成复杂事件
    • 输出：满足规则的复杂事件

    在这里插入图片描述

3. Pattern API

  • FlinkCEP 中提供了 Pattern API 用于对输入流数据的复杂事件规则定义，并从事件流中抽取事件结果。
  • 包含四个步骤

    1. 输入事件流的创建

    2. Pattern 的定义

    3. Pattern 应用在事件流上检测

    4. 选取结果

1.3.1 输入事件流的创建

//获取数据输入流
val input: DataStream[Event] = ...

1.3.2 Pattern的定义

  • 定义 Pattern 可以是单次执行模式，也可以是循环执行模式。单次执行模式一次只接受 一个事件，循环执行模式可以接收一个或者多个事件。通常情况下，可以通过指定循环次数将单次执行模式变为循环执行模式。每种模式能够将多个条件组合应用到同一事件之上，条件组合可以通过 where 方法进行叠加。

  • 每个 Pattern 都是通过 begin 方法定义的

    val start = Pattern.begin[Event]("start_pattern")

  • 下一步通过 Pattern.where()方法在 Pattern 上指定 Condition，只有当 Condition 满足之后，当前的 Pattern 才会接受事件

    start.where(_.getID == "9527")
1.3.2.1 设置循环次数

对于已经创建好的 Pattern，可以指定循环次数，形成循环执行的 Pattern

  • times：可以通过 times 指定固定的循环执行次数

    //指定循环触发4次 
start.times(4); 
//可以执行触发次数范围,让循环执行次数在该范围之内 
start.times(2, 4);

  • optional：也可以通过 optional 关键字指定要么不触发，要么触发指定的次数

    start.times(4).optional()
start.times(2, 4).optional()

  • greedy：可以通过 greedy 将 Pattern 标记为贪婪模式，在 Pattern 匹配成功的前提下，会尽可能多次触发。

    //触发2、3、4次,尽可能重复执行 
start.times(2, 4).greedy()
//触发0、2、3、4次,尽可能重复执行 
start.times(2, 4).optional().greedy()

  • oneOrMore：可以通过 oneOrMore 方法指定触发一次或多次

    // 触发一次或者多次 
start.oneOrMore()
//触发一次或者多次,尽可能重复执行 
start.oneOrMore().greedy() 
// 触发0次或者多次 
start.oneOrMore().optional() 
// 触发0次或者多次,尽可能重复执行 
start.oneOrMore().optional().greedy()

  • timesOrMor：通过 timesOrMore 方法可以指定触发固定次数以上，例如执行两次以上

    // 触发两次或者多次 
start.timesOrMore(2);
// 触发两次或者多次,尽可能重复执行 
start.timesOrMore(2).greedy()
// 不触发或者触发两次以上,尽可能重执行 
start.timesOrMore(2).optional().greedy()
1.3.2.2 定义条件

每个模式都需要指定触发条件，作为事件进入到该模式是否接受的判断依据，当事件中的数值满足了条件时，便进行下一步操作。在 FlinkCFP 中通过 pattern.where()、 pattern.or()及pattern.until()方法来为 Pattern 指定条件，且 Pattern 条件有 Simple Conditions 及Combining Conditions 等类型

  • Simple Conditions（简单条件）

    其主要根据事件中的字段信息进行判断，决定是否接受该事件。

    // 把ID为9527的事件挑选出来
start.where(_.getID == "9527")

  • Combining Conditions（组合条件）

    是将简单条件进行合并，通常情况下也可以使用 where 方法进行条件的组合，默认每个条件通过 AND 逻辑相连。如果需要使用 OR 逻辑，直接使用 or 方法连接条件即可

    // 把ID为9527或者年龄大于30的事件挑选出来 
val start = Pattern.begin[Event]("start_pattern")
				 .where(_.callType=="success").or(_.age >30)

  • Stop condition （终止条件）

    如果程序中使用了 oneOrMore 或者 oneOrMore().optional()方法，还可以指定停止条件，否则模式中的规则会一直循环下去，如下终止条件通过 until()方法指定

    start.oneOrMore.until(_.getID == "123")
1.3.2.3 模式序列

将相互独立的模式进行组合然后形成模式序列。模式序列基本的编写方式和独立模式一 致，各个模式之间通过邻近条件进行连接即可，其中有严格邻近、宽松邻近、非确定宽松邻近三种邻近连接条件。

  • 严格邻近

    严格邻近条件中，需要所有的事件都按照顺序满足模式条件，不允许忽略任意不满足的模式

    next()

    //示例
begin("first").where(_.name='a').next("second").where(.name='b')
//当且仅当数据为a,b时，模式才会被命中。如果数据为a,c,b，由于a的后面跟了c，所以a会被直接丢弃，模式不会命中。

  • 宽松邻近

    在宽松邻近条件下，会忽略没有成功匹配模式条件，并不会像严格邻近要求得那么高，可以简单理解为 OR 的逻辑关系

    followedBy()

    //示例
begin("first").where(_.name='a').followedBy("second").where(.name='b')
//当且仅当数据为a,b或者为a,c,b，，模式均被命中，中间的c会被忽略掉。

  • 非确定宽松邻近

    和宽松邻近条件相比，非确定宽松邻近条件指在模式匹配过程中可以忽略已经匹配的条件

    followedByAny()

    //示例
begin("first").where(_.name='a').followedByAny("second").where(.name='b')
//当且仅当数据为a,c,b,b时，对于followedBy模式而言命中的为{a,b}，
//对于followedByAny而言会有两次命中{a,b},{a,b}

    在这里插入图片描述

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

    • notNext()
      • 不想让某个事件严格紧邻前一个事件发生
    • notFollowedBy()
      • 不想让某个事件在两个事件之间发生

  • 注意

    1、所有模式序列必须以 .begin() 开始

    2、模式序列不能以 .notFollowedBy() 结束

    3、“not” 类型的模式不能和optional关键字同时使用

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

    //指定模式在10秒内有效 
pattern.within(Time.seconds(10))

1.3.3 Pattern检测

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

    //Pattern检测
val patternStream = CEP.pattern[Event](dataStream,pattern)

1.3.4 选取结果

  • 得到 PatternStream 类型的数据集后，接下来数据获取都基于 PatternStream 进行。该数据集中包含了所有的匹配事件。目前在 FlinkCEP 中提供 select 和 flatSelect 两种方法从 PatternStream 提取事件结果。

  • 1、通过 Select Funciton 抽取正常事件

    可以通过在 PatternStream 的 Select 方法中传入自定义 Select Funciton 完成对匹配 事件的转换与输出。其中 Select Funciton 的输入参数为 Map[String, Iterable[IN]]，Map 中的 key 为模式序列中的 Pattern 名称，Value 为对应 Pattern 所接受的事件集合，格式为输入事件的数据类型。

    def selectFunction(pattern : Map[String, Iterable[IN]]): OUT = {
    //获取pattern中的start
     Event val startEvent = pattern.get("start_pattern").get.next
    //获取Pattern中middle
    Event val middleEvent = pattern.get("middle").get.next 
    //返回结果 
    OUT(startEvent, middleEvent)

}

  • 2、通过 Flat Select Funciton 抽取正常事件

    Flat Select Funciton 和 Select Function 相似，不过 Flat Select Funciton 在每次调用可以返回任意数量的结果。因为 Flat Select Funciton 使用 Collector 作为返回结果的容器，可以将需要输出的事件都放置在 Collector 中返回。

    def flatSelectFunction(pattern : Map[String, Iterable[IN]]),collector:Collector[OUT] = {
    //获取pattern中的start
     Event val startEvent = pattern.get("start_pattern").get.next
    //获取Pattern中middle
    Event val middleEvent = pattern.get("middle").get.next 
    //并根据startEvent的Value数量进行返回
    for (i <- 0 to startEvent.getValue) { 
        collector.collect(OUT(startEvent, middleEvent)) }
	}
}

  • 3、通过 Select Funciton 抽取超时事件

    如果模式中有 within(time)，那么就很有可能有超时的数据存在，通过 PatternStream，Select 方法分别获取超时事件和正常事件。首先需要创建 OutputTag 来标记超时事件，然后在 PatternStream.select 方法中使用 OutputTag，就可以将超时事件从 PatternStream中抽取出来。

    // 通过CEP.pattern方法创建PatternStream 
val patternStream: PatternStream[Event] = CEP.pattern(input, pattern) 

//创建OutputTag,并命名为timeout-output 
val timeoutTag = OutputTag[String]("timeout-output") 

//调用PatternStream select()并指定timeoutTag 
val result: SingleOutputStreamOperator[NormalEvent] = patternStream.select(timeoutTag){ 
//超时事件获取 
(pattern: Map[String, Iterable[Event]], timestamp: Long) =>
	TimeoutEvent() //返回异常事件
 } 
 { 
 //正常事件获取 
 pattern: Map[String, Iterable[Event]] =>
 	NormalEvent()//返回正常事件 
 } 
 //调用getSideOutput方法,并指定timeoutTag将超时事件输出 
 val timeoutResult: DataStream[TimeoutEvent] = result.getSideOutput(timeoutTag)

4. CEP编程开发案例实战——银行APP 登录异常检测

  • 描述

    • 在我们操作某些银行APP的时候，经常会发现，如果上一个操作与下一个操作IP变换了（例如上一个操作使用的流量操作，下一个操作我连接上了wifi去操作，IP就会变换），那么APP就要求我们重新进行登录，避免由于IP变换产生的风险操作

  • 需求

    • 用户上一个操作与下一个操作IP变换报警

  • 数据格式如下

    • 从socket当中输入数据源
    192.168.52.100,zhubajie,https://icbc.com.cn/login.html,2020-02-12 12:23:45
192.168.54.172,tangseng,https://icbc.com.cn/login.html,2020-02-12 12:23:46
192.168.145.77,sunwukong,https://icbc.com.cn/login.html,2020-02-12 12:23:47
192.168.52.100,zhubajie,https://icbc.com.cn/transfer.html,2020-02-12 12:23:47
192.168.54.172,tangseng,https://icbc.com.cn/transfer.html,2020-02-12 12:23:48
192.168.145.77,sunwukong,https://icbc.com.cn/transfer.html,2020-02-12 12:23:49
192.168.145.77,sunwukong,https://icbc.com.cn/save.html,2020-02-12 12:23:52
192.168.52.100,zhubajie,https://icbc.com.cn/save.html,2020-02-12 12:23:53
192.168.54.172,tangseng,https://icbc.com.cn/save.html,2020-02-12 12:23:54
192.168.54.172,tangseng,https://icbc.com.cn/buy.html,2020-02-12 12:23:57
192.168.145.77,sunwukong,https://icbc.com.cn/buy.html,2020-02-12 12:23:58
192.168.52.100,zhubajie,https://icbc.com.cn/buy.html,2020-02-12 12:23:59
192.168.44.110,zhubajie,https://icbc.com.cn/pay.html,2020-02-12 12:24:03
192.168.38.135,tangseng,https://icbc.com.cn/pay.html,2020-02-12 12:24:04
192.168.89.189,sunwukong,https://icbc.com.cn/pay.html,2020-02-12 12:24:05
192.168.44.110,zhubajie,https://icbc.com.cn/login.html,2020-02-12 12:24:04
192.168.38.135,tangseng,https://icbc.com.cn/login.html,2020-02-12 12:24:08
192.168.89.189,sunwukong,https://icbc.com.cn/login.html,2020-02-12 12:24:07
192.168.38.135,tangseng,https://icbc.com.cn/pay.html,2020-02-12 12:24:10
192.168.44.110,zhubajie,https://icbc.com.cn/pay.html,2020-02-12 12:24:06
192.168.89.189,sunwukong,https://icbc.com.cn/pay.html,2020-02-12 12:24:09
192.168.38.135,tangseng,https://icbc.com.cn/pay.html,2020-02-12 12:24:13
192.168.44.110,zhubajie,https://icbc.com.cn/pay.html,2020-02-12 12:24:12
192.168.89.189,sunwukong,https://icbc.com.cn/pay.html,2020-02-12 12:24:15
    • 整理之后的格式如下：
    192.168.145.77,sunwukong,https://icbc.com.cn/login.html,2020-02-12 12:23:47
192.168.145.77,sunwukong,https://icbc.com.cn/transfer.html,2020-02-12 12:23:49
192.168.145.77,sunwukong,https://icbc.com.cn/save.html,2020-02-12 12:23:52
192.168.145.77,sunwukong,https://icbc.com.cn/buy.html,2020-02-12 12:23:58
192.168.89.189,sunwukong,https://icbc.com.cn/pay.html,2020-02-12 12:24:05
192.168.89.189,sunwukong,https://icbc.com.cn/login.html,2020-02-12 12:24:07
192.168.89.189,sunwukong,https://icbc.com.cn/pay.html,2020-02-12 12:24:09
192.168.89.189,sunwukong,https://icbc.com.cn/pay.html,2020-02-12 12:24:15

192.168.52.100,zhubajie,https://icbc.com.cn/login.html,2020-02-12 12:23:45
192.168.52.100,zhubajie,https://icbc.com.cn/transfer.html,2020-02-12 12:23:47
192.168.52.100,zhubajie,https://icbc.com.cn/save.html,2020-02-12 12:23:53
192.168.52.100,zhubajie,https://icbc.com.cn/buy.html,2020-02-12 12:23:59
192.168.44.110,zhubajie,https://icbc.com.cn/pay.html,2020-02-12 12:24:03
192.168.44.110,zhubajie,https://icbc.com.cn/login.html,2020-02-12 12:24:04
192.168.44.110,zhubajie,https://icbc.com.cn/pay.html,2020-02-12 12:24:06
192.168.44.110,zhubajie,https://icbc.com.cn/pay.html,2020-02-12 12:24:12

192.168.54.172,tangseng,https://icbc.com.cn/login.html,2020-02-12 12:23:46
192.168.54.172,tangseng,https://icbc.com.cn/transfer.html,2020-02-12 12:23:48
192.168.54.172,tangseng,https://icbc.com.cn/save.html,2020-02-12 12:23:54
192.168.54.172,tangseng,https://icbc.com.cn/buy.html,2020-02-12 12:23:57
192.168.38.135,tangseng,https://icbc.com.cn/pay.html,2020-02-12 12:24:04
192.168.38.135,tangseng,https://icbc.com.cn/login.html,2020-02-12 12:24:08
192.168.38.135,tangseng,https://icbc.com.cn/pay.html,2020-02-12 12:24:10
192.168.38.135,tangseng,https://icbc.com.cn/pay.html,2020-02-12 12:24:13

4.1 使用State编程实现

  • 代码开发

    package com.flink.cep

import java.util
import java.util.Collections

import org.apache.flink.api.common.state.{ListState, ListStateDescriptor}
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.functions.KeyedProcessFunction
import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}
import org.apache.flink.util.Collector

/**
  * 使用state编程进行代码实现进行ip检测
  */

case class UserLogin(ip:String,username:String,operateUrl:String,time:String)

object CheckIPChangeWithState {

  def main(args: Array[String]): Unit = {
      
    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    import org.apache.flink.api.scala._

    //todo:1、接受socket数据源
    val sourceStream: DataStream[String] = environment.socketTextStream("node01",9999)

    //todo:2、数据处理
    sourceStream.map(x =>{
      val strings: Array[String] = x.split(",")
      (strings(1),UserLogin(strings(0),strings(1),strings(2),strings(3)))
    } ).keyBy(x => x._1)
      .process(new LoginCheckProcessFunction)
      .print()
    environment.execute("checkIpChange")


  }
}
//自定义KeyedProcessFunction类
class LoginCheckProcessFunction extends KeyedProcessFunction[String,(String,UserLogin),(String,UserLogin)]{

   //定义ListState
   var listState:ListState[UserLogin]=_

  override def open(parameters: Configuration): Unit = {
    listState = getRuntimeContext.getListState(new ListStateDescriptor[UserLogin]("changeIp",classOf[UserLogin]))

  }

  //解析用户访问信息
  override def processElement(value: (String, UserLogin), ctx: KeyedProcessFunction[String, (String, UserLogin), (String, UserLogin)]#Context, out: Collector[(String, UserLogin)]): Unit = {
    val logins = new util.ArrayList[UserLogin]()

    //添加到list集合
     listState.add(value._2)

    import scala.collection.JavaConverters._
    val toList: List[UserLogin] = listState.get().asScala.toList
     //排序
    val sortList: List[UserLogin] = toList.sortBy(_.time)

    if(sortList.size ==2){
      val first: UserLogin = sortList(0)
      val second: UserLogin = sortList(1)

      if(!first.ip.equals(second.ip)){
        println("小伙子你的IP变了，赶紧回去重新登录一下")
      }
      //移除第一个ip，保留第二个ip
      logins.removeAll(Collections.EMPTY_LIST)
      logins.add(second)
      listState.update(logins)
    }

     out.collect(value)

  }

}

4.2 使用CEP编程实现

  • 导入cep依赖

    <dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-cep-scala_2.12</artifactId>
    <version>1.10.2</version>
</dependency>

  • 代码开发

    package com.flink.cep

import java.util

import org.apache.flink.cep.PatternSelectFunction
import org.apache.flink.cep.pattern.conditions.IterativeCondition
import org.apache.flink.cep.scala.{CEP, PatternStream}
import org.apache.flink.cep.scala.pattern.Pattern
import org.apache.flink.streaming.api.scala.{DataStream, KeyedStream, StreamExecutionEnvironment}
import org.apache.flink.streaming.api.windowing.time.Time

import scala.collection.mutable

/**
  *使用 CEP 编程进行代码实现进行ip检测
  */

case class UserLoginInfo(ip:String,username:String,operateUrl:String,time:String)
object CheckIPChangeWithCEP {

  def main(args: Array[String]): Unit = {
    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    import org.apache.flink.api.scala._

    //todo:1、接受socket数据源
    val sourceStream: DataStream[String] = environment.socketTextStream("hadoop102",9999)

    //todo:2、数据处理
    val keyedStream: KeyedStream[(String, UserLoginInfo), String] = sourceStream.map(x => {
                       val strings: Array[String] = x.split(",")
                      (strings(1), UserLoginInfo(strings(0), strings(1), strings(2), strings(3)))
            }).keyBy(_._1)


   //todo:3、定义Pattern,指定相关条件和模型序列
    val pattern: Pattern[(String, UserLoginInfo), (String, UserLoginInfo)] = Pattern.begin[(String, UserLoginInfo)]("start")
          .where(x => x._2.username != null)
          .next("second")
          .where(new IterativeCondition[(String, UserLoginInfo)] {
            override def filter(value: (String, UserLoginInfo), context: IterativeCondition.Context[(String, UserLoginInfo)]): Boolean = {
              var flag: Boolean = false
              //获取满足前面条件的数据
              val firstValues: util.Iterator[(String, UserLoginInfo)] = context.getEventsForPattern("start").iterator()
              //遍历
              while (firstValues.hasNext) {
                val tuple: (String, UserLoginInfo) = firstValues.next()
                //ip不相同
                if (!tuple._2.ip.equals(value._2.ip)) {
                  flag = true
                }
              }

              flag
            }
          })
        //可以指定模式在一段时间内有效
      .within(Time.seconds(120))

    //todo:4、模式检测，将模式应用到流中
     val patternStream: PatternStream[(String, UserLoginInfo)] = CEP.pattern(keyedStream,pattern)


    //todo: 5、选取结果
     patternStream.select(new MyPatternSelectFunction).print()


    //todo: 6、开启计算
    environment.execute()

  }

}

//自定义PatternSelectFunction类
class MyPatternSelectFunction extends PatternSelectFunction[(String,UserLoginInfo),(String,UserLoginInfo)]{
  override def select(map: util.Map[String, util.List[(String, UserLoginInfo)]]): (String, UserLoginInfo) = {
        // 获取Pattern名称为start的事件
         val startIterator= map.get("start").iterator()

         if(startIterator.hasNext){
            println("满足start模式中的数据："+startIterator.next())
         }


        //获取Pattern名称为second的事件
         val secondIterator = map.get("second").iterator()


        var tuple:(String,UserLoginInfo)=null

        if(secondIterator.hasNext){
            tuple=secondIterator.next()
            println("满足second模式中的数据："+ tuple)
        }

    tuple
  }
}

5. Flink CEP综合案例实战——传感器温度检测

  • 场景介绍

    • 现在工厂当中有大量的传感设备，用于检测机器当中的各种指标数据，例如温度，湿度，气压等，并实时上报数据到数据中心，现在需要检测，某一个传感器上报的温度数据是否发生异常。

  • 异常的定义

    • 三分钟时间内，出现三次及以上的温度高于40度就算作是异常温度，进行报警输出

  • 收集数据如下：

    传感器设备mac地址，检测机器mac地址，温度，湿度，气压，数据产生时间

00-34-5E-5F-89-A4,00-01-6C-06-A6-29,38,0.52,1.1,2020-03-02 12:20:32
00-34-5E-5F-89-A4,00-01-6C-06-A6-29,47,0.48,1.1,2020-03-02 12:20:35
00-34-5E-5F-89-A4,00-01-6C-06-A6-29,50,0.48,1.1,2020-03-02 12:20:38
00-34-5E-5F-89-A4,00-01-6C-06-A6-29,48,0.48,1.1,2020-03-02 12:20:39
00-34-5E-5F-89-A4,00-01-6C-06-A6-29,52,0.48,1.1,2020-03-02 12:20:41
00-34-5E-5F-89-A4,00-01-6C-06-A6-29,53,0.48,1.1,2020-03-02 12:20:43
00-34-5E-5F-89-A4,00-01-6C-06-A6-29,55,0.48,1.1,2020-03-02 12:20:45

  • 代码开发实现：

package com.flink.cep


import java.util

import org.apache.commons.lang3.time.FastDateFormat
import org.apache.flink.cep.PatternSelectFunction
import org.apache.flink.cep.scala.pattern.Pattern
import org.apache.flink.cep.scala.{CEP, PatternStream}
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.scala.{DataStream, KeyedStream, StreamExecutionEnvironment}
import org.apache.flink.streaming.api.windowing.time.Time

//定义温度信息pojo
case class DeviceDetail(sensorMac:String,deviceMac:String,temperature:String,dampness:String,pressure:String,date:String)

//报警的设备信息样例类
//传感器设备mac地址，检测机器mac地址，温度
case class AlarmDevice(sensorMac:String,deviceMac:String,temperature:String)

/**
  * 基于FlinkCEP的设备温度检测
  */
object FlinkTempeatureCEP {

  private val format: FastDateFormat = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss")
  def main(args: Array[String]): Unit = {
    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //指定时间类型
    environment.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    environment.setParallelism(1)
    import org.apache.flink.api.scala._

    //接受数据
    val sourceStream: DataStream[String] = environment.socketTextStream("hadoop102",9999)

    val deviceStream: KeyedStream[DeviceDetail, String] = sourceStream.map(x => {
        val strings: Array[String] = x.split(",")
        DeviceDetail(strings(0), strings(1), strings(2), strings(3), strings(4), strings(5))
    }).assignAscendingTimestamps(x =>{format.parse(x.date).getTime})
      .keyBy(x => x.sensorMac)


     //todo:定义Pattern,指定相关条件和模型序列
    val pattern: Pattern[DeviceDetail, DeviceDetail] = Pattern.begin[DeviceDetail]("start")
                   .where(x =>x.temperature.toInt >= 40)                                               .followedByAny("follow")
                    .where(x =>x.temperature.toInt >= 40)                                             .followedByAny("follow")
                    .where(x =>x.temperature.toInt >= 40)                                             .within(Time.minutes(3))

    //todo:模式检测，将模式应用到流中
    val patternResult: PatternStream[DeviceDetail] = CEP.pattern(deviceStream,pattern)

    //todo:选取结果
    patternResult.select(new MyPatternResultFunction).print()

    //todo: 启动
    environment.execute("startTempeature")

  }
}

//自定义PatternSelectFunction
class MyPatternResultFunction extends PatternSelectFunction[DeviceDetail,AlarmDevice]{
  override def select(pattern: util.Map[String, util.List[DeviceDetail]]): AlarmDevice = {
    val startDetails: util.List[DeviceDetail] = pattern.get("start")
    val followDetails: util.List[DeviceDetail] = pattern.get("follow")
    val thirdDetails: util.List[DeviceDetail] = pattern.get("third")

   val startResult: DeviceDetail = startDetails.iterator().next()
    val followResult: DeviceDetail = followDetails.iterator().next()
    val thirdResult: DeviceDetail = thirdDetails.iterator().next()

    println("第一条数据: "+startResult)
    println("第二条数据: "+followResult)
    println("第三条数据: "+thirdResult)

    AlarmDevice(thirdResult.sensorMac,thirdResult.deviceMac,thirdResult.temperature)
  }
}

6. Flink CEP综合案例实战——监控订单状态

  • 场景介绍

    • 在我们的电商系统当中，经常会发现有些订单下单之后没有支付，就会有一个倒计时的时间值，提示你在15分钟之内完成支付，如果没有完成支付，那么该订单就会被取消，主要是因为拍下订单就会减库存，但是如果一直没有支付，那么就会造成库存没有了，别人购买的时候买不到，然后别人一直不支付，就会产生有些人买不到，有些人买到了不付款，最后导致商家一件产品都卖不出去

  • 需求

    • 创建订单之后15分钟之内一定要付款，否则就取消订单

  • 订单数据格式如下类型字段说明

    • 订单编号

    • 订单状态

      • 1.创建订单,等待支付
      • 2.支付订单完成
      • 3.取消订单，申请退款
      • 4.已发货
      • 5.确认收货，已经完成

    • 订单创建时间

    • 订单金额

      20160728001511050311389390,1,2016-07-28 00:15:11,295
20160801000227050311955990,1,2016-07-28 00:16:12,165
20160728001511050311389390,2,2016-07-28 00:18:11,295
20160801000227050311955990,2,2016-07-28 00:18:12,165
20160728001511050311389390,3,2016-07-29 08:06:11,295
20160801000227050311955990,4,2016-07-29 12:21:12,165
20160804114043050311618457,1,2016-07-30 00:16:15,132
20160801000227050311955990,5,2016-07-30 18:13:24,165

  • 规则，出现 1 创建订单标识之后，紧接着需要在15分钟之内出现 2 支付订单操作，中间允许有其他操作

  • 代码开发实现

package com.flink.cep

import java.util

import org.apache.commons.lang3.time.FastDateFormat
import org.apache.flink.cep.{PatternSelectFunction, PatternTimeoutFunction}
import org.apache.flink.cep.scala.{CEP, PatternStream, pattern}
import org.apache.flink.cep.scala.pattern.Pattern
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor
import org.apache.flink.streaming.api.scala.{DataStream, KeyedStream, OutputTag, StreamExecutionEnvironment}
import org.apache.flink.streaming.api.windowing.time.Time


/**
  *  订单下单未支付检测
  */

case class OrderDetail(orderId:String,status:String,orderCreateTime:String,price :Double)

object OrderTimeOutCheckCEP {

  private val format: FastDateFormat = FastDateFormat.getInstance("yyy-MM-dd HH:mm:ss")

  def main(args: Array[String]): Unit = {

    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    environment.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    environment.setParallelism(1)
    import org.apache.flink.api.scala._
    val sourceStream: DataStream[String] = environment.socketTextStream("node01",9999)

    val keyedStream: KeyedStream[OrderDetail, String] = sourceStream.map(x => {
      val strings: Array[String] = x.split(",")
      OrderDetail(strings(0), strings(1), strings(2), strings(3).toDouble)

    }).assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[OrderDetail](Time.seconds(5)){
      override def extractTimestamp(element: OrderDetail): Long = {
        format.parse(element.orderCreateTime).getTime
      }
    }).keyBy(x => x.orderId)

     //定义Pattern模式，指定条件
    val pattern: Pattern[OrderDetail, OrderDetail] = Pattern.begin[OrderDetail]("start")
                                                            .where(order => order.status.equals("1"))
                                                            .followedBy("second")
                                                            .where(x => x.status.equals("2"))
                                                            .within(Time.minutes(15))


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

    val patternStream: PatternStream[OrderDetail] = CEP.pattern(keyedStream,pattern)
    val selectResultStream: DataStream[OrderDetail] = patternStream
            .select(orderTimeoutOutputTag, new OrderTimeoutPatternFunction, new OrderPatternFunction)

     selectResultStream.print()

    //打印侧输出流数据 过了15分钟还没支付的数据
    selectResultStream.getSideOutput(orderTimeoutOutputTag).print()
    environment.execute()
  }
}

//订单超时检测
class OrderTimeoutPatternFunction extends PatternTimeoutFunction[OrderDetail,OrderDetail]{

  override def timeout(pattern: util.Map[String, util.List[OrderDetail]], l: Long): OrderDetail = {
    val detail: OrderDetail = pattern.get("start").iterator().next()
        println("超时订单号为" + detail)
        detail
  }
}


class OrderPatternFunction extends PatternSelectFunction[OrderDetail,OrderDetail] {
  override def select(pattern: util.Map[String, util.List[OrderDetail]]): OrderDetail = {
        val detail: OrderDetail = pattern.get("second").iterator().next()
        println("支付成功的订单为" + detail)
        detail
  }
}
dwjf321
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一个Flink-Cep使用案例
微信搜：import_bigdata，大数据领域硬核原创作者
08-29 1116
声明：本系列博客部分是根据SGG的视频整理而成，非常适合大家入门学习。部分文章是通过爬虫等技术手段采集的，目的是学习分享，如果有版权问题请留言，随时删除。 《2021年最新版大数据面试题全面开启更新》 本篇主要演练使用Flink-Cep+Groovy+Aviator 来实现一个物联网监控规则中的一个场景案例，后续将会介绍如何实现规则动态变更。 技术背景简介 Flink-Cep 是flink中的高级library，用于进行复杂事件处理，例如某一类事件连续出现三次就触发告警，可以类比Siddhi、E
【Flink】Flink CEP 案例
九师兄
07-01 569
1.案例 我们先产生一个输入流，这个输入Event流由Event对象和event time组成，那么要使用EventTime，除了指定TimeCharacteristic外，在Flink中还要assignTimestampsAndWatermarks，其中分别定义了Eventtime和WaterMark， /** * 测试结果： * {start=[Event(id=1, name=start, money=1.0)], middle=[Event(id=5, name=middl.
flink CEP示例
a3125504x的博客
10-01 1002
CEP示例三分钟时间内，出现三次及以上的温度高于40度就算作是异常温度，进行报警输出创建订单之后15分钟之内一定要付款，否则就取消订单 三分钟时间内，出现三次及以上的温度高于40度就算作是异常温度，进行报警输出 场景介绍 现在工厂当中有大量的传感设备，用于检测机器当中的各种指标数据，例如温度，湿度，气压等，并实时上报数据到数据中心，现在需要检测，某一个传感器上报的温度数据是否发生异常。 异常的定义 三分钟时间内，出现三次及以上的温度高于40度就算作是异常温度，进行报警输出 测试数据
Flink_CEP 功能和简单案例
weixin_45417821的博客
03-15 675
文章目录FlinkCEP——Flink的复杂事件处理FlinkCEP 简单流程Pattern API个体模式(Individual Patterns)量词条件模式组(Groups of Patterns)近邻引入 FlinkCEP——Flink的复杂事件处理 FlinkCEP是在Flink之上实现的复杂事件处理 （CEP）库。它使您可以检查无穷无尽的事件流的事件模型，从而使您有机会掌握数据中的重要信息 FlinkCEP 简单流程 DataStream<Event> input = ... Pa
Flink的CEP使用流程+使用案例
haibucuoba的博客
07-23 6187
一、CEP 一个或多个由简单事件构成的事件流通过一定的规则匹配，然后输出用户想得到的数据，满足规则的复杂事件。 CEP支持在流上进行模式匹配，根据模式的条件不同，分为连续的条件或不连续的条件；模式的条件允许有时间的限制，当在条件范围内没有达到满足的条件时，会导致模式匹配超时。 、 CEP就相当于在流上对event进行模式匹配。比如 连续两条登录失败日志不超过2秒，则进行错误预...
【Flink篇11】Flink之CEP复杂时间处理1
08-04
在Flink中，复杂事件处理（Complex Event Processing，简称CEP）是一个重要的特性，它允许开发者从大量的实时事件流中识别出具有特定模式的复杂事件。在本文中，我们将深入探讨Flink的CEP功能。 CEP的核心概念是...
Flink CEP学习线路指导1：Flink CEP入门
01-07
1.Flink CEP是什么？2.Flink CEP可以做哪些事情？3.Flink CEP和流式处理有什么区别？4.Flink CEP实现方式有哪些？ Flink CEP在Flink里面还是比较难以理解的。有的老铁甚至以为和Flink流式处理是差不多的。其实Flink ...
Flink CEP兵书
06-16
Flink CEP兵书全面系统的介绍Flink CEP...分别讲解了：Flink CEP与流式处理的区别、原理、api讲解、Flink CEP各种模式、跳过策略、模式匹配、水位线的讲解等内容。以及在代码例子中，给大家提供了代码实现及代码讲解。
Flink动态CEP，来自啤酒鸭
最新发布
09-19
标题中的“Flink动态CEP”指的是Apache Flink中用于处理事件流的复杂事件处理（Complex Event Processing，简称CEP）功能，而“动态”则意味着这种处理方式具有灵活性和可适应性，能够应对流数据中模式的变化。Flink...
Apache FlinkCEP 实现超时状态监控的步骤详解
09-14
Apache Flink CEP，全称为Complex Event Processing，是一种强大的工具，用于从连续的数据流中识别出复杂的模式。在实时数据处理场景中，如订单管理、交通监控或物流追踪，超时状态监控是一个关键功能，它可以帮助...
FlinkCEP - Flink的复杂事件处理
京河小蚁的博客
06-17 1208
FlinkCEP是在Flink上层实现的复杂事件处理库。 它可以让你在无限事件流中检测出特定的事件模型，有机会掌握数据中重要的那部分。 如果需要其它依赖，请参照案例地址 模式（pattern） API 模式API可以让你定义想从输入流中抽取的复杂模式序列。每个复杂的模式序列包括多个简单的模式，比如，寻找拥有相同属性事件序列的模式。从现在开始，我们把这些简单的模式称作模式， 把我们在数据流中最终寻找的复杂模式序列称作模式序列，你可以把模式序列看作是这样的模式构成的图， 这些模式基于用户指定的条件从一个转换到另
Flink-1.12.0 CEP详解与实战
喜讯XiCent 的博客
02-19 1606
什么是CEP CEP(Complex Event Processing)，复杂事件处理，一个或多个由简单事件构成的事件流通过一定的规则匹配，然后输出用户想得到的数据，满足规则的复杂事件。 Flink CEP简介 Flink CEP是在flink中实现的复杂事件处理库，也就是说搭配Flink实时处理的能力，FLink CEP能够在流处理的场景去做一些实时的复杂事件匹配，特点是能够作用于一个无限的数据流上，这就意味着它可以将某种规则的数据匹配一只保持下去； 举个例子： 下图中原始流包含了各种形状的图形，并且是杂
各种示例让你学会Flink复杂事件模式CEP
Bulut0907
12-20 1012
目录1. 什么是Flink CEP2. CEP的使用准备3. Individual Patterns(单个模式)3.1 times和oneOrMore(不连续匹配) 1. 什么是Flink CEP 从DataStream中检测出符合特定规则的数据结果，如下图所示DataStream中元素是各种形状，我们想检测长方形后面跟着椭圆形这样一个规则，最后得到两次检测结果 2. CEP的使用准备 pom.xml <dependency> <groupId>org.apache.fli
视频教程-Flink CEP兵书-大数据
weixin_33833830的博客
05-28 650
Flink CEP兵书 about云首席讲师，多年软件开发经验，曾担任项目经...
案例简介flink CEP
大数据星球-浪尖
11-04 5256
随着无处不在的传感器网络和智能设备不断收集越来越多的数据，我们面临着以近实时的方式分析不断增长的数据流的挑战。 能够快速响应不断变化的趋势或提供最新的商业智能可能是公司成...
Flink CEP 订单案例
qq_31866793的博客
08-29 1090
1，下面代码要注意的点： 1）函数可能会报错，需要引入scala Map 2）以为我们的条件是next 严格相邻，所以第一条数据会被过滤掉不满足条件，它不会出现在测流，就是被过滤掉了，如果想要测流拿到不满足的数据，正常应该用followBy或者其他模式; 2，具体代码 package com.coder.flink.core.a_bilibili import org....
flink cep 案例之机架温度监控报警
公众号[大数据技术与应用实战]，分享大数据实战案例
12-04 2656
记录下需要学习的相关知识点 1.watermark原理,设置水印的方法，分布式情况下水印的处理 2.分布式快照算法 3.window 4.自定义udf 5.sql、table 6.异步io 7.机器学习 8.流处理和批处理的api 9.checkpoint，savepoint 10.flink执行job流程 11.flink的资源管理 12.状态管理 13.join 14.Event Time 1...
Flink：从起源到阿里巴巴Blink的崛起与实战应用
Apache Flink是一个强大的框架和分布式处理引擎，专注于对无界和有界数据流进行实时和有状态的计算。它最初源于2010年至2014年的Stratosphere项目，该项目旨在研究高效的数据流处理技术。2014年，该项目的核心开发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值