Apache flink 如何在其他流的基础上过滤ApacheFlink流？

我有两个流，一个是Int，另一个是json。在json模式中，有一个键是Int。因此我需要通过与另一个整数流的键比较来过滤json流，这样在Flink中可能吗？

是的，您可以使用Flink进行这种流处理。Flink需要的基本构建块是连接流和有状态函数——下面是一个使用RichCoFlatMap的示例：

import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.api.common.typeinfo.TypeHint;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.co.RichCoFlatMapFunction;
import org.apache.flink.util.Collector;

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

        DataStream<Event> control = env.fromElements(
                new Event(17),
                new Event(42))
                .keyBy("key");

        DataStream<Event> data = env.fromElements(
                new Event(2),
                new Event(42),
                new Event(6),
                new Event(17),
                new Event(8),
                new Event(42)
                )
                .keyBy("key");

        DataStream<Event> result = control
                .connect(data)
                .flatMap(new MyConnectedStreams());

        result.print();

        env.execute();
    }

    static final class MyConnectedStreams
            extends RichCoFlatMapFunction<Event, Event, Event> {

        private ValueState<Boolean> seen = null;

        @Override
        public void open(Configuration config) {
            ValueStateDescriptor<Boolean> descriptor = new ValueStateDescriptor<>(
                    // state name
                    "have-seen-key",
                    // type information of state
                    TypeInformation.of(new TypeHint<Boolean>() {
                    }));
            seen = getRuntimeContext().getState(descriptor);
        }

        @Override
        public void flatMap1(Event control, Collector<Event> out) throws Exception {
            seen.update(Boolean.TRUE);
        }

        @Override
        public void flatMap2(Event data, Collector<Event> out) throws Exception {
            if (seen.value() == Boolean.TRUE) {
                out.collect(data);
            }
        }
    }


    public static final class Event {
        public Event() {
        }

        public Event(int key) {
            this.key = key;
        }

        public int key;

        public String toString() {
            return String.valueOf(key);
        }
    }
}

import org.apache.flink.api.common.state.ValueState；
导入org.apache.flink.api.common.state.ValueStateDescriptor；
导入org.apache.flink.api.common.typeinfo.TypeHint；
导入org.apache.flink.api.common.typeinfo.TypeInformation；
导入org.apache.flink.configuration.configuration；
导入org.apache.flink.streaming.api.datastream.datastream；
导入org.apache.flink.streaming.api.environment.StreamExecutionEnvironment；
导入org.apache.flink.streaming.api.functions.co.RichCoFlatMapFunction；
导入org.apache.flink.util.Collector；
公共类连接{
公共静态void main（字符串[]args）引发异常{
最终StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment（）；
数据流控件=env.fromElements(
新事件（17），
新活动（42））
.keyBy（“key”）；
DataStream data=env.fromElements(
新事件（2），
新事件（42），
新事件（6），
新事件（17），
新事件（8），
新活动（42）
)
.keyBy（“key”）；
数据流结果=控制
.连接（数据）
.flatMap（新的MyConnectedStreams（））；
result.print（）；
execute（）；
}
静态最终类MyConnectedStreams
扩展RichCoFlatMapFunction{
private ValueState seen=null；
@凌驾
公共无效打开（配置）{
ValueStateDescriptor描述符=新的ValueStateDescriptor(
//州名
“见过钥匙”，
//状态类型信息
TypeInformation.of（新的TypeHint（）{
}));
seen=getRuntimeContext（）.getState（描述符）；
}
@凌驾
公共void flatMap1（事件控制，收集器输出）引发异常{
seen.update（Boolean.TRUE）；
}
@凌驾
公共void flatMap2（事件数据，收集器输出）引发异常{
if（seen.value（）==Boolean.TRUE）{
收集（数据）；
}
}
}
公共静态最终类事件{
公共活动（）{
}
公共事件（整数键）{
this.key=key；
}
公钥；
公共字符串toString（）{
返回字符串.valueOf（键）；
}
}
}

在本例中，只有那些在控制流上看到的键才会通过数据流——所有其他事件都会被过滤掉。我利用了和

为了简单起见，我忽略了您对数据流具有JSON的要求，但是您可以在其他地方找到如何使用JSON和Flink的示例

请注意，您的结果将是不确定的，因为您无法控制两个流相对于另一个流的计时。您可以通过向流添加事件时间戳，然后改用RichCoProcessFunction来管理这一点