Flink——CEP应用

一：Complex Event Processing. CEP
package com.loginfail
import java.util
import org.apache.flink.api.common.state.{ListState, ListStateDescriptor}
import org.apache.flink.cep.PatternSelectFunction
import org.apache.flink.cep.scala.{CEP, PatternStream}
import org.apache.flink.cep.scala.pattern.Pattern
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.KeyedProcessFunction
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.util.Collector
object LonginFailAdviceWithCEP {
case class LonginEvent(userId:Long,ip:String,eventType:String,timestamp:Long)
//输出报警信息样例类
case class LonginFailWarning(userId:Long,firstFailTime:Long,lastFailTime:Long,waringMsg:String)
def main(args: Array[String]): Unit = {
val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
val inputStream: DataStream[String] = env.readTextFile(“F:\UserBehaviorAnalysis\LongInFail\src\main\resources\LoginLog.csv”)
val loginStream: DataStream[LonginEvent] = inputStream.map(
data => {
val arr = data.split(",")
LonginEvent(arr(0).toLong, arr(1), arr(2), arr(3).toLong)
}
).assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractorLonginEvent {
override def extractTimestamp(element: LonginEvent): Long = element.timestamp*1000L
})
//使用CEP 首先定义模式
val parrern: Pattern[LonginEvent, LonginEvent] = Pattern
.beginLonginEvent.where(.eventType == “fail”)
.next(“secondFail”).where(.eventType == “fail”)
.within(Time.seconds(2))
//将模式云云到数据留上
val patternStream: PatternStream[LonginEvent] = CEP.pattern(loginStream.keyBy(_.userId),parrern)
val result: DataStream[LonginFailWarning] = patternStream.select(new LoginFailEventMatch())
result.print(“result”)
env.execute()
}
class LoginFailEventMatch() extends PatternSelectFunction[LonginEvent,LonginFailWarning]{
override def select(pattern: util.Map[String, util.List[LonginEvent]]): LonginFailWarning = {
val firstlonginEvent: LonginEvent = pattern.get(“firstFail”).get(0)
val secondlonginEvent: LonginEvent = pattern.get(“secondFail”).get(0)
LonginFailWarning(firstlonginEvent.userId,firstlonginEvent.timestamp,secondlonginEvent.timestamp,“fail”)
}
}
}

package com

import java.util

import org.apache.flink.cep.{PatternSelectFunction, PatternTimeoutFunction}
import org.apache.flink.cep.scala.{CEP, PatternStream}
import org.apache.flink.cep.scala.pattern.Pattern
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.windowing.time.Time

//订单超时事件处理
object OrderTimeout {
case class OrderEvent(orderId:Long,enentType:String,txId:String,timestamp:Long)
case class OrderResult(orderId:Long,resultMsg:String)
def main(args: Array[String]): Unit = {
val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
//0.得到数据yuan
val inputStream: DataStream[String] = env.readTextFile(“F:\UserBehaviorAnalysis\OrderPayDetect\src\main\resources\OrderLog.csv”)
val orderEventStream: KeyedStream[OrderEvent, Long] = inputStream.map(data => {
val arr = data.split(",")
OrderEvent(arr(0).toLong, arr(1), arr(2), arr(3).toLong)
}).assignAscendingTimestamps(.timestamp * 1000L)
.keyBy(.orderId)
val orderPayPattern: Pattern[OrderEvent, OrderEvent] = Pattern
.beginOrderEvent.where(.enentType == “create”)
//宽松紧邻
.followedBy(“pay”).where(.enentType == “pay”)
.within(Time.minutes(15))
val patternStream: PatternStream[OrderEvent] = CEP.pattern(orderEventStream,orderPayPattern)
//3.定义侧输出流标签 用于处理超时事件
val orderTimeoutOutputTag = new OutputTagOrderResult
val resultStream= patternStream.select(orderTimeoutOutputTag,
new OrderTimeoutSelect(),
new OrderPaySelect()
)
resultStream.print(“payed”)
resultStream.getSideOutput(orderTimeoutOutputTag).print(“timeout”)
env.execute()
}
class OrderTimeoutSelect() extends PatternTimeoutFunction[OrderEvent,OrderResult]{
override def timeout(pattern: util.Map[String, util.List[OrderEvent]], timeoutTimestamp: Long): OrderResult = {
val timeoutOrderId = pattern.get(“create”).iterator().next().orderId
OrderResult(timeoutOrderId,“timeout”+":"+timeoutTimestamp) //超时事件
}
}
class OrderPaySelect() extends PatternSelectFunction[OrderEvent,OrderResult]{
override def select(pattern: util.Map[String, util.List[OrderEvent]]): OrderResult = {
val payId: Long = pattern.get(“pay”).iterator().next().orderId
OrderResult(payId,“payed successfully”)
}
}
}