Flink 流处理API

在这里插入图片描述

1 Environment

1.1 getExecutionEnvironment

创建一个执行环境，表示当前执行程序的上下文。如果程序是独立调用的，则
此方法返回本地执行环境；如果从命令行客户端调用程序以提交到集群，则此方法
返回此集群的执行环境，也就是说，getExecutionEnvironment 会根据查询运行的方
式决定返回什么样的运行环境，是最常用的一种创建执行环境的方式。

val env: ExecutionEnvironment = ExecutionEnvironment.getExecutionEnvironment

val env = StreamExecutionEnvironment.getExecutionEnvironment

如果没有设置并行度，会以flink-conf.yaml 中的配置为准，默认是1。

1.2 createLocalEnvironment

返回本地执行环境，需要在调用时指定默认的并行度。

val env = StreamExecutionEnvironment.createLocalEnvironment(1)

1.3 createRemoteEnvironment

返回集群执行环境，将Jar 提交到远程服务器。需要在调用时指定JobManager
的IP 和端口号，并指定要在集群中运行的Jar 包。

val env = ExecutionEnvironment.createRemoteEnvironment("jobmanage-hostname",
6123,"YOURPATH//wordcount.jar")

2 Source

2.1 从集合读取数据

// 定义样例类，传感器id，时间戳，温度
case class SensorReading(id: String, timestamp: Long, temperature: Double)
object Sensor {
def main(args: Array[String]): Unit = {
val env = StreamExecutionEnvironment.getExecutionEnvironment
val stream1 = env
.fromCollection(List(
SensorReading("sensor_1", 1547718199, 35.8),
SensorReading("sensor_6", 1547718201, 15.4),
SensorReading("sensor_7", 1547718202, 6.7),
SensorReading("sensor_10", 1547718205, 38.1)
))
stream1.print("stream1:").setParallelism(1)
env.execute()
}
}

2.2 从文件读取数据

val stream2 = env.readTextFile("YOUR_FILE_PATH")

2.3 以kafka 消息队列的数据作为来源

 // 3. 从kafka中读取数据
    val properties = new Properties()
    properties.setProperty("bootstrap.servers", "hadoop01:9092")
    properties.setProperty("group.id", "consumer-group")
    val stream3 = env.addSource( new FlinkKafkaConsumer011[String]("sensor", new SimpleStringSchema(), properties) )

2.4 自定义Source

除了以上的source 数据来源，我们还可以自定义source。需要做的，只是传入
一个SourceFunction 就可以。具体调用如下：

val stream4 = env.addSource( new MySensorSource() )

我们希望可以随机生成传感器数据，MySensorSource 具体的代码实现如下：

class MySensorSource extends SourceFunction[SensorReading]{
// flag: 表示数据源是否还在正常运行
var running: Boolean = true
override def cancel(): Unit = {
running = false
}
override def run(ctx: SourceFunction.SourceContext[SensorReading]): Unit
= {
// 初始化一个随机数发生器
val rand = new Random()
var curTemp = 1.to(10).map(
i => ( "sensor_" + i, 65 + rand.nextGaussian() * 20 )
)
while(running){
// 更新温度值
curTemp = curTemp.map(
t => (t._1, t._2 + rand.nextGaussian() )
)
// 获取当前时间戳
val curTime = System.currentTimeMillis()
curTemp.foreach(
t => ctx.collect(SensorReading(t._1, curTime, t._2))
)
Thread.sleep(100)
}
}}

3 Transform

3.1 map

val streamMap = stream.map { x => x * 2 }

3.2 flatmap

val streamFlatMap = stream.flatMap{
x => x.split(" ")
}

3.3 filter

val streamFilter = stream.filter{
x => x == 1
}

3.4 keyBY

DataStream → KeyedStream：逻辑地将一个流拆分成不相交的分区，每个分
区包含具有相同key 的元素，在内部以hash 的形式实现的。

3.5 Rolling Aggregation

这些算子可以针对KeyedStream 的每一个支流做聚合。

sum()
min()
max()
minBy()
maxBy()

3.6 Reduce

KeyedStream → DataStream：一个分组数据流的聚合操作，合并当前的元素
和上次聚合的结果，产生一个新的值，返回的流中包含每一次聚合的结果，而不是
只返回最后一次聚合的最终结果。

val stream2 = env.readTextFile("YOUR_PATH\\sensor.txt")
.map( data => {
val dataArray = data.split(",")
SensorReading(dataArray(0).trim, dataArray(1).trim.toLong,
dataArray(2).trim.toDouble)
}).keyBy("id")
.reduce( (x, y) => SensorReading(x.id, x.timestamp + 1, y.temperature) )

3.7 Split 和Select

Split

DataStream → SplitStream：根据某些特征把一个DataStream 拆分成两个或者
多个DataStream。

Select

SplitStream→DataStream：从一个SplitStream 中获取一个或者多个
DataStream。
需求：传感器数据按照温度高低（以30 度为界），拆分成两个流

val splitStream = stream2.split(
 sensorData => {
if (sensorData.temperature > 30) Seq("high") else Seq("low")
} )
val high = splitStream.select("high")
val low = splitStream.select("low")
val all = splitStream.select("high", "low")

3.8 Connect 和CoMap

图Connect 算子

DataStream,DataStream → ConnectedStreams：连接两个保持他们类型的数
据流，两个数据流被Connect 之后，只是被放在了一个同一个流中，内部依然保持
各自的数据和形式不发生任何变化，两个流相互独立。
CoMap,CoFlatMap
图CoMap/CoFlatMap

ConnectedStreams → DataStream：作用于ConnectedStreams 上，功能与map
和flatMap 一样，对ConnectedStreams 中的每一个Stream 分别进行map 和flatMap
处理。

val warning = high.map( sensorData => (sensorData.id,
sensorData.temperature) )
val connected = warning.connect(low)
val coMap = connected.map(
warningData => (warningData._1, warningData._2, "warning"),
lowData => (lowData.id, "healthy")
)

3.9 Union

在这里插入图片描述
DataStream → DataStream：对两个或者两个以上的DataStream 进行union 操
作，产生一个包含所有DataStream 元素的新DataStream。

//合并以后打印
val unionStream: DataStream[StartUpLog] = appStoreStream.union(otherStream)
unionStream.print("union:::")

Connect 与Union 区别：

Union 之前两个流的类型必须是一样，Connect 可以不一样，在之后的coMap
中再去调整成为一样的。
Connect 只能操作两个流，Union 可以操作多个。