Flink中的CEP(二)

目录

12.4 模式的检测处理

12.4.1 将模式应用到流上

12.4.2 处理匹配事件

12.4.3 处理超时事件

12.4.4 处理迟到数据

12.5 CEP 的状态机实现

12.6 本章总结


12.4 模式的检测处理

Pattern API 是 Flink CEP 的核心,也是最复杂的一部分。不过利用 Pattern API 定义好模式 还只是整个复杂事件处理的第一步,接下来还需要将模式应用到事件流上、检测提取匹配的复杂事件并定义处理转换的方法,最终得到想要的输出信息。

12.4.1 将模式应用到流上

将模式应用到事件流上的代码非常简单,只要调用 CEP 类的静态方法.pattern(),将数据流(DataStream)和模式(Pattern)作为两个参数传入就可以了。最终得到的是一个 PatternStream:

DataStream inputStream = ... 
Pattern pattern = ... 
 
PatternStream patternStream = CEP.pattern(inputStream, pattern); 

这里的 DataStream,也可以通过 keyBy 进行按键分区得到 KeyedStream,接下来对复杂事件的检测就会针对不同的 key 单独进行了。

模式中定义的复杂事件,发生是有先后顺序的,这里“先后”的判断标准取决于具体的时间语义。默认情况下采用事件时间语义,那么事件会以各自的时间戳进行排序;如果是处理时间语义,那么所谓先后就是数据到达的顺序。对于时间戳相同或是同时到达的事件,我们还可以在 CEP.pattern()中传入一个比较器作为第三个参数,用来进行更精确的排序:

// 可选的事件比较器 
EventComparator comparator = ... 
PatternStream patternStream = CEP.pattern(input, pattern, comparator); 

得到 PatternStream 后,接下来要做的就是对匹配事件的检测处理了。

12.4.2 处理匹配事件

基于PatternStream 可以调用一些转换方法,对匹配的复杂事件进行检测和处理,并最终得到一个正常的 DataStream。这个转换的过程与窗口的处理类似:将模式应用到流上得到PatternStream,就像在流上添加窗口分配器得到 WindowedStream;而之后的转换操作,就像 定义具体处理操作的窗口函数,对收集到的数据进行分析计算,得到结果进行输出,最后回到DataStream 的类型来。 PatternStream 的转换操作主要可以分成两种:简单便捷的选择提取(select)操作,和更 加通用、更加强大的处理(process)操作。与 DataStream 的转换类似,具体实现也是在调用API 时传入一个函数类:选择操作传入的是一个 PatternSelectFunction,处理操作传入的则是一 个 PatternProcessFunction。

1. 匹配事件的选择提取(select)

处理匹配事件最简单的方式,就是从 PatternStream 中直接把匹配的复杂事件提取出来, 包装成想要的信息输出,这个操作就是“选择”(select)。

⚫ PatternSelectFunction

代码中基于 PatternStream 直接调用.select()方法,传入一个 PatternSelectFunction 作为参数。

PatternStream patternStream = CEP.pattern(inputStream, pattern); 
DataStream result = patternStream.select(new MyPatternSelectFunction()); 

这 里 的 MyPatternSelectFunction 是 PatternSelectFunction 的一个具体实现 。

PatternSelectFunction 是 Flink CEP 提供的一个函数类接口,它会将检测到的匹配事件保存在一 个 Map 里,对应的 key 就是这些事件的名称。这里的“事件名称”就对应着在模式中定义的 每个个体模式的名称;而个体模式可以是循环模式,一个名称会对应多个事件,所以最终保存 在 Map 里的 value 就是一个事件的列表(List)。

下面是 MyPatternSelectFunction 的一个具体实现:

class MyPatternSelectFunction implements PatternSelectFunction{ 
@Override 
 public String select(Map> pattern) throws Exception { 
 Event startEvent = pattern.get("start").get(0); 
 Event middleEvent = pattern.get("middle").get(0); 
 return startEvent.toString() + " " + middleEvent.toString(); 
 } 
} 

PatternSelectFunction 里需要实现一个 select()方法,这个方法每当检测到一组匹配的复杂事件时都会调用一次。它以保存了匹配复杂事件的 Map 作为输入,经自定义转换后得到输出信息返回。这里我们假设之前定义的模式序列中,有名为“start”和“middle”的两个个体模式, 于是可以通过这个名称从 Map 中选择提取出对应的事件。注意调用 Map 的.get(key)方法后得 到的是一个事件的 List;如果个体模式是单例的,那么 List 中只有一个元素,直接调用.get(0)就可以把它取出。

当然,如果个体模式是循环的,List 中就有可能有多个元素了。例如我们在 12.3.2 小节中 对连续登录失败检测的改进,我们可以将匹配到的事件包装成 String 类型的报警信息输出,代 码如下:

// 1. 定义 Pattern,登录失败事件,循环检测 3 次 
Pattern pattern = Pattern 
 .begin("fails") 
 .where(new SimpleCondition() { 
 @Override 
 public boolean filter(LoginEvent loginEvent) throws Exception { 
 return loginEvent.eventType.equals("fail"); 
 } 
 }).times(3).consecutive(); 
 
// 2. 将 Pattern 应用到流上,检测匹配的复杂事件,得到一个 PatternStream 
PatternStream patternStream = CEP.pattern(stream, pattern); 
 
// 3. 将匹配到的复杂事件选择出来,然后包装成报警信息输出 
patternStream 
 .select(new PatternSelectFunction() { 
 @Override 
 public String select(Map> map) throws 
Exception { 
 // 只有一个模式,匹配到了 3 个事件,放在 List 中 
 LoginEvent first = map.get("fails").get(0); 
 LoginEvent second = map.get("fails").get(1); 
 LoginEvent third = map.get("fails").get(2); 
 return first.userId + " 连续三次登录失败!登录时间:" + first.timestamp 
+ ", " + second.timestamp + ", " + third.timestamp; 
 } 
 }) 
 .print("warning"); 

我们定义的模式序列中只有一个循环模式 fails,它会将检测到的 3 个登录失败事件保存到 一个列表(List)中。所以第三步处理匹配的复杂事件时,我们从 map 中获取模式名 fails 对应 的事件,拿到的是一个 List,从中按位置索引依次获取元素就可以得到匹配的三个登录失败事 件。

运行程序进行测试,会发现结果与之前完全一样。

⚫ PatternFlatSelectFunction

除此之外,PatternStream 还有一个类似的方法是.flatSelect(),传入的参数是一个PatternFlatSelectFunction。从名字上就能看出,这是 PatternSelectFunction 的“扁平化”版本;内部需要实现一个 flatSelect()方法,它与之前 select()的不同就在于没有返回值,而是多了一个收 集器(Collector)参数 out,通过调用 out.collet()方法就可以实现多次发送输出数据了。

例如上面的代码可以写成:

// 3. 将匹配到的复杂事件选择出来,然后包装成报警信息输出 
patternStream.flatSelect(new PatternFlatSelectFunction() { 
@Override 
public void flatSelect(Map> map, 
Collector out) throws Exception { 
LoginEvent first = map.get("fails").get(0); 
LoginEvent second = map.get("fails").get(1); 
LoginEvent third = map.get("fails").get(2); 
out.collect(first.userId + " 连续三次登录失败!登录时间:" + first.timestamp + 
", " + second.timestamp + ", " + third.timestamp); 
} 
}).print("warning"); 

可见 PatternFlatSelectFunction 使用更加灵活,完全能够覆盖 PatternSelectFunction 的功能。 这跟 FlatMapFunction 与 MapFunction 的区别是一样的。

2. 匹配事件的通用处理(process)

自 1.8 版本之后,Flink CEP 引入了对于匹配事件的通用检测处理方式,那就是直接调用PatternStream 的.process()方法,传入一个 PatternProcessFunction。这看起来就像是我们熟悉的 处理函数(process function),它也可以访问一个上下文(Context),进行更多的操作。

所以 PatternProcessFunction 功能更加丰富、调用更加灵活,可以完全覆盖其他接口,也就 成为了目前官方推荐的处理方式。事实上,PatternSelectFunction 和 PatternFlatSelectFunction在 CEP 内部执行时也会被转换成 PatternProcessFunction。

我们可以使用 PatternProcessFunction 将之前的代码重写如下:

package com.atguigu.chapter12;

import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.cep.CEP;
import org.apache.flink.cep.PatternSelectFunction;
import org.apache.flink.cep.PatternStream;
import org.apache.flink.cep.functions.PatternProcessFunction;
import org.apache.flink.cep.pattern.Pattern;
import org.apache.flink.cep.pattern.conditions.SimpleCondition;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;

import java.time.Duration;
import java.util.List;
import java.util.Map;

public class LoginFailDetectProExample {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        KeyedStream stream = env.fromElements(
                        new LoginEvent("user_1", "192.168.0.1", "fail", 2000L),
                        new LoginEvent("user_1", "192.168.0.2", "fail", 3000L),
                        new LoginEvent("user_2", "192.168.1.29", "fail", 4000L),
                        new LoginEvent("user_1", "171.56.23.10", "fail", 5000L),
                        new LoginEvent("user_2", "192.168.1.29", "fail", 7000L),
                        new LoginEvent("user_2", "192.168.1.29", "fail", 8000L),
                        new LoginEvent("user_2", "192.168.1.29", "success", 6000L)
                )
                .assignTimestampsAndWatermarks(WatermarkStrategy.forBoundedOutOfOrderness(Duration.ZERO)
                        .withTimestampAssigner(new SerializableTimestampAssigner() {
                            @Override
                            public long extractTimestamp(LoginEvent loginEvent, long l) {
                                return loginEvent.timestamp;
                            }
                        }))
                .keyBy(data -> data.userId);

        //1.定义一个模式(Pattern):连续三次登录失败
        Pattern pattern = Pattern.begin("fail") //开始事件的名字(标签)
                .where(new SimpleCondition() {
                    @Override
                    public boolean filter(LoginEvent value) throws Exception {
                        return value.eventType.equals("fail");
                    }
                }).times(3).consecutive();//指定严格近邻的连续三次登录失败


        //2.将Pattern应用到DataStream上,检测满足规则的复杂事件,得到一个PatternStream;
        PatternStream patternStream = CEP.pattern(stream, pattern);

        //3.对 PatternStream 进行转换处理,将检测到的复杂事件提取出来,包装成报警信息输出。
        SingleOutputStreamOperator warningStream = patternStream.process(new PatternProcessFunction() {
            @Override
            public void processMatch(Map> map, Context context, Collector collector) throws Exception {
                //提取三次登录失败事件
                LoginEvent firstFailEvent =map.get("fail").get(0);
                LoginEvent secondFailEvent =map.get("fail").get(1);
                LoginEvent thirdFailEvent =map.get("fail").get(2);
                collector.collect(firstFailEvent.userId + "连续三次登录失败!登录时间为:" +
                        firstFailEvent.timestamp + "," +
                        secondFailEvent.timestamp + "," +
                        thirdFailEvent.timestamp + ".");
            }
        });


        //打印输出
        warningStream.print("warning");

        env.execute();
    }
}

可以看到,PatternProcessFunction 中必须实现一个 processMatch()方法;这个方法与之前 的 flatSelect()类似,只是多了一个上下文 Context 参数。利用这个上下文可以获取当前的时间 信息,比如事件的时间戳(timestamp)或者处理时间(processing time);还可以调用.output()方法将数据输出到侧输出流。侧输出流的功能是处理函数的一大特性,我们已经非常熟悉;而 在 CEP 中,侧输出流一般被用来处理超时事件

12.4.3 处理超时事件

复杂事件的检测结果一般只有两种:要么匹配,要么不匹配。检测处理的过程具体如下:

(1)如果当前事件符合模式匹配的条件,就接受该事件,保存到对应的 Map 中;

(2)如果在模式序列定义中,当前事件后面还应该有其他事件,就继续读取事件流进行检测;如果模式序列的定义已经全部满足,那么就成功检测到了一组匹配的复杂事件,调用PatternProcessFunction 的 processMatch()方法进行处理;

(3)如果当前事件不符合模式匹配的条件,就丢弃该事件;

(4)如果当前事件破坏了模式序列中定义的限制条件,比如不满足严格近邻要求,那么 当前已检测的一组部分匹配事件都被丢弃,重新开始检测。

不过在有时间限制的情况下,需要考虑的问题会有一点特别。比如我们用.within()指定了 模式检测的时间间隔,超出这个时间当前这组检测就应该失败了。然而这种“超时失败”跟真 正的“匹配失败”不同,它其实是一种“部分成功匹配”;因为只有在开头能够正常匹配的前提下,没有等到后续的匹配事件才会超时。所以往往不应该直接丢弃,而是要输出一个提示或报警信息。这就要求我们有能力捕获并处理超时事件。

1. 使用 PatternProcessFunction 的侧输出流

在 Flink CEP 中 ,提供了一个专门捕捉超时的部分匹配事件的接口, 叫 作TimedOutPartialMatchHandler。这个接口需要实现一个 processTimedOutMatch()方法,可以将 超时的、已检测到的部分匹配事件放在一个 Map 中,作为方法的第一个参数;方法的第二个参数则是 PatternProcessFunction 的上下文 Context。所以这个接口必须与 PatternProcessFunction结合使用,对处理结果的输出则需要利用侧输出流来进行。

代码中的调用方式如下:

class MyPatternProcessFunction extends PatternProcessFunction 
implements TimedOutPartialMatchHandler { 
 // 正常匹配事件的处理 
@Override 
 public void processMatch(Map> match, Context ctx, 
Collector out) throws Exception{ 
 ... 
 } 
 
 // 超时部分匹配事件的处理 
 @Override 
 public void processTimedOutMatch(Map> match, Context ctx) 
throws Exception{ 
 Event startEvent = match.get("start").get(0); 
 OutputTag outputTag = new OutputTag("time-out"){}; 
 ctx.output(outputTag, startEvent); 
 } 
}

我们在 processTimedOutMatch()方法中定义了一个输出标签(OutputTag)。调用 ctx.output()方法,就可以将超时的部分匹配事件输出到标签所标识的侧输出流了。

2. 使用 PatternTimeoutFunction

上文提到的PatternProcessFunction通过实现TimedOutPartialMatchHandler接口扩展出了处 理超时事件的能力,这是官方推荐的做法。此外,Flink CEP 中也保留了简化版的PatternSelectFunction,它无法直接处理超时事件,不过我们可以通过调用 PatternStream的.select()方法时多传入一个 PatternTimeoutFunction 参数来实现这一点。 PatternTimeoutFunction 是早期版本中用于捕获超时事件的接口。它需要实现一个 timeout()方法,同样会将部分匹配的事件放在一个 Map 中作为参数传入,此外还有一个参数是当前的 时间戳。提取部分匹配事件进行处理转换后,可以将通知或报警信息输出。

由于调用.select()方法后会得到唯一的 DataStream,所以正常匹配事件和超时事件的处理 结果不应该放在同一条流中。正常匹配事件的处理结果会进入转换后得到的 DataStream,而超 时事件的处理结果则会进入侧输出流;这个侧输出流需要另外传入一个侧输出标签(OutputTag) 来指定。

所以最终我们在调用 PatternStream 的.select()方法时需要传入三个参数:侧输出流标签( OutputTag ), 超时事件处理函数 PatternTimeoutFunction ,匹配事件提取函数PatternSelectFunction。下面是一个代码中的调用方式:

// 定义一个侧输出流标签,用于标识超时侧输出流 
OutputTag timeoutTag = new OutputTag("timeout"){}; 
 
// 将匹配到的,和超时部分匹配的复杂事件提取出来,然后包装成提示信息输出 
SingleOutputStreamOperator resultStream = patternStream 
.select(timeoutTag, 
// 超时部分匹配事件的处理 
 new PatternTimeoutFunction() { 
 @Override 
 public String timeout(Map> pattern, long 
timeoutTimestamp) throws Exception { 
 Event event = pattern.get("start").get(0); 
 return "超时:" + event.toString(); 
 } 
 }, 
// 正常匹配事件的处理 
 new PatternSelectFunction() { 
 @Override 
 public String select(Map> pattern) throws Exception 
{ 
... 
 } 
 } 
); 
 
// 将正常匹配和超时部分匹配的处理结果流打印输出 
resultStream.print("matched"); 
resultStream.getSideOutput(timeoutTag).print("timeout"); 

这里需要注意的是,在超时事件处理的过程中,从 Map 里只能取到已经检测到匹配的那 些事件;如果取可能未匹配的事件并调用它的对象方法,则可能会报空指针异常 (NullPointerException)。另外,超时事件处理的结果进入侧输出流,正常匹配事件的处理结果进入主流,两者的数据类型可以不同。

3. 应用实例

接下来我们看一个具体的应用场景。

在电商平台中,最终创造收入和利润的是用户下单购买的环节。用户下单的行为可以表明 用户对商品的需求,但在现实中,并不是每次下单都会被用户立刻支付。当拖延一段时间后, 用户支付的意愿会降低。所以为了让用户更有紧迫感从而提高支付转化率,同时也为了防范订 单支付环节的安全风险,电商网站往往会对订单状态进行监控,设置一个失效时间(比如 15分钟),如果下单后一段时间仍未支付,订单就会被取消。

首先定义出要处理的数据类型。我们面对的是订单事件,主要包括用户对订单的创建(下 单)和支付两种行为。

因此可以定义 POJO 类 OrderEvent 如下,其中属性字段包括用户 ID、 订单 ID、事件类型(操作类型)以及时间戳。

POJO类:

package com.atguigu.chapter12;

public class OrderEvent {
    public String userId;
    public String orderId;
    public String eventType;
    public Long timestamp;

    public OrderEvent() {
    }

    public OrderEvent(String userId, String orderId, String eventType, Long
            timestamp) {
        this.userId = userId;
        this.orderId = orderId;
        this.eventType = eventType;
        this.timestamp = timestamp;
    }

    @Override
    public String toString() {
        return "OrderEvent{" +
                "userId='" + userId + '\'' +
                "orderId='" + orderId + '\'' +
                ", eventType='" + eventType + '\'' +
                ", timestamp=" + timestamp + '}';
    }
}

当前需求的重点在于对超时未支付的用户进行监控提醒,也就是需要检测有下单行为、但15分钟内没有支付行为的复杂事件。在下单和支付之间,可以有其他操作(比如对订单的修改),所以两者之间是宽松近邻关系。                                                    

测试类:

package com.atguigu.chapter12;

import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.cep.CEP;
import org.apache.flink.cep.PatternStream;
import org.apache.flink.cep.functions.PatternProcessFunction;
import org.apache.flink.cep.functions.TimedOutPartialMatchHandler;
import org.apache.flink.cep.pattern.Pattern;
import org.apache.flink.cep.pattern.conditions.SimpleCondition;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.util.Collector;
import org.apache.flink.util.OutputTag;

import java.time.Duration;
import java.util.List;
import java.util.Map;

public class OrderTimeOutDetectExample {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        //1.获取数据源
        KeyedStream stream = env.fromElements(
                new OrderEvent("user_1", "order_1", "create", 1000L),
                new OrderEvent("user_2", "order_2", "create", 2000L),
                new OrderEvent("user_1", "order_1", "modify", 10 * 1000L),
                new OrderEvent("user_1", "order_1", "pay", 60 * 1000L),
                new OrderEvent("user_2", "order_3", "create", 10 * 60 * 1000L),
                new OrderEvent("user_2", "order_3", "pay", 20 * 60 * 1000L)
        )
                .assignTimestampsAndWatermarks(WatermarkStrategy.forBoundedOutOfOrderness(Duration.ZERO)
                        .withTimestampAssigner(new SerializableTimestampAssigner() {
                            @Override
                            public long extractTimestamp(OrderEvent orderEvent, long l) {
                                return orderEvent.timestamp;
                            }
                        }))
                .keyBy(data -> data.orderId);

        //2.定义模式
        Pattern pattern = Pattern.begin("create")
                .where(new SimpleCondition() {
                    @Override
                    public boolean filter(OrderEvent orderEvent) throws Exception {
                        return orderEvent.eventType.equals("create");
                    }
                })
                .followedBy("pay")
                .where(new SimpleCondition() {
                    @Override
                    public boolean filter(OrderEvent orderEvent) throws Exception {
                        return orderEvent.eventType.equals("pay");
                    }
                })
                .within(Time.minutes(15));

        //3.将当前模式应用到当前数据流中
        PatternStream patternStream = CEP.pattern(stream, pattern);

        //4.定义一个测输出流标签,用于输出超时事件
        OutputTag timeoutTag = new OutputTag("timeout"){};

        //5.将完全匹配和超时匹配的复杂事件提取出来,进行处理
        SingleOutputStreamOperator result = patternStream.process(new OrderPayMatch());

        //6.打印输出

        result.print("payed: ");//完全匹配

        result.getSideOutput(timeoutTag).print("timeout: ");//超时匹配

        env.execute();
    }
    //自定义PatternProcessFunction
    public static class OrderPayMatch extends PatternProcessFunction implements TimedOutPartialMatchHandler {

        //提取完全匹配事件,并输出
        @Override
        public void processMatch(Map> map, Context context, Collector collector) throws Exception {
            //获取当前的支付事件
            OrderEvent payEvent = map.get("pay").get(0);
            collector.collect("用户"+ payEvent.userId+" 订单 "+ payEvent.orderId + " 已支付!");
        }
        //提取超时匹配事件,并输出
        @Override
        public void processTimedOutMatch(Map> map, Context context) throws Exception {
            //获取当前的下单(create)事件
            OrderEvent createEvent = map.get("create").get(0);
            OutputTag timeoutTag = new OutputTag("timeout"){};
            context.output(timeoutTag,"用户"+ createEvent.userId+" 订单 "+ createEvent.orderId + " 超时未支付!");
        }
    }
}

12.4.4 处理迟到数据

CEP 主要处理的是先后发生的一组复杂事件,所以事件的顺序非常关键。前面已经说过, 事件先后顺序的具体定义与时间语义有关。如果是处理时间语义,那比较简单,只要按照数据处理的系统时间算就可以了;而如果是事件时间语义,需要按照事件自身的时间戳来排序。这 就有可能出现时间戳大的事件先到、时间戳小的事件后到的现象,也就是所谓的“乱序数据”或“迟到数据”。

在 Flink CEP 中沿用了通过设置水位线(watermark)延迟来处理乱序数据的做法。当一个 事件到来时,并不会立即做检测匹配处理,而是先放入一个缓冲区(buffer)。缓冲区内的数据, 会按照时间戳由小到大排序;当一个水位线到来时,就会将缓冲区中所有时间戳小于水位线的 事件依次取出,进行检测匹配。这样就保证了匹配事件的顺序和事件时间的进展一致,处理的顺序就一定是正确的。这里水位线的延迟时间,也就是事件在缓冲区等待的最大时间。

这样又会带来另一个问题:水位线延迟时间不可能保证将所有乱序数据完美包括进来,总会有一些事件延迟比较大,以至于等它到来的时候水位线早已超过了它的时间戳。这时之前的数据都已处理完毕,这样的“迟到数据”就只能被直接丢弃了——这与窗口对迟到数据的默认处理一致。

我们自然想到,如果不希望迟到数据丢掉,应该也可以借鉴窗口的做法。Flink CEP同样提供了将迟到事件输出到侧输出流的方式 : 我们可以基于 PatternStream 直接调 用.sideOutputLateData()方法,传入一个 OutputTag,将迟到数据放入侧输出流另行处理。代码 中调用方式如下:

PatternStream patternStream = CEP.pattern(input, pattern); 
 
// 定义一个侧输出流的标签 
OutputTag lateDataOutputTag = new OutputTag("late-data"){}; 
 
SingleOutputStreamOperator result = patternStream 
 .sideOutputLateData(lateDataOutputTag) // 将迟到数据输出到侧输出流 
 .select( 
// 处理正常匹配数据 
 new PatternSelectFunction() {...} 
 ); 
 
// 从结果中提取侧输出流 
DataStream lateData = result.getSideOutput(lateDataOutputTag); 

可以看到,整个处理流程与窗口非常相似。经处理匹配数据得到结果数据流之后,可以调用.getSideOutput()方法来提取侧输出流,捕获迟到数据进行额外处理。

12.5 CEP 的状态机实现

Flink CEP 中对复杂事件的检测,关键在模式的定义。我们会发现 CEP 中模式的定义方式 比较复杂,而且与正则表达式非常相似:正则表达式在字符串上匹配符合模板的字符序列,而Flink CEP 则是在事件流上匹配符合模式定义的复杂事件

前面我们分析过 CEP 检测处理的流程,可以认为检测匹配事件的过程中会有“初始(没有任何匹配)”“检测中(部分匹配成功)”“匹配成功”“匹配失败”等不同的“状态”。随着每个事件的到来,都会改变当前检测的“状态”;而这种改变跟当前事件的特性有关、也跟当前 所处的状态有关。这样的系统,其实就是一个“状态机”(state machine)。这也正是正则表达式底层引擎的实现原理。

所以 Flink CEP 的底层工作原理其实与正则表达式是一致的,是一个“非确定有限状态自动机”(Nondeterministic Finite Automaton,NFA)。NFA 的原理涉及到较多数学知识,我们这 里不做详细展开,而是用一个具体的例子来说明一下状态机的工作方式,以更好地理解 CEP的原理。

我们回顾一下 12.2.2 小节中的应用案例,检测用户连续三次登录失败的复杂事件。用 Flink CEP 中的 Pattern API 可以很方便地把它定义出来;如果我们现在不用 CEP,而是用 DataStream API 和处理函数来实现,应该怎么做呢?

这需要设置状态,并根据输入的事件不断更新状态。当然因为这个需求不是很复杂,我们 也可以用嵌套的 if-else 条件判断将它实现,不过这样做的代码可读性和扩展性都会很差。更好的方式,就是实现一个状态机。

Flink中的CEP(二)_第1张图片

如图所示,即为状态转移的过程,从初始状态(INITIAL)出发,遇到一个类型为fail 的登录失败事件,就开始进入部分匹配的状态;目前只有一个 fail 事件,我们把当前状态 记作 S1。基于 S1 状态,如果继续遇到 fail 事件,那么就有两个 fail 事件,记作 S2。基于 S2状态如果再次遇到 fail 事件,那么就找到了一组匹配的复杂事件,把当前状态记作 Matched, 就可以输出报警信息了。需要注意的是,报警完毕需要立即重置状态回 S2;因为如果接下来再遇到 fail 事件,就又满足了新的连续三次登录失败,需要再次报警。

而不论是初始状态,还是 S1、S2 状态,只要遇到类型为 success 的登录成功事件,就会 跳转到结束状态,记作 Terminal。此时当前检测完毕,之前的部分匹配应该全部清空,所以需 要立即重置状态到 Initial,重新开始下一轮检测。所以这里我们真正参与状态转移的,其实只 有 Initial、S1、S2 三个状态,Matched 和 Terminal 是为了方便我们做其他操作(比如输出报警、 清空状态)的“临时标记状态”,不等新事件到来马上就会跳转。

完整代码如下:

package com.atguigu.chapter12;

import org.apache.flink.api.common.functions.RichFlatMapFunction;
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;

public class NFAExample {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        //1.获取登录数据源,并按用户id进行分组
        KeyedStream stream = env.fromElements(
                new LoginEvent("user_1", "192.168.0.1", "fail", 2000L),
                new LoginEvent("user_1", "192.168.0.2", "fail", 3000L),
                new LoginEvent("user_2", "192.168.1.29", "fail", 4000L),
                new LoginEvent("user_1", "171.56.23.10", "fail", 5000L),
                new LoginEvent("user_2", "192.168.1.29", "fail", 7000L),
                new LoginEvent("user_2", "192.168.1.29", "fail", 8000L),
                new LoginEvent("user_2", "192.168.1.29", "success", 6000L)
        ).keyBy(data -> data.userId);

        //2.数据按照顺序依次输入,用状态机进行处理,状态跳转
        SingleOutputStreamOperator warningStream = stream.flatMap(new StateMachineMapper());

        //3.打印输出
        warningStream.print();

        env.execute();


    }
    //实现自定义的RichFlatMapFunction
    public static class StateMachineMapper extends RichFlatMapFunction{

        //声明当前状态机当前的状态
        ValueState currentState;

        @Override
        public void open(Configuration parameters) throws Exception {
            currentState=getRuntimeContext().getState(new ValueStateDescriptor("state",State.class));
        }

        @Override
        public void flatMap(LoginEvent value, Collector collector) throws Exception {
            //如果状态为空,进行初始化
            State state=currentState.value();
            if(state==null){
                state=state.Initial;
            }

            //跳转到下一状态
            State nextState=state.transition(value.eventType);

            //判断当前状态的特殊情况,直接进行跳转
            if(nextState==State.Matched){
                //检测到了匹配,输出报警信息;不更新状态就是跳转回S2
                collector.collect(value.userId + "连续三次登录失败");
            }else if (nextState== State.Terminal){
                //状态更新,直接状态更新为初始状态,重新开始检测
                currentState.update(State.Initial);
            }else {
                //状态覆盖
                currentState.update(nextState);
            }
        }
    }
    //状态实现
    public enum State{
        Terminal,  //匹配失败,终止状态
        Matched,   //匹配成功

        //S2状态,传入基于S2状态可以进行的一系列状态转移
        S2(new Transition("fail",Matched),new Transition("success",Terminal)),

        //S1状态
        S1(new Transition("fail",S2),new Transition("success",Terminal)),

        //初始状态
        Initial(new Transition("fail",S1),new Transition("success",Terminal)),
        ;

        private Transition[] transitions; //当前状态的转移规则

        State(Transition... transitions){
            this.transitions=transitions;
        }

        //状态转移方法
        public State transition(String eventType){
            for(Transition transition:transitions){
                if(transition.getEventType().equals(eventType)){
                    return transition.getTargetState();
                }
            }
            //回到初始状态
            return Initial;
        }

    }
    //定义一个状态转移类,包含当前引起状态转移的事件类型,以及转移的目标状态
    public static class Transition{
        private String eventType;
        private State targetState;

        public Transition(String eventType, State targetState) {
            this.eventType = eventType;
            this.targetState = targetState;
        }

        public String getEventType() {
            return eventType;
        }

        public State getTargetState() {
            return targetState;
        }
    }
}

运行代码,可以看到输出与之前 CEP 的实现是完全一样的。显然,如果所有的复杂事件处理都自己设计状态机来实现是非常繁琐的,而且中间逻辑非常容易出错;所以 Flink CEP 将 底层 NFA 全部实现好并封装起来,这样我们处理复杂事件时只要调上层的 Pattern API 就可以, 无疑大大降低了代码的复杂度,提高了编程的效率。

12.6 本章总结

Flink CEP 是 Flink 对复杂事件处理提供的强大而高效的应用库。本章中我们从一个简单 的应用实例出发,详细讲解了 CEP 的核心内容——Pattern API 和模式的检测处理,并以案例 说明了对超时事件和迟到数据的处理。最后进行了深度扩展,举例讲解了 CEP 的状态机实现, 这部分大家可以只做原理了解,不要求完全实现状态机的代码。 CEP 在实际生产中有非常广泛的应用。对于大数据分析而言,应用场景主要可以分为统 计分析和逻辑分析。企业的报表统计、商业决策都离不开统计分析,这部分需求在目前企业的 分析指标中占了很大的比重,实时的流数据统计可以通过 Flink SQL 方便地实现;而逻辑分析 可以进一步细分为风险控制、数据挖掘、用户画像、精准推荐等各个应用场景,如今对实时性 要求也越来越高,Flink CEP 就可以作为对流数据进行逻辑分析、进行实时风控和推荐的有力工具

所以 DataStream API 和处理函数是 Flink 应用的基石,而 SQL 和 CEP 就是 Flink 大厦顶层 扩展的两大工具。Flink SQL 也提供了与 CEP 相结合的“模式识别”(Pattern Recognition)语 句——MATCH_RECOGNIZE,可以支持在 SQL 语句中进行复杂事件处理。尽管目前还不完 善,不过相信随着 Flink 的进一步发展,Flink SQL 和 CEP 将对程序员更加友好,功能也将更 加强大,全方位实现大数据实时流处理的各种应用需求。

你可能感兴趣的:(flink,大数据)