Apache flink 如何检测模式a+；b+；与弗林克CEP

Flink CEP不适合我的模式。 我有一个序列，例如aabbaabbabb（a+b+）。 我希望函数过程显示如下输出： {aabbbb}{aaaabb}{abb}

AfterMatchSkipStrategy skipStrategy = AfterMatchSkipStrategy.skipPastLastEvent();
Pattern<JsonNode, JsonNode> attemptPattern = Pattern.<JsonNode>begin("first", skipStrategy)
        .where(new SPCondition() {
            @Override
            public boolean filter(JsonNode element, Context<JsonNode> context) throws Exception {
                return element.get("endpoint").textvalue().equals("A");
            }
        }).oneOrMore()
        .next("second")
        .where(new SPCondition() {
            @Override
            public boolean filter(JsonNode element, Context<JsonNode> context) throws Exception {
                return element.get("endpoint").textvalue().equals("B");
            }
        }).oneOrMore();

AfterMatchSkipStrategy skipStrategy=AfterMatchSkipStrategy.skipPastLastEvent（）；
Pattern attemptPattern=Pattern.begin（“第一”，skipststrategy）
.其中（新的SPCondition（）{
@凌驾
公共布尔筛选器（JsonNode元素、上下文）引发异常{
返回元素.get（“端点”）.textvalue（）.equals（“A”）；
}
}).一个或多个（）
.下一个（“第二个”）
.其中（新的SPCondition（）{
@凌驾
公共布尔筛选器（JsonNode元素、上下文）引发异常{
返回元素.get（“端点”）.textvalue（）.equals（“B”）；
}
}).一个或多个（）；

我的结果是：

---

{aab}{aaaab}{ab}

你需要以某种方式坚持它尽可能地使用所有的B，而不仅仅是在第一个之后匹配。这里有一种方法

public class CEPExample {

    public static void main(String[] args) throws Exception {

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        DataStream<String> events = env.fromElements("a", "a", "b", "b", "b", "b", "a", "a", "a", "a", "b", "b", "a", "b", "b", "x");

        AfterMatchSkipStrategy skipStrategy = AfterMatchSkipStrategy.skipToFirst("end");
        Pattern<String, String> pattern = Pattern.<String>begin("first", skipStrategy)
                .where(new SimpleCondition<String>() {
                    @Override
                    public boolean filter(String element) throws Exception {
                        return (element.equals("a"));
                    }
                }).oneOrMore()
                .next("second")
                .where(new SimpleCondition<String>() {
                    @Override
                    public boolean filter(String element) throws Exception {
                        return (element.equals("b"));
                    }
                }).oneOrMore()
                .next("end")
                .where(new SimpleCondition<String>() {
                    @Override
                    public boolean filter(String element) throws Exception {
                        return (!element.equals("b"));
                    }
                });

        PatternStream<String> patternStream = CEP.pattern(events, pattern);
        patternStream.select(new SelectSegment()).print();
        env.execute();
    }

    public static class SelectSegment implements PatternSelectFunction<String, String> {
        public String select(Map<String, List<String>> pattern) {
            return String.join("", pattern.get("first")) + String.join("", pattern.get("second"));
        }
    }

}

public类示例{
公共静态void main（字符串[]args）引发异常{
StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment（）；
环境(一)；
DataStream events=env.fromElements（“a”、“a”、“b”、“b”、“b”、“a”、“a”、“a”、“b”、“b”、“b”、“x”）；
AfterMatchSkipStrategy skipStrategy=AfterMatchSkipStrategy.skipToFirst（“结束”）；
模式模式=模式。开始（“第一”，SkipsStrategy）
.where（新的SimpleCondition（）{
@凌驾
公共布尔筛选器（字符串元素）引发异常{
回报（元素等于（“a”））；
}
}).一个或多个（）
.下一个（“第二个”）
.where（新的SimpleCondition（）{
@凌驾
公共布尔筛选器（字符串元素）引发异常{
收益（要素等于（“b”）；
}
}).一个或多个（）
.下一步（“结束”）
.where（新的SimpleCondition（）{
@凌驾
公共布尔筛选器（字符串元素）引发异常{
返回（！element.equals（“b”））；
}
});
PatternStream PatternStream=CEP.pattern（事件，模式）；
patternStream.select（新建SelectSegment（））.print（）；
execute（）；
}
公共静态类SelectSegment实现了PatternSelectFunction{
公共字符串选择（映射模式）{
返回String.join（“，pattern.get（“第一”））+String.join（“，pattern.get（“第二”）；
}
}
}

相反，如果您想匹配a+b*，虽然我觉得应该有一个更简单的解决方案，但以下是一些可行的方法：

public class CEPExample {

    public static void main(String[] args) throws Exception {

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        DataStream<String> events = env.fromElements("a", "a", "b", "b", "b", "b", "a", "a", "a", "a", "x");

        AfterMatchSkipStrategy skipStrategy = AfterMatchSkipStrategy.skipToFirst("end");
        Pattern<String, String> pattern = Pattern.<String>begin("a-or-b", skipStrategy)
                .where(new SimpleCondition<String>() {
                    @Override
                    public boolean filter(String element) throws Exception {
                        return element.equals("a") || element.equals("b");
                    }
                }).oneOrMore()
                .next("end")
                .where(new IterativeCondition<String>() {
                    @Override
                    public boolean filter(String element, Context<String> ctx) throws Exception {
                        List<String> list = new ArrayList<>();
                        ctx.getEventsForPattern("a-or-b").iterator().forEachRemaining(list::add);
                        int length = list.size();
                        if (!element.equals("a") && !element.equals("b")) return true;
                        return (((length >= 1) && element.equals("a") && list.get(length - 1).equals("b")));
                    }
                });

        PatternStream<String> patternStream = CEP.pattern(events, pattern);
        patternStream.select(new SelectSegment()).print();
        env.execute();
    }

    public static class SelectSegment implements PatternSelectFunction<String, String> {
        public String select(Map<String, List<String>> pattern) {
            return String.join("", pattern.get("a-or-b"));
        }
    }

}

public类示例{
公共静态void main（字符串[]args）引发异常{
StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment（）；
环境(一)；
DataStream events=env.fromElements（“a”、“a”、“b”、“b”、“b”、“a”、“a”、“a”、“x”）；
AfterMatchSkipStrategy skipStrategy=AfterMatchSkipStrategy.skipToFirst（“结束”）；
模式=模式。开始（“a或b”，跳过策略）
.where（新的SimpleCondition（）{
@凌驾
公共布尔筛选器（字符串元素）引发异常{
返回元素.equals（“a”）|元素.equals（“b”）；
}
}).一个或多个（）
.下一步（“结束”）
.where（新的迭代条件（）{
@凌驾
公共布尔筛选器（字符串元素，上下文ctx）引发异常{
列表=新的ArrayList（）；
ctx.getEventsForPattern（“a-or-b”）.iterator（）.forEachRemaining（list:：add）；
int length=list.size（）；
如果（！element.equals（“a”）和（&！element.equals（“b”）返回true；
返回（（长度>=1）和&element.equals（“a”）和&list.get（长度-1.equals（“b”））；
}
});
PatternStream PatternStream=CEP.pattern（事件，模式）；
patternStream.select（新建SelectSegment（））.print（）；
execute（）；
}
公共静态类SelectSegment实现了PatternSelectFunction{
公共字符串选择（映射模式）{
返回字符串.join（“，pattern.get”（“a-or-b”）；
}
}
}

---

不管它值多少钱，我通常发现它提供了一种更直接的DSL，用于与Flink进行模式匹配。

亲爱的David。谢谢你的回复。解决了我的问题，但我想要a+b*模式。如何检测a+b*？（例如输入：aaaaaaaaaaaapattern detected:aaaaaaaaaaa）查看我的更新答案以及我的建议，即使用带有match_recognize（编译为下面的CEP）的Flink SQL进行调查。