Flink_订单支付_sucess+process处理

一：

package com.orderpay

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

case class OrderEvent(orderId:Long,eventType:String,txId:String,timestamp:Long)
case class OrderResrult(orderId:Long,resultMsg:String)
//业务场景
object OrderTimeout {
def main(args: Array[String]): Unit = {
val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
env.setParallelism(1)
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
val inputStream: DataStream[String] = env.readTextFile(“in/OrderLog.csv”)
val orderStream: DataStream[OrderEvent] = inputStream.map(
data => {
val arr: Array[String] = data.split(",")
OrderEvent(arr(0).toLong, arr(1), arr(2), arr(3).toLong)
}
).assignAscendingTimestamps(.timestamp * 1000L)
val keyedStream: KeyedStream[OrderEvent, Long] = orderStream.keyBy(.orderId)
val orderPayPattern: Pattern[OrderEvent, OrderEvent] = Pattern
.beginOrderEvent.where(.eventType == “create”)
.followedBy(“pay”).where(.eventType == “pay”)
.within(Time.minutes(5))
val parrernStream: PatternStream[OrderEvent] = CEP.pattern(keyedStream,orderPayPattern)
//3.定义侧输出流标签用于处理超时时间
val orderTimeoutOutputTag = new OutputTagOrderResrult
val resultStream: DataStream[OrderResrult] = parrernStream.select(orderTimeoutOutputTag,
new OrderTimeoutSelect(),
new OrderPaySelect()
)
resultStream.print(“payed”)
resultStream.getSideOutput(orderTimeoutOutputTag).print(“timeout”)
env.execute("")

}
}
//自定义
class OrderTimeoutSelect() extends PatternTimeoutFunction[OrderEvent,OrderResrult]{
override def timeout(pattern: util.Map[String, util.List[OrderEvent]], timeoutTimestamp: Long): OrderResrult = {
val timeOutOrderId: Long = pattern.get(“create”).iterator().next().orderId
OrderResrult(timeOutOrderId,“timeout”+":+"+timeoutTimestamp)
}
}
class OrderPaySelect() extends PatternSelectFunction[OrderEvent,OrderResrult]{
override def select(pattern: util.Map[String, util.List[OrderEvent]]): OrderResrult = {
val payedOrderid: Long = pattern.get(“pay”).iterator().next().orderId
OrderResrult(payedOrderid,“payed successfully”)
}
}

package com.orderpay

import org.apache.flink.api.common.state.{ValueState, ValueStateDescriptor}
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.KeyedProcessFunction
import org.apache.flink.streaming.api.scala._
import org.apache.flink.util.Collector

object OrderTeimoutWithState {
def main(args: Array[String]): Unit = {
val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
env.setParallelism(1)
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
val inputStream: DataStream[String] = env.readTextFile(“in/OrderLog.csv”)
val orderStream: DataStream[OrderEvent] = inputStream.map(
data => {
val arr: Array[String] = data.split(",")
OrderEvent(arr(0).toLong, arr(1), arr(2), arr(3).toLong)
}
).assignAscendingTimestamps(.timestamp * 1000L)
val resultSt: DataStream[OrderResrult] = orderStream
.keyBy(.orderId)
.process(new OrderPayMatchResult())
val timeOutStream: DataStream[OrderResrult] = resultSt.getSideOutput(new OutputTagOrderResrult)
resultSt.print()
timeOutStream.print()
env.execute()
}
}
class OrderPayMatchResult() extends KeyedProcessFunction[Long,OrderEvent,OrderResrult]{
//定义状态
//1.
lazy val isCreatedState: ValueState[Boolean] = getRuntimeContext.getState(new ValueStateDescriptorBoolean)
lazy val isPayState: ValueState[Boolean] = getRuntimeContext.getState(new ValueStateDescriptorBoolean)
lazy val timerTsState: ValueState[Long] = getRuntimeContext.getState(new ValueStateDescriptorLong)
//定义侧输出流标签
lazy val orderTimeoutOutputTag = new OutputTagOrderResrult
override def processElement(value: OrderEvent, ctx: KeyedProcessFunction[Long, OrderEvent, OrderResrult]#Context, out: Collector[OrderResrult]): Unit = {
//先得到状态
val isCreated = isCreatedState.value()
val isPay: Boolean = isPayState.value()
val timerTs: Long = timerTsState.value()
//判断当前事件类型 看是create还是pay
if(value.eventType == “create”){
//如果已经支付过了 正常支付 输出匹配成功的结果
if(isPay){
out.collect(OrderResrult(value.orderId,“payed sucessed”))
//处理完毕 删除状态 删除定时器
isCreatedState.clear()
isPayState.clear()
timerTsState.clear()
ctx.timerService().deleteEventTimeTimer(timerTs)
}else{
//没有支付过 注册定时器 等待15分钟支付时间
val ts: Long = value.timestamp1000L+9001000L
timerTsState.update(ts)
isCreatedState.update(true)
}
}
//如果来的是pay
else if(value.eventType==“pay”){
//首先判断状态里是否创建过 如果创建过
if(isCreated){
//如果创建过 匹配成功 还要判断一下pay时间是否超过定时器时间
if(value.timestamp1000L < timerTs){
//如果没有超时，正常输出
out.collect(OrderResrult(value.orderId,"payed successfully "))
}else{
//如果超时
ctx.output(orderTimeoutOutputTag,OrderResrult(value.orderId,“payed but already timeout”))
}
//只要输出结果 当前order处理已经结束，清空状态和定时器
isCreatedState.clear()
isPayState.clear()
timerTsState.clear()
ctx.timerService().deleteEventTimeTimer(timerTs)
}else{
//如果create没来
ctx.timerService().registerEventTimeTimer(value.timestamp1000)
timerTsState.update(value.timestamp*1000L)
isCreatedState.update(true)
}
}
}

override def onTimer(timestamp: Long, ctx: KeyedProcessFunction[Long, OrderEvent, OrderResrult]#OnTimerContext, out: Collector[OrderResrult]): Unit = {
//定时器触发
//1.pay来了 没等到create
if(isPayState.value()){
ctx.output(orderTimeoutOutputTag,OrderResrult(ctx.getCurrentKey,“pay but not create create”))
}else{
//2create来了 没有pay
ctx.output(orderTimeoutOutputTag,OrderResrult(ctx.getCurrentKey,“order time out”))
}
//情况状态
isCreatedState.clear()
isPayState.clear()
timerTsState.clear()
}
}