1. Transformieren
Transformationsoperatoren können einen oder mehrere DataStreams in einen neuen DataStream konvertieren. Programme können mehrere komplexe Transformationen zu komplexen Datenflusstopologien kombinieren.
2. Grundlegender Konvertierungsoperator
2.1, Karte (Zuordnung)
Transformieren Sie die Daten im Datenstrom, um einen neuen Datenstrom zu bilden, ein Element zu konsumieren und ein Element zu erzeugen
package com.lyh.flink05;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.DataSource;
public class Transform_map {
public static void main(String[] args) throws Exception {
ExecutionEnvironment svn = ExecutionEnvironment.getExecutionEnvironment();
DataSource<Integer> s_num = svn.fromElements(1, 2, 3, 4, 5);
s_num.map(new MapFunction<Integer, Integer>() {
@Override
public Integer map(Integer values) throws Exception {
return values*values;
}
}).print();
}
}
2.2, Filter (Filter)
Gemäß den angegebenen Regeln werden die Daten, die die Bedingung erfüllen (wahr), beibehalten und die Daten, die die Bedingung nicht erfüllen (falsch), verworfen
package com.lyh.flink05;
import org.apache.flink.api.common.functions.FilterFunction;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.DataSource;
public class Transform_filter {
public static void main(String[] args) throws Exception {
ExecutionEnvironment svn = ExecutionEnvironment.getExecutionEnvironment();
DataSource<Integer> elements = svn.fromElements(1, 2, 3, 4, 5, 6, 7, 8, 9);
// elements.filter(new FilterFunction<Integer>() {
// @Override
// public boolean filter(Integer integer) throws Exception {
// if (integer % 2 == 0 )
// return false;
// else {
// return true;
// }
// }
// }).print();
elements.filter(value -> value % 2 != 0).print();
}
}
2.3, flatMap (flache Karte)
verbraucht ein Element und produziert null oder mehr Elemente
package com.lyh.flink05;
import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.DataSource;
import org.apache.flink.util.Collector;
import java.util.concurrent.ExecutionException;
public class flatMap {
public static void main(String[] args) throws Exception {
ExecutionEnvironment svn = ExecutionEnvironment.getExecutionEnvironment();
DataSource<Integer> dataSource = svn.fromElements(1, 2, 3);
dataSource.flatMap(new FlatMapFunction<Integer, Integer>() {
@Override
public void flatMap(Integer integer, Collector<Integer> collector) throws Exception {
collector.collect(integer*integer);
collector.collect(integer*integer*integer);
}
}).print();
}
}
3. Aggregationsoperator
3.1, keyBy (Schlüsselpartition)
Teilen Sie die Daten im Stream in verschiedene Partitionen auf (Parallelität). Elemente mit demselben Schlüssel werden in dieselbe Partition unterteilt
package com.lyh.flink05;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
public class keyBy_s {
public static void main(String[] args) throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
// this can be used in a streaming program like this (assuming we have a StreamExecutionEnvironment env)
env.fromElements(Tuple2.of(2L, 3L), Tuple2.of(1L, 5L), Tuple2.of(1L, 7L), Tuple2.of(2L, 4L), Tuple2.of(1L, 2L))
.keyBy(0) // 以数组的第一个元素作为key
.map((MapFunction<Tuple2<Long, Long>, String>) longLongTuple2 -> "key:" + longLongTuple2.f0 + ",value:" + longLongTuple2.f1)
.print();
env.execute("execute");
}
}
3.2, sum, min, max, minBy, maxBy (einfache Aggregation)
Jeder Zweig des KeyedStream wird aggregiert. Nach Abschluss der Ausführung werden die aggregierten Ergebnisse zu einem Stream zusammengefasst und zurückgegeben, sodass alle Ergebnisse DataStream sind
package com.lyh.flink05;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
public class keyBy_s {
public static void main(String[] args) throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
// this can be used in a streaming program like this (assuming we have a StreamExecutionEnvironment env)
env.fromElements(Tuple2.of(2L, 3L), Tuple2.of(1L, 5L), Tuple2.of(1L, 7L), Tuple2.of(2L, 4L), Tuple2.of(1L, 2L))
.keyBy(0) // 以数组的第一个元素作为key
.sum(1)
.print();
env.execute("execute");
}
}
3.3, reduzieren (Reduktionsaggregation)
Der Aggregationsvorgang eines gruppierten Datenstroms kombiniert das aktuelle Element und das Ergebnis der letzten Aggregation, um einen neuen Wert zu generieren, und der zurückgegebene Stream enthält die Ergebnisse jeder Aggregation, anstatt nur das Endergebnis der letzten Aggregation zurückzugeben.
package com.lyh.flink05;
import org.apache.flink.api.common.functions.ReduceFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
public class keyByReduce {
public static void main(String[] args) throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(2);
env.fromElements(Tuple2.of(1L,2L),Tuple2.of(2L,4L),Tuple2.of(2L,9L),Tuple2.of(1L,9L),Tuple2.of(1L,2L),Tuple2.of(2L,3L))
.keyBy(0)
.reduce(new ReduceFunction<Tuple2<Long, Long>>() {
@Override
public Tuple2<Long, Long> reduce(Tuple2<Long, Long> values1, Tuple2<Long, Long> values2) throws Exception {
return new Tuple2<>(values1.f0,values1.f1+values2.f1);
}
})
.print();
env.execute();
}
}
3.4, Prozess (zugrunde liegende Verarbeitung)
Der Prozessoperator ist ein Operator auf relativ niedriger Ebene in Flink. Er kann für viele Arten von Streams aufgerufen werden, und aus den Streams können mehr Informationen abgerufen werden (nicht nur die Daten selbst). Die Verwendung von Prozessen ist flexibler und wir werde später spezielle Nachforschungen anstellen.
package com.lyh.flink05;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.streaming.api.datastream.DataStream;
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.functions.ProcessFunction;
import org.apache.flink.util.Collector;
import org.apache.flink.util.OutputTag;
public class Process_s {
public static void main(String[] args) throws Exception {
// 获取环境
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(1);
DataStreamSource<Integer> streamSource = env.fromElements(1, 2, 3, 4, 5);
SingleOutputStreamOperator<Integer> processed = streamSource.process(new ProcessFunction<Integer, Integer>() {
@Override
public void processElement(Integer value, Context ctx, Collector<Integer> out) throws Exception {
if (value % 3 == 0) {
//测流数据
ctx.output(new OutputTag<Integer>("3%0", TypeInformation.of(Integer.class)), value);
}
if (value % 3 == 1) {
//测流数据
ctx.output(new OutputTag<Integer>("3%1", TypeInformation.of(Integer.class)), value);
}
//主流 ,数据
out.collect(value);
}
});
DataStream<Integer> output0 = processed.getSideOutput(new OutputTag<>("3%0",TypeInformation.of(Integer.class)));
DataStream<Integer> output1 = processed.getSideOutput(new OutputTag<>("3%1",TypeInformation.of(Integer.class)));
output1.print();
env.execute();
}
}
4. Konfluenzoperator
4.1, verbinden (Verbindung)
In einigen Fällen müssen wir zwei Datenströme aus unterschiedlichen Quellen verbinden, um einen Datenabgleich zu erreichen, z. B. Bestellzahlungs- und Transaktionsinformationen Dritter. Die Daten dieser beiden Informationen stammen aus unterschiedlichen Datenquellen. Nach der Verbindung erfolgt die Bestellung Die Zahlung und die Transaktionsinformationen Dritter werden abgeglichen. Zu diesem Zeitpunkt kann die tatsächliche Zahlung als abgeschlossen betrachtet werden.
Der Verbindungsoperator in Flink kann zwei Datenströme verbinden, die ihren Typ beibehalten. Nachdem die beiden Datenströme verbunden wurden, werden sie nur im selben Strom platziert und ihre jeweiligen Daten und Formen bleiben intern unverändert. Streams sind unabhängig voneinander.
package com.lyh.flink05;
import org.apache.flink.streaming.api.datastream.ConnectedStreams;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.kafka.common.protocol.types.Field;
public class connect_s {
public static void main(String[] args) throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(1);
DataStreamSource<Integer> data1 = env.fromElements(1, 2, 3, 4, 5);
DataStreamSource<String> data2 = env.fromElements("a", "b", "c");
ConnectedStreams<Integer, String> data3 = data1.connect(data2);
data3.getFirstInput().print("data1");
data3.getSecondInput().print("data2");
env.execute();
}
}
4.2, Vereinigung (Zusammenführung)
package com.lyh.flink05;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
public class union_s {
public static void main(String[] args) throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(1);
DataStreamSource<Integer> data1 = env.fromElements(1, 2, 3);
DataStreamSource<Integer> data2 = env.fromElements(555,666);
DataStreamSource<Integer> data3 = env.fromElements(999);
DataStream<Integer> data = data1.union(data2).union(data3);
data.print();
env.execute();
}
}