Flink CEP结合案例详解

最新推荐文章于 2024-09-12 09:02:37 发布
最新推荐文章于 2024-09-12 09:02:37 发布
阅读量2.9k 收藏 12
点赞数 5
分类专栏： Flink 大数据 文章标签： flink 大数据 big data
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Aaron_ch/article/details/123008238
版权

1、介绍

FlinkCEP是在Flink之上实现的复杂事件处理(CEP)库。它允许您在无穷无尽的事件流中检测事件模式，使您有机会掌握数据中重要的内容。通常会用来做一些用户操作APP的日志风控策略等多种复杂事件，下面详细以用户连续10s内登陆失败超过3次告警为需求，进行全面讲解。

1.1、整体需求数据详解图

2、官方案例

官方代码案例如下：

DataStream<Event> input = ...

Pattern<Event, ?> pattern = Pattern.<Event>begin("start").where(
        new SimpleCondition<Event>() {
            @Override
            public boolean filter(Event event) {
                return event.getId() == 42;
            }
        }
    ).next("middle").subtype(SubEvent.class).where(
        new SimpleCondition<SubEvent>() {
            @Override
            public boolean filter(SubEvent subEvent) {
                return subEvent.getVolume() >= 10.0;
            }
        }
    ).followedBy("end").where(
         new SimpleCondition<Event>() {
            @Override
            public boolean filter(Event event) {
                return event.getName().equals("end");
            }
         }
    );

PatternStream<Event> patternStream = CEP.pattern(input, pattern);

DataStream<Alert> result = patternStream.process(
    new PatternProcessFunction<Event, Alert>() {
        @Override
        public void processMatch(
                Map<String, List<Event>> pattern,
                Context ctx,
                Collector<Alert> out) throws Exception {
            out.collect(createAlertFrom(pattern));
        }
    });

2.1、官方案例总结

CEP编程步骤
a）定义模式序列

Pattern.<Class>begin("patternName").API...

基本都是按照如上的套路来新建自定义一个模式规则

后续的可以跟的API可以在官方中查看学习

Event Processing (CEP) | Apache Flink
b）将模式序列作用到流上

CEP.pattern(inputDataStream,pattern)

CEP.pattern()是固定格式写法，

其中第一个参数，表示需要具体作用的流；

第二个参数，表示具体的自定义的模式。
c）提取匹配上的数据和输出

由b）生成的流用process API来进行数据处理输出，继承PatternProcessFunction，重写processMatch(Map<String, List<Event>> pattern,Context ctx,Collector<Alert> out)方法，

第一个参数，表示具体匹配上的数据，其中Map的key就是a）步骤中定义的"patternName"名称，value就是该名称具体对应规则匹配上的数据集；

第二个参数，表示没匹配上的数据侧输出流

第三个参数，表示具体该函数处理完，需要对外输出的内容收集。

3、需求案例详解

下面就以从Socket中模拟读取用户操作日志数据，来进行数据CEP匹配数据输出。

以如下代码把读进来的数据进行数据打平成JavaBean。该章节的讲解以代码段进行，后续章节会把demo代码全部贴出来。

final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

/**
 * 设置成1，是为了能够触发watermark来计算
 */
env.setParallelism(1);

DataStreamSource<String> socketTextStream = env.socketTextStream("localhost", 8888);

SingleOutputStreamOperator<UserLoginLog> dataStream = socketTextStream.flatMap(new MyFlatMapFunction())
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy.<UserLoginLog>forBoundedOutOfOrderness(Duration.ofSeconds(1))
                                .withTimestampAssigner((SerializableTimestampAssigner<UserLoginLog>) (element, recordTimestamp) -> element.getLoginTime())
                );

3.1、使用begin.where.next.where.next

/**
 * 10s钟之内连续3次登陆失败的才输出，强制连续
 */
Pattern<UserLoginLog, UserLoginLog> wherePatternOne = Pattern.<UserLoginLog>begin("start").where(new SimpleCondition<UserLoginLog>() {
            @Override
            public boolean filter(UserLoginLog value) throws Exception {
                return 1 == value.getLoginStatus();
            }
        }).next("second").where(new IterativeCondition<UserLoginLog>() {
            @Override
            public boolean filter(UserLoginLog value, Context<UserLoginLog> ctx) throws Exception {

                return 1 == value.getLoginStatus();
            }
        }).next("third").where(new SimpleCondition<UserLoginLog>() {
            @Override
            public boolean filter(UserLoginLog value) throws Exception {

                return 1 == value.getLoginStatus();
            }
        }).within(Time.seconds(10));

如上根据设置判断登陆状态是否为失败开始计数，连续第二条，第三条如果也同样为失败的话，就会输出

//如下日志数据输入，最终将输出loginId为：11111、11112、11113、11116、11117、11121

{"loginId":11111,"loginTime":1645177352000,"loginStatus":1,"userName":"aaron"}
{"loginId":11112,"loginTime":1645177353000,"loginStatus":1,"userName":"aaron"}
{"loginId":11113,"loginTime":1645177354000,"loginStatus":1,"userName":"aaron"}
{"loginId":11116,"loginTime":1645177355000,"loginStatus":1,"userName":"aaron"}
{"loginId":11117,"loginTime":1645177356000,"loginStatus":1,"userName":"aaron"}
{"loginId":11118,"loginTime":1645177357000,"loginStatus":1,"userName":"aaron"}
{"loginId":11119,"loginTime":1645177358000,"loginStatus":1,"userName":"aaron"}
{"loginId":11120,"loginTime":1645177359000,"loginStatus":0,"userName":"aaron"}
{"loginId":11121,"loginTime":1645177360000,"loginStatus":1,"userName":"aaron"}
{"loginId":11122,"loginTime":1645177361000,"loginStatus":1,"userName":"aaron"}
{"loginId":11123,"loginTime":1645177362000,"loginStatus":1,"userName":"aaron"}

3.1.1需求输出图解

3.2、使用begin.times

/**
 * 10s钟之内连续3次登陆失败的才输出,不强制连续
 */
Pattern<UserLoginLog, UserLoginLog> wherePatternTwo = Pattern.<UserLoginLog>begin("start").where(new IterativeCondition<UserLoginLog>() {
            @Override
            public boolean filter(UserLoginLog value, Context<UserLoginLog> ctx) throws Exception {
                return 1 == value.getLoginStatus();
            }
        }).times(3).within(Time.seconds(10));

如上根据设置判断登陆状态是否为失败开始计数，只要在10秒之内出现第二条，第三条如果也同样为失败的话，就会输出，该本质就是不需要连续出现。

//如下日志数据输入，最终将输出loginId为：11111、11112、11113、11116、11117、11118、11119、11121

{"loginId":11111,"loginTime":1645177352000,"loginStatus":1,"userName":"aaron"}
{"loginId":11112,"loginTime":1645177353000,"loginStatus":1,"userName":"aaron"}
{"loginId":11113,"loginTime":1645177354000,"loginStatus":1,"userName":"aaron"}
{"loginId":11116,"loginTime":1645177355000,"loginStatus":1,"userName":"aaron"}
{"loginId":11117,"loginTime":1645177356000,"loginStatus":1,"userName":"aaron"}
{"loginId":11118,"loginTime":1645177357000,"loginStatus":1,"userName":"aaron"}
{"loginId":11119,"loginTime":1645177358000,"loginStatus":1,"userName":"aaron"}
{"loginId":11120,"loginTime":1645177359000,"loginStatus":0,"userName":"aaron"}
{"loginId":11121,"loginTime":1645177360000,"loginStatus":1,"userName":"aaron"}
{"loginId":11122,"loginTime":1645177361000,"loginStatus":1,"userName":"aaron"}
{"loginId":11123,"loginTime":1645177362000,"loginStatus":1,"userName":"aaron"}

3.2.1、需求图解

3.3、使用begin.times.consecutive

/**
 * 10s钟之内连续3次登陆失败的才输出,加上 consecutive 之后 就是 强制连续输出
 */
Pattern<UserLoginLog, UserLoginLog> wherePatternThree = Pattern.<UserLoginLog>begin("start").where(new IterativeCondition<UserLoginLog>() {
            @Override
            public boolean filter(UserLoginLog value, Context<UserLoginLog> ctx) throws Exception {
                return 1 == value.getLoginStatus();
            }
        }).times(3).consecutive().within(Time.seconds(10));

如上在比3.2的基础上多加了一个consecutive之后，就变成跟3.1一样的效果

//如下日志数据输入，最终将输出loginId为：11111、11112、11113、11116、11117、11121

{"loginId":11111,"loginTime":1645177352000,"loginStatus":1,"userName":"aaron"}
{"loginId":11112,"loginTime":1645177353000,"loginStatus":1,"userName":"aaron"}
{"loginId":11113,"loginTime":1645177354000,"loginStatus":1,"userName":"aaron"}
{"loginId":11116,"loginTime":1645177355000,"loginStatus":1,"userName":"aaron"}
{"loginId":11117,"loginTime":1645177356000,"loginStatus":1,"userName":"aaron"}
{"loginId":11118,"loginTime":1645177357000,"loginStatus":1,"userName":"aaron"}
{"loginId":11119,"loginTime":1645177358000,"loginStatus":1,"userName":"aaron"}
{"loginId":11120,"loginTime":1645177359000,"loginStatus":0,"userName":"aaron"}
{"loginId":11121,"loginTime":1645177360000,"loginStatus":1,"userName":"aaron"}
{"loginId":11122,"loginTime":1645177361000,"loginStatus":1,"userName":"aaron"}
{"loginId":11123,"loginTime":1645177362000,"loginStatus":1,"userName":"aaron"}

4、本Demo所有代码

4.1、pom文件

<properties>
        <flink.version>1.14.3</flink.version>
        <hadoop.version>2.7.5</hadoop.version>
        <scala.binary.version>2.11</scala.binary.version>
        <kafka.version>2.4.0</kafka.version>
        <redis.version>3.3.0</redis.version>
        <lombok.version>1.18.6</lombok.version>
        <fastjson.verson>1.2.72</fastjson.verson>
        <jdk.version>1.8</jdk.version>

    </properties>
    <dependencyManagement>
        <dependencies>
            <!--hadoop 依赖-->
            <dependency>
                <groupId>org.apache.hadoop</groupId>
                <artifactId>hadoop-common</artifactId>
                <version>${hadoop.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>org.slf4j</groupId>
                        <artifactId>slf4j-log4j12</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>log4j</groupId>
                        <artifactId>log4j</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>org.slf4j</groupId>
                        <artifactId>slf4j-api</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <!--flink 依赖-->
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-clients_${scala.binary.version}</artifactId>
                <version>${flink.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>org.slf4j</groupId>
                        <artifactId>slf4j-api</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-java</artifactId>
                <version>${flink.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>log4j</groupId>
                        <artifactId>*</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>org.slf4j</groupId>
                        <artifactId>slf4j-log4j12</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-streaming-java_${scala.binary.version}</artifactId>
                <version>${flink.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>log4j</groupId>
                        <artifactId>*</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>org.slf4j</groupId>
                        <artifactId>slf4j-log4j12</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>com.google.code.findbugs</groupId>
                        <artifactId>jsr305</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>org.apache.flink</groupId>
                        <artifactId>force-shading</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-statebackend-rocksdb_${scala.binary.version}</artifactId>
                <version>${flink.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>log4j</groupId>
                        <artifactId>*</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>org.slf4j</groupId>
                        <artifactId>slf4j-log4j12</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-runtime-web_2.11</artifactId>
                <version>${flink.version}</version>
                <scope>provided</scope>
            </dependency>
            <!--kafka依赖-->
            <dependency>
                <groupId>org.apache.kafka</groupId>
                <artifactId>kafka-clients</artifactId>
                <version>${kafka.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-connector-kafka_2.11</artifactId>
                <version>${flink.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>log4j</groupId>
                        <artifactId>*</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>org.slf4j</groupId>
                        <artifactId>slf4j-log4j12</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <!--redis依赖-->
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>${redis.version}</version>
            </dependency>
            <!--lombok-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>${fastjson.verson}</version>
            </dependency>

            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-cep_2.11</artifactId>
                <version>${flink.version}</version>
            </dependency>

        </dependencies>
    </dependencyManagement>

4.2、UserLoginLog类

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
class UserLoginLog {
    /**
     * 登陆id
     */
    private int loginId;
    /**
     * 登陆时间
     */
    private long loginTime;
    /**
     * 登陆状态 1--登陆失败 0--登陆成功
     */
    private int loginStatus;
    /**
     * 登陆用户名
     */
    private String userName;
}

4.3、MyFlatMapFunction类

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.util.Collector;

@Slf4j
public class MyFlatMapFunction implements FlatMapFunction<String, UserLoginLog> {

    /**
     * The core method of the FlatMapFunction. Takes an element from the input data set and
     * transforms it into zero, one, or more elements.
     *
     * @param value The input value.
     * @param out   The collector for returning result values.
     * @throws Exception This method may throw exceptions. Throwing an exception will cause the
     *                   operation to fail and may trigger recovery.
     */
    @Override
    public void flatMap(String value, Collector<UserLoginLog> out) throws Exception {

        if (StringUtils.isNotBlank(value)) {
            UserLoginLog userLoginLog = JSONObject.parseObject(value, UserLoginLog.class);
            out.collect(userLoginLog);
        }


    }
}

4.4、MyPatternProcessFunction类

import lombok.extern.slf4j.Slf4j;
import org.apache.flink.cep.functions.PatternProcessFunction;
import org.apache.flink.util.Collector;

import java.util.List;
import java.util.Map;

@Slf4j
public class MyPatternProcessFunction extends PatternProcessFunction<UserLoginLog, UserLoginLog> {
    /**
     * Generates resulting elements given a map of detected pattern events. The events are
     * identified by their specified names.
     *
     * <p>{@link Context#timestamp()} in this case returns the time of the
     * last element that was assigned to the match, resulting in this partial match being finished.
     *
     * @param match map containing the found pattern. Events are identified by their names.
     * @param ctx   enables access to time features and emitting results through side outputs
     * @param out   Collector used to output the generated elements
     * @throws Exception This method may throw exceptions. Throwing an exception will cause the
     *                   operation to fail and may trigger recovery.
     */
    @Override
    public void processMatch(Map<String, List<UserLoginLog>> match, Context ctx, Collector<UserLoginLog> out) throws Exception {

        List<UserLoginLog> start = match.get("start");

        out.collect(start.get(0));
    }
}

4.4、主类

import lombok.extern.slf4j.Slf4j;
import org.apache.flink.api.common.eventtime.*;
import org.apache.flink.cep.CEP;
import org.apache.flink.cep.PatternStream;
import org.apache.flink.cep.pattern.Pattern;
import org.apache.flink.cep.pattern.conditions.IterativeCondition;
import org.apache.flink.cep.pattern.conditions.SimpleCondition;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
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 java.time.Duration;

@Slf4j
public class CepLearning {
    public static void main(String[] args) {

        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        /**
         * 设置成1，是为了能够触发watermark来计算
         */
        env.setParallelism(1);

        DataStreamSource<String> socketTextStream = env.socketTextStream("localhost", 8888);

        SingleOutputStreamOperator<UserLoginLog> dataStream = socketTextStream.flatMap(new MyFlatMapFunction())
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy.<UserLoginLog>forBoundedOutOfOrderness(Duration.ofSeconds(1))
                                .withTimestampAssigner((SerializableTimestampAssigner<UserLoginLog>) (element, recordTimestamp) -> element.getLoginTime())
                );


        /**
         * 10s钟之内连续3次登陆失败的才输出，强制连续
         */
        Pattern<UserLoginLog, UserLoginLog> wherePatternOne = Pattern.<UserLoginLog>begin("start").where(new SimpleCondition<UserLoginLog>() {
            @Override
            public boolean filter(UserLoginLog value) throws Exception {
                return 1 == value.getLoginStatus();
            }
        }).next("second").where(new IterativeCondition<UserLoginLog>() {
            @Override
            public boolean filter(UserLoginLog value, Context<UserLoginLog> ctx) throws Exception {

                return 1 == value.getLoginStatus();
            }
        }).next("third").where(new SimpleCondition<UserLoginLog>() {
            @Override
            public boolean filter(UserLoginLog value) throws Exception {

                return 1 == value.getLoginStatus();
            }
        }).within(Time.seconds(10));

        /**
         * 10s钟之内连续3次登陆失败的才输出,不强制连续
         */
        Pattern<UserLoginLog, UserLoginLog> wherePatternTwo = Pattern.<UserLoginLog>begin("start").where(new IterativeCondition<UserLoginLog>() {
            @Override
            public boolean filter(UserLoginLog value, Context<UserLoginLog> ctx) throws Exception {
                return 1 == value.getLoginStatus();
            }
        }).times(3).within(Time.seconds(10));

        /**
         * 10s钟之内连续3次登陆失败的才输出,加上 consecutive 之后 就是 强制连续输出
         */
        Pattern<UserLoginLog, UserLoginLog> wherePatternThree = Pattern.<UserLoginLog>begin("start").where(new IterativeCondition<UserLoginLog>() {
            @Override
            public boolean filter(UserLoginLog value, Context<UserLoginLog> ctx) throws Exception {
                return 1 == value.getLoginStatus();
            }
        }).times(3).consecutive().within(Time.seconds(10));


        PatternStream<UserLoginLog> patternStream = CEP.pattern(dataStream, wherePatternOne);

        PatternStream<UserLoginLog> patternStream1 = CEP.pattern(dataStream, wherePatternTwo);

        PatternStream<UserLoginLog> patternStream2 = CEP.pattern(dataStream, wherePatternThree);


        SingleOutputStreamOperator<UserLoginLog> process = patternStream.process(new MyPatternProcessFunction());
        SingleOutputStreamOperator<UserLoginLog> process1 = patternStream1.process(new MyPatternProcessFunction());
        SingleOutputStreamOperator<UserLoginLog> process2 = patternStream2.process(new MyPatternProcessFunction());

        process.print("resultOutPut");

        process1.print("resultOutPutTwo");

        process2.print("resultOutPutThree");

        try {
            env.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


}

一个数据小开发
关注
专栏目录
一个Flink-Cep使用案例
微信搜：import_bigdata，大数据领域硬核原创作者
08-29 1178
声明：本系列博客部分是根据SGG的视频整理而成，非常适合大家入门学习。部分文章是通过爬虫等技术手段采集的，目的是学习分享，如果有版权问题请留言，随时删除。 《2021年最新版大数据面试题全面开启更新》 本篇主要演练使用Flink-Cep+Groovy+Aviator 来实现一个物联网监控规则中的一个场景案例，后续将会介绍如何实现规则动态变更。 技术背景简介 Flink-Cep 是flink中的高级library，用于进行复杂事件处理，例如某一类事件连续出现三次就触发告警，可以类比Siddhi、E
【Flink】 CEP 简单例子
一杯咖啡半杯糖的博客
03-31 1387
1、引入依赖（注意版本要和flink版本一致，例子暂用1.12版本） <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-cep_2.11</artifactId> <version>1.12.7</version> </dependency> 2、定义传递类 package com.test
Flink CEP(十) 案例 对用户登录行为进行检测，检测在2秒内连续登录失败次数10次，输出警告信息
技术博客
08-02 160
flink cep 案例1
大数据-130 - Flink CEP 详解 - CEP开发流程 与 案例实践：恶意登录检测实现
永远好奇，无限进步！
09-11 4538
所以，二进制输入完毕，如果满足最终状态，也就是最后停在S1状态，那么输入的二进制数就含有偶数个0。对超时的部分模式序列应用超时函数，对于每个部分模式序列，调用提供的 PatternTimeoutFunction，模式超时函数只能产生一个结果元素。对检测到的序列模式序列应用选择函数，对于每个模式序列，调用提供的 PatternSelectFunction，模式选择函数只能产生一个结果元素。从图上可以看出，输入只有1和0两种。所以有限状态机的工作过程，就是从开始状态，根据不同的输入，自动进行转换的过程。
Flink之CEP案例分析-网络攻击检测
热门推荐
VinoYang的专栏
03-01 1万+
上一篇我们介绍了Flink CEP的API，这一篇我们将以结合一个案例来练习使用CEP的API编写应用程序，以强化对API的理解。所选取的案例是对网络遭受的潜在攻击进行检测并给出告警。当下互联网安全形势仍然严峻，网络攻击屡见不鲜且花样众多，这里我们以DDOS（分布式拒绝服务攻击）产生的流入流量来作为遭受攻击的判断依据。
flink CEP示例
a3125504x的博客
10-01 1049
CEP示例三分钟时间内，出现三次及以上的温度高于40度就算作是异常温度，进行报警输出创建订单之后15分钟之内一定要付款，否则就取消订单 三分钟时间内，出现三次及以上的温度高于40度就算作是异常温度，进行报警输出 场景介绍 现在工厂当中有大量的传感设备，用于检测机器当中的各种指标数据，例如温度，湿度，气压等，并实时上报数据到数据中心，现在需要检测，某一个传感器上报的温度数据是否发生异常。 异常的定义 三分钟时间内，出现三次及以上的温度高于40度就算作是异常温度，进行报警输出 测试数据
【Flink】Flink CEP 案例
九师兄
07-01 592
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.
Apache Flink CEP复杂事件处理详解及实战案例
最新发布
10-15
内容概要：本文详细介绍了Apache Flink的FlinkCEP模块，讲解了其安装配置、事件流处理基础及其应用场景，其中包括电商欺诈检测、网络监控、实时交易系统的模式匹配以及社交媒体趋势分析的具体实现。通过多个实战示例...
Flink CEP原理与代码实例讲解
AI架构设计之禅
06-13 724
Flink CEP原理与代码实例讲解 1. 背景介绍 1.1 什么是复杂事件处理(CEP) 复杂事件处理(Complex Event Processing, CEP)是一种技术，用于从多个事件源实时地分析数据流，以便识别有意义
FlinkCEP - Flink的复杂事件处理详解
L
08-21 272
FlinkCEP是在Flink之上实现的复杂事件处理（CEP）库。它允许在无尽的事件流中检测事件模式，使您有机会掌握数据中重要的内容。FlinkCEP类似字符串中，使用正则表达式检测感兴趣的字符串。如果您想直接开始，可以设置Flink程序并将FlinkCEP依赖项添加到项目的pom.xml中。2.12为scala版本，1.71.1为flink版本。FlinkCEP不是二进制发行版的一部分。
（十八）Flink CEP 详解
springk的专栏
08-25 665
Flink CEP 是在 Flink 上层实现的复杂事件处理库。它可以让你在无限事件流中检测出特定的事件模型，有机会掌握数据中重要的部分。Flink CEP 主要用于实时流数据的分析处理。这在企业项目的风控管理、用户画像和运维监控中，都有非常重要的应用。通过本章的介绍结合实际案例，让你进一步了解Flink CEP 的使用。
FlinkCEP - Flink的复杂事件处理 - 简单案例
京河小蚁的博客
06-18 517
下面两个pattern： 1. 5s内点击浏览了商品3次 2. 3秒内先点击浏览商品，然后将商品加入收藏 更多关于flink cep内容请移步到https://github.com/DeveloperZJQ/learning-flink/blob/master/flink-learning-base/src/main/java/com/flink/cep/CEPDemo1.java.........
Flink_CEP 功能和简单案例
weixin_45417821的博客
03-15 697
文章目录FlinkCEP——Flink的复杂事件处理FlinkCEP 简单流程Pattern API个体模式(Individual Patterns)量词条件模式组(Groups of Patterns)近邻引入 FlinkCEP——Flink的复杂事件处理 FlinkCEP是在Flink之上实现的复杂事件处理 （CEP）库。它使您可以检查无穷无尽的事件流的事件模型，从而使您有机会掌握数据中的重要信息 FlinkCEP 简单流程 DataStream<Event> input = ... Pa
Flink CEP
bigdata_wangzhe的博客
03-14 269
什么是 CEP 复杂事件处理（Complex Event Processing，CEP） Flink CEP是在 Flink 中实现的复杂事件处理（CEP）库 CEP 允许在无休止的事件流中检测事件模式，让我们有机会掌握数据中重要的部分 一个或多个由简单事件构成的事件流通过一定的规则匹配，然后输出用户想得到的数据 —— 满足规则的复杂事件 CEP 的特点 目标：从有序的简单事件流中发现一些高阶特征 输入：一个或多个由简单事件构成的事件流 处理：识别简单事件之间的内在联系，多个符合一定规则的简单事件构
Flink CEP 示例（可运行）
swing2008的专栏
02-25 1176
package com.cep import org.apache.flink.api.common.serialization.SimpleStringSchema import org.apache.flink.cep.PatternSelectFunction import org.apache.flink.cep.pattern.conditions.SimpleCondition import org.apache.flink.cep.scala.pattern.Pattern import .
Flink的CEP使用流程+使用案例
haibucuoba的博客
07-23 6239
一、CEP 一个或多个由简单事件构成的事件流通过一定的规则匹配，然后输出用户想得到的数据，满足规则的复杂事件。 CEP支持在流上进行模式匹配，根据模式的条件不同，分为连续的条件或不连续的条件；模式的条件允许有时间的限制，当在条件范围内没有达到满足的条件时，会导致模式匹配超时。 、 CEP就相当于在流上对event进行模式匹配。比如 连续两条登录失败日志不超过2秒，则进行错误预...
Flink CEP 订单案例
qq_31866793的博客
08-29 1113
1，下面代码要注意的点： 1）函数可能会报错，需要引入scala Map 2）以为我们的条件是next 严格相邻，所以第一条数据会被过滤掉不满足条件，它不会出现在测流，就是被过滤掉了，如果想要测流拿到不满足的数据，正常应该用followBy或者其他模式; 2，具体代码 package com.coder.flink.core.a_bilibili import org....
大数据-131 - Flink CEP 案例：检测交易活跃用户、超时未交付
永远好奇，无限进步！
09-12 3625
通过Flink CEP，开发者可以从流数据中识别出特定的事件模式。将模式应用到流中：将定义好的模式应用到事件流上，生成模式流PatternStream。定义事件模式：使用Flink CEP的API定义事件模式，例如连续事件、迟到事件等。提取匹配事件：使用select函数提取匹配模式的事件，并定义如何处理这些事件。Flink CEP的核心是通过定义事件模式，从流中检测复杂事件序列。定义事件流：创建一个DataStream，表示原始的事件流。业务上需要找出24小时内，至少5次有效交易的用户。
flink cep案例
07-29
Flink（流处理框架）与Complex Event Processing (CEP，复杂事件处理) 结合，可以实现在实时数据流中检测并分析复杂的业务逻辑，比如金融交易中的异常检测、物联网设备的行为模式识别等。Flink CEP案例通常包括以下几个步骤： 1. **事件流处理**：首先，Flink从源头收集数据流，如Kafka、HTTP请求或数据库查询结果。 2. **窗口定义**：设置时间窗口，比如滑动窗口或 tumbling 窗口，以便在特定时间段内聚合和处理事件。 3. **事件条件表达式**：使用Flink的CPE库或相似功能，编写匹配规则，比如“当A事件和B事件在某个时间间隔内先后发生”这样的规则。 4. **事件触发**：当满足预定义的条件时，系统会自动触发相应的处理操作。 5. **流式决策**：基于匹配到的事件序列，执行实时的业务决策，例如生成警报、调整策略或触发下游动作。 6. **响应优化**：由于Flink的低延迟特性，处理结果能快速返回给用户或驱动其他系统操作。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值