javaCEP超时数据

已于 2022-08-02 19:05:12 修改
阅读量176 收藏
点赞数
分类专栏： flink 文章标签： java jvm apache
于 2022-07-26 15:31:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdnfan_/article/details/125995989
版权 
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;

/**
 * @author jiasongfan
 * @date 2022/7/26
 * @apiNote
 */
public class CEPTest05 {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        SingleOutputStreamOperator<LoginEvent> timeDS = env.fromElements(
                new LoginEvent("user_1", "order_1", "create", 1000L),
                new LoginEvent("user_2", "order_2", "create", 2000L),
                new LoginEvent("user_1", "order_1", "modify", 10*1000L),
                new LoginEvent("user_1", "order_1", "pay", 60*1000L),
                new LoginEvent("user_2", "order_3", "create", 10*60*1000L),
                new LoginEvent("user_2", "order_3", "pay", 20*60*1000L),
                new LoginEvent("user_2", "order_2", "create", 30*60*1000L)

        ).assignTimestampsAndWatermarks(WatermarkStrategy
                .<LoginEvent>forBoundedOutOfOrderness(Duration.ofSeconds(0))
                .withTimestampAssigner((event, timestamp) -> event.timestamp));

        KeyedStream<LoginEvent, String> keyDS = timeDS.keyBy(data -> data.ipAddress);
        Pattern<LoginEvent, LoginEvent> pattern = Pattern.<LoginEvent>begin("create").where(
                new SimpleCondition<LoginEvent>() {
                    @Override
                    public boolean filter(LoginEvent event) {
                        return event.eventType.equals("create");
                    }
                }
        ).followedBy("pay").subtype(LoginEvent.class).where(
                new SimpleCondition<LoginEvent>() {
                    @Override
                    public boolean filter(LoginEvent subEvent) {
                        return subEvent.eventType.equals("pay");
                    }
                }
        ).within(Time.minutes(15));

        PatternStream<LoginEvent> patternStream = CEP.pattern(keyDS, pattern);
        OutputTag<String> outputTag = new OutputTag<String>("late_data") {
        };
        SingleOutputStreamOperator<String> process = patternStream.process(new MyPro2());
        process.print("正常");

        process.getSideOutput(outputTag).print("未支付");

        env.execute();

    }

    public static  class MyPro2  extends PatternProcessFunction<LoginEvent,String>  implements TimedOutPartialMatchHandler<LoginEvent>{

        @Override
        public void processMatch(Map<String, List<LoginEvent>> map, Context context, Collector<String> collector) throws Exception {
            LoginEvent pay = map.get("pay").get(0);
            collector.collect(pay.ipAddress+"已支付");
        }

        @Override
        public void processTimedOutMatch(Map<String, List<LoginEvent>> map, Context context) throws Exception {
            LoginEvent create = map.get("create").get(0);
            //测流必须相同
            OutputTag<String> outputTag = new OutputTag<String>("late_data") {
            };
            context.output(outputTag,create.ipAddress+"未支付");
        }
    }
}

获取连续登录失败

/**
 * @author jiasongfan
 * @date 2022/7/26
 * @apiNote
 */
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.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 java.time.Duration;
import java.util.List;
import java.util.Map;

public class CEPTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        SingleOutputStreamOperator<LoginEvent> timeDS = 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", "172.56.23.10", "fail", 5000L),
                new LoginEvent("user_2", "192.168.1.29", "success", 6000L),
                new LoginEvent("user_2", "192.168.1.29", "fail", 7000L),
                new LoginEvent("user_2", "192.168.1.29", "fail", 8000L)
        ).assignTimestampsAndWatermarks(WatermarkStrategy
                .<LoginEvent>forBoundedOutOfOrderness(Duration.ofSeconds(20))
                .withTimestampAssigner((event, timestamp) -> event.timestamp));


        KeyedStream<LoginEvent, String> keyDS = timeDS.keyBy(data -> data.userId);


        //连续三次登录失败

        Pattern<LoginEvent, LoginEvent> pattern = Pattern.<LoginEvent>begin("first").where(
                new SimpleCondition<LoginEvent>() {
                    @Override
                    public boolean filter(LoginEvent event) {
                        return event.eventType.equals("fail");
                    }
                }
        )
                .times(3);
        //        .next("second").subtype(LoginEvent.class).where(
        //        new SimpleCondition<LoginEvent>() {
        //            @Override
        //            public boolean filter(LoginEvent subEvent) {
        //                return subEvent.eventType.equals("fail");
        //            }
        //        }
        //).next("third").subtype(LoginEvent.class).where(
        //        new SimpleCondition<LoginEvent>() {
        //            @Override
        //            public boolean filter(LoginEvent subEvent) {
        //                return subEvent.eventType.equals("fail");
        //            }
        //        }
        //);

        PatternStream<LoginEvent> patternStream = CEP.pattern(keyDS, pattern);

        //4.将检测到的复杂事件提取出来,进行处理得到报警信息输出
        SingleOutputStreamOperator<String> select = patternStream.select(new PatternSelectFunction<LoginEvent, String>() {
            @Override
            public String select(Map<String, List<LoginEvent>> map) throws Exception {
                //提取复杂事件的三次登录失败时间
                LoginEvent first = map.get("first").get(0);
               // LoginEvent second = map.get("second").get(0);
               // LoginEvent third = map.get("third").get(0);
                return first.userId+"连续三次登录失败,登录时间"
                        +first.timestamp+ ","
                       // +second.timestamp+ ","+
                       // +third.timestamp
                        ;
            }
        });

        select.print();
        env.execute("Window WordCount");
    }
}

cep  json

/**
 * @author jiasongfan
 * @date 2022/7/29
 * @apiNote
 */
import com.alibaba.fastjson.JSONObject;
import jdk.nashorn.internal.scripts.JO;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.cep.CEP;
import org.apache.flink.cep.PatternSelectFunction;
import org.apache.flink.cep.PatternStream;
import org.apache.flink.cep.PatternTimeoutFunction;
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.DataStream;
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.streaming.connectors.kafka.FlinkKafkaConsumer;
import org.apache.flink.util.Collector;
import org.apache.flink.util.OutputTag;

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

public class Test01 {
    public static void main(String[] args) throws Exception {
        //2)创建maven项目，导入相关flink依赖（10分）
        //3)设置流环境变量（10分）
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //4)设置并行度为1（10分）
        env.setParallelism(1);
        //5)获取kafak的dwd_page_log数据源（10分）
        Properties properties = new Properties();
        properties.setProperty("bootstrap.servers", "hdp1:9092");
        properties.setProperty("group.id", "test");
        DataStream<String> stream = env
                .addSource(new FlinkKafkaConsumer<>("dwd_page_log", new SimpleStringSchema(), properties));


        //创建测试数据
        DataStream<String> dataStream = env
                .fromElements(
                        "{\"common\":{\"mid\":\"101\"},\"page\":{\"page_id\":\"home\"},\"ts\":10000} ",
                        "{\"common\":{\"mid\":\"102\"},\"page\":{\"page_id\":\"home\"},\"ts\":12000}",
                        "{\"common\":{\"mid\":\"102\"},\"page\":{\"page_id\":\"good_list\",\"last_page_id\":" +
                                "\"home\"},\"ts\":15000} ",
                        "{\"common\":{\"mid\":\"102\"},\"page\":{\"page_id\":\"good_list\",\"last_page_id\":" +
                                "\"detail\"},\"ts\":30000}"
                );




        //6)将数据转换成json对象并指定事件时间（10分）
        SingleOutputStreamOperator<JSONObject> map = dataStream.map(data -> JSONObject.parseObject(data));
        //指定事件时间
        SingleOutputStreamOperator<JSONObject> timeDS = map.assignTimestampsAndWatermarks(WatermarkStrategy
                .<JSONObject>forBoundedOutOfOrderness(Duration.ofSeconds(0))
                .withTimestampAssigner((event, timestamp) -> event.getLong("ts")));
        //分组
        KeyedStream<JSONObject, String> keyDS = timeDS.keyBy(data -> data.getJSONObject("common").getString("mid"));
        //7)定义cep模式序列开始没有last_page_id的数据（5分）
      //  keyDS.print();
        //8)定义cep模式序列next没有last_page_id的数据（5分）
        //9)定义cep模式序列时间设置10S内（5分）
        Pattern<JSONObject, JSONObject> pattern = Pattern.<JSONObject>begin("start").where(
                new SimpleCondition<JSONObject>() {
                    @Override
                    public boolean filter(JSONObject event) {
                        String string = event.getJSONObject("page").getString("last_page_id");
                      if(string== null || string.length()==0){
                        //返回true表述符合筛选条件
                          return  true;
                      }
                        return false;
                    }
                }
        ).next("next").subtype(JSONObject.class).where(
                new SimpleCondition<JSONObject>() {
                    @Override
                    public boolean filter(JSONObject subEvent) {
                        String string = subEvent.getJSONObject("page").getString("page_id");
                        if(string!=null&& string.length()>0){
                            return  true;
                        }
                        return false;
                    }
                }
        ).within(Time.seconds(10));

        PatternStream<JSONObject> patternStream = CEP.pattern(keyDS, pattern);
        //10)讲模式序列添加到流中（5分）

        //SingleOutputStreamOperator<String> select = patternStream.select(new PatternSelectFunction<JSONObject, String>() {
        //    @Override
        //    public String select(Map<String, List<JSONObject>> map) throws Exception {
        //        JSONObject start = map.get("start").get(0);
        //        return start + "正常";
        //    }
        //});
        OutputTag<String> tag1 = new OutputTag<String>("late-data"){};
        SingleOutputStreamOperator<String> process = patternStream.process(new MyCERPro());

      //  process.print("非跳出");
        process.getSideOutput(tag1).print("跳出用户");

        // map.print();
        env.execute("Window WordCount");
    }
    public static class  MyCERPro extends PatternProcessFunction<JSONObject,String> implements TimedOutPartialMatchHandler<JSONObject>{

        @Override
        public void processMatch(Map<String, List<JSONObject>> map, Context context, Collector<String> collector) throws Exception {

        }

        @Override
        public void processTimedOutMatch(Map<String, List<JSONObject>> map, Context context) throws Exception {
            JSONObject start = map.get("start").get(0);
            OutputTag<String> tag1 = new OutputTag<String>("late-data"){};
            context.output(tag1,start+"跳出用户");
        }
    }
}

csdnfan_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cep java_Siddhi cep java 集成简单使用
weixin_40007016的博客
02-16 359
Siddhi 是一个开源的cep (Complex Event Processing)类库，有一个明显的例子是uber 的事件处理，具体可以google几张参考cep 以及siddhi 图 java 集成使用(使用maven)代码mavenxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="...
java cep aactor_IT系统监控的规则引擎-CEP
weixin_39703926的博客
03-04 428
CEP简介CEP全称为 Complex Event Processing 复杂事件处理，其可以通过在流式数据中发现符合某种特征的模式进而触发对应的后续动作，其既支持基于单条事件的简单无状态的模式匹配(例如基于事件中的某个字段进行筛选过滤)，也可以支持基于关联／聚合／时间窗口等跨事件的复杂有状态模式匹配(例如计算滑动时间窗口移动均值)。受益于其直接作用于流式数据，无需查询持久化数据库，对底层数据库不...
Flink超时数据提取
cts618
06-11 170
Flink超时数据提取
java cep_CEP是我需要的（系统状态和事件重放）
weixin_32357285的博客
02-23 319
我正在寻找一个CEP引擎，但我不知道是否有任何引擎符合我的要求 . 我的系统必须处理多个事件数据流并生成复杂的事件，这正是几乎所有CEP引擎完全适合的(ESPER，Drools) .我将所有原始事件存储在数据库中(它不是CEP部分，但我这样做)并使用规则(或连续查询或其他内容)来生成复杂事件的自定义操作 . 但我的一些规则依赖于过去的事件 . 例如：每当我的配偶来或离开家时我都可以发送一个传感器发...
cep java_交易系统中的CEP框架
weixin_30045711的博客
02-16 497
最近在搭建交易系统的过程中，学习了一下CEP框架的相关知识。CEP全称是复杂事务处理框架(Complex Event Processing)，他的特点简单概括如下：1、他的输入是一些简单的事件流2、接受到输入的事件流后，他通过内部核心的判别逻辑，根据事件特点，路由到相应的处理分支进行处理。举个实例，这个很像是有一种带收纳桶的积木玩具：可以把每一个积木粒当做一个个简单的事件，而cep框架就是收纳桶的...
CEPLite:用于终端设备的轻量级 java CEP（复杂事件处理）引擎
05-29
CEPLite 用于终端设备的轻量级 CEP（复杂事件处理）引擎。它特别适用于涉及处理连续事件收入并将其推送到云/服务器的物联网应用。 该项目背后的基本逻辑是，我们可以为发生的处理添加分布式特性，并在终端设备（如安卓手机/具有微型操作系统的传感器），然后将复杂的处理推送到云端。 将很快发布适用于 android 的实现。 尚待完成/尚在进行中：1）在Streams上向引擎添加联接。（建议！）2）扩展了对android的支持。 请联系： 任何查询/建议/错误。将很快发布引擎架构的详细文档。在此之前，请联系给定的电子邮件 ID 进行查询。
Socket接受数据超时
06-19
Socket接收数据超时是一个常见的问题，尤其在处理高并发或者网络环境不稳定的情况下。这个问题涉及到网络编程中的异步编程模型，以及如何优雅地处理阻塞操作。在本篇中，我们将深入探讨Socket接收数据超时的原理，...
PHP中Socket连接及读写数据超时问题分析
10-21
然而，Socket连接和数据读写过程中可能会遇到超时问题，这可能导致程序执行效率降低或者出现错误。本文将详细分析PHP中Socket连接及读写数据超时问题，并提供相应的解决策略。 首先，PHP的`fsockopen()`函数用于...
Ajax请求在数据量大的时候出现超时的解决方法
09-04
在开发Web应用时，我们经常会遇到使用Ajax进行数据交互的情况，特别是当数据量非常大时，可能会遇到Ajax请求超时的问题。这个问题不仅影响用户体验，也可能导致应用性能下降。本篇文章将详细探讨这个问题，并提供几...
串口使用超时判断接收数据帧
07-17
配合定时器中断，通过超时的方法，完成串口数据帧的接收。
bosphorus:一个实验性的分布式 Java CEP 引擎
06-30
博斯普鲁斯海峡 一个实验性分布式 Java 复杂事件处理器。 标量函数 日期函数 年 月 日期差异 月日 星期几 小时 分钟 第二 truncateToYear 截断到月 截断今天 truncateToHour 截断到分钟 截断到秒 现在 逻辑运算 和 或者 等于 不等于 一片空白 isNotNull 少于 小于或等于 比...更棒 大于或等于 在 不在 不是 数学函数 添加 减去 乘 划分 模组 字符串函数 解析日期 解析整数 解析长 解析浮点数 解析双 正则匹配 字符串连接 字符串包含 索引号 字符串连接 字符串长度 拆分 子串 其他功能 划分 身份 以前的 兑换 向导 如果 如果为空 随机的 聚合函数 团体 数数 计数不同 和 选择不同 第一的 最后的 分钟 最大限度 平均 标准偏差 中位数 投影示例 ListStreamBuilder ss = new ListStream
drools：Drools是Java的规则引擎，DMN引擎和复杂事件处理（CEP）引擎
02-03
适用于Java:trade_mark:和JVM平台的开源规则引擎， 和复杂事件处理（CEP）引擎。 Drools是一个业务规则管理系统，具有基于前向链接和后向链接推理的规则引擎，可以快速，可靠地评估业务规则和进行复杂的事件处理。 规则引擎还是创建专家系统的基本构建块，在人工智能中，该专家系统是模拟人类专家的决策能力的计算机系统。 请务必查看Drools的项目和！ 开发Drools和jBPM 如果要构建或参与kiegroup项目，请。 正确设置开发环境将为您和我们节省大量时间。 它解决了可能会破坏您的开发的所有已知陷阱。 它还描述了所有准则，技巧和窍门。 如果您希望将拉取请求（或补丁）合并到主请求中，请遵守这
BuscaCEP:使用Java的uma API的使用，使用常识通知软件，使用CEP进行大多数操作，使用USANDO Web服务Viacep
04-03
BuscaCEP 使用Java的uma API的使用，使用常识通知用户的软件，使用CEP和大多数Web服务的Web服务。
java批量加入约束_处理大量规则（条件和约束）CEP系统
weixin_27011811的博客
02-27 116
我正在开发一个接受100k独特输入的应用程序 - 为简单起见假设每个输入都是一个浮点值(a，b，c ......等) - 尽管它们也可以是字符串等 . 应用程序有很多规则/与这些输入相关的事件/触发器 .Example1:Rule[(a > b) and (c <= d)] --> [execute EventX]Definition1: 上述规则说：当输入'a'的值大于'b'的...
java flink（二十六） 实战之电商黑名单过滤 Flink CEP编程实现、什么是CEP、CEP组合模式demo、CEP循环模式demo
qq_40771567的博客
05-21 669
什么是CEP： 1、复杂事件处理 2、Flink中实现复杂事件处理库 3、CEP允许在无休止的事件中检测事件模式，让我们有机会掌握数据中的重要部分 4、一个或多个由简单事件构成的事件通过一定的规则匹配，然后输出用户想要的数据。 CEP API: begin 第一个事件定义 where 条件 next 后一个紧跟着事件定义 subtype 子类型判断 followedBy 后边的时间 不一定紧跟着 CEP 个体模式： CEP 模式序列 CEP 超时处理 ...
cep java_使用两次窗口查询Siddhi CEP
weixin_42512841的博客
02-23 231
您可以执行以下操作：define stream webvisit (idClient string, idProduct string, chanel string)from visits[productId =='Fondos’]#window.time(4 days)select idClient, idProduct, chanel, count(idClient) as visitCoun...
SODBASE CEP学习进阶篇（一）：除了Java还有C++
happynyear的博客
05-14 1213
许多监测系统、交易系统、实时数据挖掘分析算法是用C++写的，而且第三方接口也往往以C++动态库的方式出现。当你更偏好于使用C++编程语言的话，可以用SODBASE CEP C++ 接口来搭建流式计算系统。
flink 1.10.1 cep java版本案例（登录连续失败检测）
liaomingwu的专栏
02-10 1141
flink 1.10.1 cep java版本案例（登录连续失败检测）
Elsaticsearch java基本操作
最新发布
qq_62383709的博客
07-13 442
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
was数据源配置超时
01-12
根据提供的引用内容，以下是关于WebSphere Application Server（WAS）数据源配置超时的介绍： 在WAS中，数据源配置超时是指在连接到数据库时，如果连接超过了预设的时间限制，连接将被关闭。这个超时时间可以在数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值