1)创建一个执行环境,表示当前执行程序的上下文。
2)如果程序是独立调用的,则此方法返回本地执行环境;
3)如果从命令行客户端调用程序以提交到集群,则此方法返回此集群的执行环境,也就是说,
getExecutionEnvironment 会根据查询运行的方式决定返回什么样的运行环境,是最常用的一种创建执行环境的
方式。
//获得批处理执行环境 ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); //获得流处理执行环境 StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
如果没有设置并行度,会以 flink-conf.yaml中的配置为准,默认是 1。
返回本地执行环境,需要在调用时指定默认的并行度。
LocalStreamEnvironment env = StreamExecutionEnvironment.createLocalEnvironment(1);
1)返回集群执行环境,将 Jar 提交到远程服务器。
2)需要在调用时指定 JobManager 的 IP 和端口号,并指定要在集群中运行的 Jar 包。
StreamExecutionEnvironment env = StreamExecutionEnvironment.createRemoteEnvironment("jobmanage-hostname", 6123,"YOURPATH//WordCount.jar");
传感器对象实体
// 传感器温度读数的数据类型 public class SensorReading { // 属性:id,时间戳,温度值 private String id; private Long timestamp; private Double temperature; public SensorReading() { } public SensorReading(String id, Long timestamp, Double temperature) { this.id = id; this.timestamp = timestamp; this.temperature = temperature; } public String getId() { return id; } public void setId(String id) { this.id = id; } public Long getTimestamp() { return timestamp; } public void setTimestamp(Long timestamp) { this.timestamp = timestamp; } public Double getTemperature() { return temperature; } public void setTemperature(Double temperature) { this.temperature = temperature; } @Override public String toString() { return "SensorReading{" + "id='" + id + '\'' + ", timestamp=" + timestamp + ", temperature=" + temperature + '}'; } }
示例代码
import com.wyb.apitest.beans.SensorReading; import org.apache.flink.streaming.api.datastream.DataStream; import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; import java.util.Arrays; public class SourceTest1_Collection { public static void main(String[] args) throws Exception{ // 创建执行环境 StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); env.setParallelism(1); // 从集合中读取数据 DataStreamdataStream = env.fromCollection(Arrays.asList( new SensorReading("sensor_1", 1547718199L, 35.8), new SensorReading("sensor_6", 1547718201L, 15.4), new SensorReading("sensor_7", 1547718202L, 6.7), new SensorReading("sensor_10", 1547718205L, 38.1) )); DataStream integerDataStream = env.fromElements(1, 2, 4, 67, 189); // 打印输出 dataStream.print("data"); integerDataStream.print("int"); // 执行 env.execute(); } }
DataStreamdataStream = env.readTextFile("YOUR_FILE_PATH ");
pom.xml
org.apache.flink flink-connector-kafka-0.11_2.12 1.10.1
具体代码如下:
// kafka 配置项 Properties properties = new Properties(); properties.setProperty("bootstrap.servers", "localhost:9092"); properties.setProperty("group.id", "consumer-group"); properties.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer"); properties.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer"); properties.setProperty("auto.offset.reset", "latest"); // 从 kafka 读取数据 DataStreamdataStream = env.addSource( new FlinkKafkaConsumer011 ("sensor", new SimpleStringSchema(), properties));
除了以上的 source 数据来源,我们还可以自定义 source。需要做的,只是传入一个 SourceFunction 就可
以。具体调用如下:
DataStreamdataStream = env.addSource( new MySensor());
我们希望可以随机生成传感器数据,MySensorSource 具体的代码实现如下:
import com.wyb.apitest.beans.SensorReading; import org.apache.flink.streaming.api.datastream.DataStream; import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; import org.apache.flink.streaming.api.functions.source.SourceFunction; import java.util.HashMap; import java.util.Random; public class SourceTest4_UDF { public static void main(String[] args) throws Exception { StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); env.setParallelism(1); // 从文件读取数据 DataStreamdataStream = env.addSource(new MySensorSource()); // 打印输出 dataStream.print(); env.execute(); } // 实现自定义的SourceFunction public static class MySensorSource implements SourceFunction { // 定义一个标识位,用来控制数据的产生 private boolean running = true; @Override public void run(SourceContext ctx) throws Exception { // 定义一个随机数发生器 Random random = new Random(); // 设置10个传感器的初始温度 HashMap sensorTempMap = new HashMap<>(); for (int i = 0; i < 10; i++) { sensorTempMap.put("sensor_" + (i + 1), 60 + random.nextGaussian() * 20); } while (running) { for (String sensorId : sensorTempMap.keySet()) { // 在当前温度基础上随机波动 Double newtemp = sensorTempMap.get(sensorId) + random.nextGaussian(); sensorTempMap.put(sensorId, newtemp); ctx.collect(new SensorReading(sensorId, System.currentTimeMillis(), newtemp)); } // 控制输出频率 Thread.sleep(1000L); } } @Override public void cancel() { running = false; } } }
DataStreammapStram = dataStream.map(new MapFunction () { public Integer map(String value) throws Exception { return value.length(); } });
DataStreamflatMapStream = dataStream.flatMap(new FlatMapFunction () { public void flatMap(String value, Collector out) throws Exception { String[] fields = value.split(","); for( String field: fields ) out.collect(field); } });
DataStreamfilterStream = dataStream.filter(new FilterFunction () { public boolean filter(String value) throws Exception { return value == 1; } });
DataStream → KeyedStream:
逻辑地将一个流拆分成不相交的分区,每个分区包含具有相同 key的元素,在内部以 hash code重分区的形
式实现的。
这些算子可以针对 KeyedStream 的每一个支流做聚合。
⚫ sum()
⚫ min()
⚫ max()
⚫ minBy()
⚫ maxBy()
KeyedStream → DataStream
一个分组数据流的聚合操作,合并当前的元素和上次聚合的结果,产生一个新的值,返回的流中包含每一次
聚合的结果,而不是只返回最后一次聚合的最终结果。
DataStreaminputStream = env.readTextFile("sensor.txt"); // 转换成 SensorReading 类型 DataStream dataStream = inputStream.map(new MapFunction () { public SensorReading map(String value) throws Exception { String[] fileds = value.split(","); return new SensorReading(fileds[0], new Long(fileds[1]), new Double(fileds[2])); } }); // 分组 KeyedStream keyedStream = dataStream.keyBy("id"); // reduce 聚合,取最小的温度值,并输出当前的时间戳 DataStream reduceStream = keyedStream.reduce(new ReduceFunction () { @Override public SensorReading reduce(SensorReading value1, SensorReading value2) throws Exception { return new SensorReading(value1.getId(), value2.getTimestamp(), Math.min(value1.getTemperature(), value2.getTemperature())); } });
Split
DataStream → SplitStream
根据某些特征把一个 DataStream 拆分成两个或者多个 DataStream。
Select
SplitStream→DataStream
从一个 SplitStream 中获取一个或者多个DataStream。
需求:传感器数据按照温度高低(以 30 度为界),拆分成两个流。
SplitStreamsplitStream = dataStream.split(new OutputSelector () { @Override public Iterable select(SensorReading value) { return (value.getTemperature() > 30) ? Collections.singletonList("high") : Collections.singletonList("low"); } }); DataStream highTempStream = splitStream.select("high"); DataStream lowTempStream = splitStream.select("low"); DataStream allTempStream = splitStream.select("high", "low");
DataStream,DataStream → ConnectedStreams
连接两个保持他们类型的数据流,两个数据流被 Connect 之后,只是被放在了一个同一个流中,内部依然保持
各自的数据和形式不发生任何变化,两个流相互独立。
CoMap,CoFlatMap
ConnectedStreams → DataStream:
作用于 ConnectedStreams 上,功能与 map和 flatMap 一样,对 ConnectedStreams 中的每一个 Stream 分
别进行 map 和 flatMap处理。
// 合流 connect DataStream> warningStream = highTempStream.map(new MapFunction >() { @Override public Tuple2 map(SensorReading value) throws Exception { return new Tuple2<>(value.getId(), value.getTemperature()); } }); ConnectedStreams , SensorReading> connectedStreams = warningStream.connect(lowTempStream); DataStream
DataStream → DataStream
对两个或者两个以上的 DataStream 进行 union 操作,产生一个包含所有 DataStream 元素的新
DataStream。
DataStreamunionStream = highTempStream.union(lowTempStream);
Connect 与 Union 区别:
1)Union 之前两个流的类型必须是一样,Connect 可以不一样,在之后的 coMap 中再去调整成为一样的。
2)Connect 只能操作两个流,Union 可以操作多个。
Flink 流应用程序处理的是以数据对象表示的事件流。所以在 Flink 内部,我们需要能够处理这些对象。它们
需要被序列化和反序列化,以便通过网络传送它们; 或者从状态后端、检查点和保存点读取它们。为了有效地做
到这一点,Flink 需要明确知道应用程序所处理的数据类型。Flink 使用类型信息的概念来表示数据类型,并为每个
数据类型生成特定的序列化器、反序列化器和比较器。
Flink 还具有一个类型提取系统,该系统分析函数的输入和返回类型,以自动获取类型信息,从而获得序列化
器和反序列化器。但是,在某些情况下,例如 lambda函数或泛型类型,需要显式地提供类型信息,才能使应用程
序正常工作或提高其性能。
Flink 支持 Java 和 Scala 中所有常见数据类型。使用最广泛的类型有以下几种。
Flink 支持所有的 Java 和 Scala 基础数据类型,Int, Double, Long, String, …
DataStreamnumberStream = env.fromElements(1, 2, 3, 4); numberStream.map(data -> data 2);
DataStream> personStream = env.fromElements( new Tuple2("Adam", 17), new Tuple2("Sarah", 23) ); personStream.filter(p -> p.f1 > 18);
不懂Scala语法可略过该节内容
case class Person(name: String, age: Int) val persons: DataStream[Person] = env.fromElements( Person("Adam", 17), Person("Sarah", 23) ) persons.filter(p => p.age > 18)
public class Person { public String name; public int age; public Person() {} public Person(String name, int age) { this.name = name; this.age = age; } } DataStreampersons = env.fromElements( new Person("Alex", 42), new Person("Wendy", 23));
Flink 对 Java 和 Scala 中的一些特殊目的的类型也都是支持的,比如 Java 的 ArrayList,HashMap,Enum 等等。
Flink 暴露了所有 udf 函数的接口(实现方式为接口或者抽象类)。例如MapFunction,FilterFunction,
ProcessFunction 等等。
例1:实现了 FilterFunction 接口:
DataStreamflinkTweets = tweets.filter(new FlinkFilter()); public static class FlinkFilter implements FilterFunction { @Override public boolean filter(String value) throws Exception { return value.contains("flink"); } }
例2:实现成匿名类函数
DataStreamflinkTweets = tweets.filter(new FilterFunction () { @Override public boolean filter(String value) throws Exception { return value.contains("flink"); } });
例3:参数传递
DataStreamtweets = env.readTextFile("INPUT_FILE "); DataStream flinkTweets = tweets.filter(new KeyWordFilter("flink")); public static class KeyWordFilter implements FilterFunction { private String keyWord; KeyWordFilter(String keyWord) { this.keyWord = keyWord; } @Override public boolean filter(String value) throws Exception { return value.contains(this.keyWord); } }
DataStreamtweets = env.readTextFile("INPUT_FILE"); DataStream flinkTweets = tweets.filter( tweet -> tweet.contains("flink") );
“富函数”是 DataStream API 提供的一个函数类的接口,所有 Flink 函数类都有其 Rich 版本。它与常规函数的不
同在于,可以获取运行环境的上下文,并拥有一些生命周期方法,所以可以实现更复杂的功能。
⚫ RichMapFunction
⚫ RichFlatMapFunction
⚫ RichFilterFunction
⚫ …
Rich Function 有一个生命周期的概念。典型的生命周期方法有:
⚫ open()方法是 rich function 的初始化方法,当一个算子例如 map 或者 filter被调用之前 open()会被调用。
⚫ close()方法是生命周期中的最后一个调用的方法,做一些清理工作。
⚫ getRuntimeContext()方法提供了函数的 RuntimeContext 的一些信息,例如函数执行的并行度,任务的名字,以及 state 状态 。
public static class MyMapFunction extends RichMapFunction> { @Override public Tuple2 map(SensorReading value) throws Exception { return new Tuple2<>(getRuntimeContext().getIndexOfThisSubtask(), value.getId()); } @Override public void open(Configuration parameters) throws Exception { System.out.println("my map open"); // 以下可以做一些初始化工作,例如建立一个和 HDFS 的连接 } @Override public void close() throws Exception { System.out.println("my map close"); // 以下做一些清理工作,例如断开和 HDFS 的连接 } }
Flink 没有类似于 spark 中 foreach 方法,让用户进行迭代的操作。虽有对外的输出操作都要利用 Sink 完成。最
后通过类似如下方式完成整个任务最终输出操作。
stream.addSink(new MySink(xxxx))
官方提供了一部分的框架的 sink。除此以外,需要用户自定义实现 sink。
1)pom.xml
org.apache.flink flink-connector-kafka-0.11_2.12 1.10.1
2)主函数中添加 sink:
dataStream.addSink(new FlinkKafkaProducer011[String]("localhost:9092", "test", new SimpleStringSchema()))
1)pom.xml
org.apache.bahir flink-connector-redis_2.11 1.0
2)定义一个 redis 的 mapper 类,用于定义保存到 redis 时调用的命令
public static class MyRedisMapper implements RedisMapper{ // 保存到 redis 的命令,存成哈希表 public RedisCommandDescription getCommandDescription() { return new RedisCommandDescription(RedisCommand.HSET, "sensor_tempe"); } public String getKeyFromData(SensorReading data) { return data.getId(); } public String getValueFromData(SensorReading data) { return data.getTemperature().toString(); } }
3)在主函数中调用:
FlinkJedisPoolConfig config = new FlinkJedisPoolConfig.Builder() .setHost("localhost") .setPort(6379) .build(); dataStream.addSink( new RedisSink(config, new MyRedisMapper()) );
1)pom.xml
org.apache.flink flink-connector-elasticsearch6_2.12 1.10.1
2)在主函数中调用
// es 的 httpHosts 配置 ArrayListhttpHosts = new ArrayList<>(); httpHosts.add(new HttpHost("localhost", 9200)); dataStream.addSink( new ElasticsearchSink.Builder (httpHosts, new MyEsSinkFunction()).build());
3)ElasitcsearchSinkFunction 的实现
public static class MyEsSinkFunction implements ElasticsearchSinkFunction{ @Override public void process(SensorReading element, RuntimeContext ctx, RequestIndexer indexer) { HashMap dataSource = new HashMap<>(); dataSource.put("id", element.getId()); dataSource.put("ts", element.getTimestamp().toString()); dataSource.put("temp", element.getTemperature().toString()); IndexRequest indexRequest = Requests.indexRequest() .index("sensor") .type("readingData") .source(dataSource); indexer.add(indexRequest); } }
1)pom.xml
mysql mysql-connector-java 5.1.44
2)添加 MyJdbcSink
public static class MyJdbcSink extends RichSinkFunction{ Connection conn = null; PreparedStatement insertStmt = null; PreparedStatement updateStmt = null; // open 主要是创建连接 @Override public void open(Configuration parameters) throws Exception { conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456"); // 创建预编译器,有占位符,可传入参数 insertStmt = conn.prepareStatement("INSERT INTO sensor_temp (id, temp) VALUES (?, ?)"); updateStmt = conn.prepareStatement("UPDATE sensor_temp SET temp = ? WHERE id = ?"); } // 调用连接,执行 sql @Override public void invoke(SensorReading value, Context context) throws Exception { // 执行更新语句,注意不要留 super updateStmt.setDouble(1, value.getTemperature()); updateStmt.setString(2, value.getId()); updateStmt.execute(); // 如果刚才 update 语句没有更新,那么插入 if (updateStmt.getUpdateCount() == 0) { insertStmt.setString(1, value.getId()); insertStmt.setDouble(2, value.getTemperature()); insertStmt.execute(); } } @Override public void close() throws Exception { insertStmt.close(); updateStmt.close(); conn.close(); } }
3)在 main 方法中增加,把明细保存到 mysql 中
dataStream.addSink(new MyJdbcSink())