Flink开发步骤、核心技术原理及窗口机制

概述

和其他所有的计算框架一样，Flink 也有一些基础的开发步骤以及基础，核心的API，从开发步骤的角度来讲，主要分为四大部分

1、Evironment

Flink Job 在提交执行计算时，需要首先建立和 Flink 框架之间的联系，也就指的是当前的 Flink 运行环境，只有获取了环境信息，才能将 task 调度到不同的 taskManager 执行。而这个环境对象的获取方式相对比较简单

// 创建批处理环境
val env = ExecutionEnvironment.getExecutionEnvironment
// 创建流式数据处理环境
val env = StreamExecutionEnvironment.getExecutionEnvironment

2、Source

Flink 框架可以从不同的来源获取数据，将数据提交给框架进行处理，我们将获取数据的来源称之为数据源

2.1、从集合读取数据

一般情况下，可以将数据临时存储到内存中，形成特殊的数据结构后，作为数据源使用。这里的数据结构采用集合类型是比较普遍的

import org.apache.flink.streaming.api.scala._

object SourceList {
    
    
/**
   * 定义样例类：水位传感器：用于接收空高数据
   * @param id 传感器编号
   * @param ts 时间戳
   * @param vc 空高
   */
  case class WaterSensor(id: String, ts: Long, vc: Double)
  def main(args: Array[String]): Unit = {
    
    
    // 1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    // 2.从集合中读取数据
    val sensorDS: DataStream[WaterSensor] = env.fromCollection(
      List(
        WaterSensor("001", 1577844001, 45.0),
        WaterSensor("002", 1577844015, 43.0),
        WaterSensor("003", 1577844020, 42.0)
      )
    )
    // 3.打印
    sensorDS.print()
    // 4.执行
    env.execute()
  }
}

注意：自动导包是这个包import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}，执行时会报以下错误，需要手动修改为import org.apache.flink.streaming.api.scala._

执行成功结果如下：

2.2、从本地文件中读取数据

通常情况下，我们会从存储介质中获取数据，比较常见的就是将日志文件作为数据源

import org.apache.flink.streaming.api.scala.{
    
    DataStream, StreamExecutionEnvironment}

object SourceFile {
    
    
  def main(args: Array[String]): Unit = {
    
    
    // 1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    // 2.从指定路径获取数据
    val fileDS: DataStream[String] = env.readTextFile("in/data.log")
    // 3.打印结果
    fileDS.print()
    // 4.执行
    env.execute()
  }
}

此处导入org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}包虽然不会执行报错，还是建议修改为import org.apache.flink.streaming.api.scala._
文件内容如下：

执行成功结果如下：

2.3、从HDFS文件中读取数据

如果是 standalone 集群环境，默认为集群节点根目录，当然除了相对路径以外，也可以将路径设置为分布式文件系统路径，如HDFS

import org.apache.flink.streaming.api.scala.{
    
    DataStream, StreamExecutionEnvironment}

object SourceFile {
    
    
  def main(args: Array[String]): Unit = {
    
    
    // 1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    // 2.从HDFS获取数据
   	val fileDS: DataStream[String] =
      env.readTextFile( "hdfs://hadoop:9000/test/1.txt")
    // 3.打印结果
    fileDS.print()
    // 4.执行
    env.execute()
  }
}

默认读取时，Flink 的依赖关系中是不包含 Hadoop 依赖关系的，所以执行以下代码时会报以下错误

解决方法就是增加以下相关依赖项

<dependency>
      <groupId>org.apache.flink</groupId>
      <artifactId>flink-hadoop-compatibility_2.11</artifactId>
      <version>1.7.2</version>
    </dependency>
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-client</artifactId>
      <version>2.6.0</version>
    </dependency>

执行成功结果如下：

2.4、从Kafka获取数据

Kafka作为消息传输队列，是一个分布式的，高吞吐量，易于扩展地基于主题发布/订阅的消息系统。在现今企业级开发中，Kafka 和 Flink 成为构建一个实时的数据处理系统的首选

import java.util.Properties
import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer
import org.apache.kafka.clients.consumer.ConsumerConfig

object SourceKafka {
    
    
  def main(args: Array[String]): Unit = {
    
    
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    val prop = new Properties()
    prop.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.8.99:9092")
    prop.setProperty(ConsumerConfig.GROUP_ID_CONFIG,"flink-kafka-demo")
    prop.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer")
    prop.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer")
    prop.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"latest")

    val kafkaDS: DataStream[String] = env.addSource(
      new FlinkKafkaConsumer[String](
        "sensor",
        new SimpleStringSchema(),
        prop
      )
    )
    kafkaDS.print()
    env.execute()
  }
}

注意：自动导包是这个包import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}，执行时会报以下错误，需要手动修改为import org.apache.flink.streaming.api.scala._

执行成功结果如下：在控制台输入，结果会自动实时输出到 IDEA

注意：获取 Kafka 数据时需要添加以下依赖

	<dependency>
      <groupId>org.apache.flink</groupId>
      <artifactId>flink-connector-kafka_2.11</artifactId>
      <version>1.7.2</version>
    </dependency>

2.5、自定义数据源

大多数情况下，前面的数据源已经能够满足需要，但是难免会存在特殊情况的场合，所以 Flink 也提供了能自定义数据源的方式

import java.util.Random
import org.apache.flink.streaming.api.functions.source.SourceFunction
import org.apache.flink.streaming.api.scala.{
    
    DataStream, StreamExecutionEnvironment}
import org.apache.flink.streaming.api.scala._

case class WaterSensor(id:String,ts:Long,vc:Double)

object SourceMy {
    
    
  def main(args: Array[String]): Unit = {
    
    
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    val mydefDStream: DataStream[WaterSensor] = env.addSource(new MySensorSource())

    mydefDStream.print()
    env.execute("mydefsource")
  }
}

class MySensorSource extends SourceFunction[WaterSensor] {
    
    
  var flag = true
  override def run(ctx: SourceFunction.SourceContext[WaterSensor]): Unit = {
    
    
    while ( flag ) {
    
    
      // 采集数据
      ctx.collect(
        WaterSensor(
          "sensor_" +new Random().nextInt(3),
          1577844001,
          new Random().nextInt(5)+40
        )
      )
      Thread.sleep(3000)// 3秒获取一次
    }
  }

  override def cancel(): Unit = {
    
    
    flag = false;
  }
}

注意：自动导包是这个包import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}，执行时会报以下错误，需要手动修改为import org.apache.flink.streaming.api.scala._

执行结果如下：

3、Transform

在Spark中，算子分为转换算子和行动算子，转换算子的作用可以通过算子方法的调用将一个RDD转换另外一个RDD，Flink中也存在同样的操作，可以将一个数据流转换为其他的数据流。

转换过程中，数据流的类型也会发生变化，那么到底 Flink 支持什么样的数据类型呢，其实我们常用的数据类型，Flink 都是支持的。比如：Long，String，Integer，Int，List，Map，元组，样例类等

3.1、map

映射：将数据流中的数据进行转换，形成新的数据流，消费一个元素并产出一个元素
参数：Scala 匿名函数或 MapFunction
返回：DataStream

import org.apache.flink.streaming.api.scala._

object Transform_Map {
    
    
  def main(args: Array[String]): Unit = {
    
    
    //1.创建执行的环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    val sensorDS: DataStream[WaterSensor] = env.fromCollection(
      List(
        WaterSensor("sensor_0", 1577844001, 43.0),
        WaterSensor("sensor_1", 1577844001, 44.0),
        WaterSensor("sensor_2", 1577844001, 45.0)
      )
    )
    val mapDStream: DataStream[(String, Long, Double)] = sensorDS.map(x=>(x.id+"_bak",x.ts+1,x.vc+1))
    mapDStream.print()
    env.execute()
  }
  
  /**
    * 定义样例类：水位传感器：用于接收空高数据
    *
    * @param id 传感器编号
    * @param ts 时间戳
    * @param vc 空高
    */
  case class WaterSensor(id: String, ts: Long, vc: Double)
}

执行结果如下：

3.1.1、MapFunction

Flink 为每一个算子的参数都至少提供了 Scala 匿名函数和函数类两种的方式，其中如果使用函数类作为参数的话，需要让自定义函数继承指定的父类或实现特定的接口。例如：MapFunction

import org.apache.flink.streaming.api.scala._

object SourceFileMap {
    
    
  def main(args: Array[String]): Unit = {
    
    
    //1.创建执行的环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //2.从指定路径获取数据
    val fileDS: DataStream[String] = env.readTextFile("in/data.log")
    val MapDS = fileDS.map(
      lines => {
    
    
        //更加逗号切割 获取每个元素
        val datas: Array[String] = lines.split(",")
        WaterSensor(datas(0), datas(1).toLong, datas(2).toInt)
      }
    )
    MapDS.print()
    env.execute()
  }

  /**
   * 定义样例类：水位传感器：用于接收空高数据
   * @param id 传感器编号
   * @param ts 时间戳
   * @param vc 空高
   */
  case class WaterSensor(id: String, ts: Long, vc: Double)
}

文件数据内容如下：

sensor_1,1549044122,10
sensor_1,1549044123,20
sensor_1,1549044124,30
sensor_2,1549044125,40
sensor_1,1549044126,50
sensor_2,1549044127,60
sensor_1,1549044128,70
sensor_3,1549044129,80
sensor_3,1549044130,90
sensor_3,1549044130,100

执行结果如下：

3.1.2、RichMapFunction

所有 Flink 函数类都有其 Rich 版本。它与常规函数的不同在于，可以获取运行环境的上下文，并拥有一些生命周期方法，所以可以实现更复杂的功能。也有意味着提供了更多的，更丰富的功能。例如：RichMapFunction

import org.apache.flink.api.common.functions.RichMapFunction
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.scala._

object Transform_RichMapFunction {
    
    
  def main(args: Array[String]): Unit = {
    
    
    //1.创建执行的环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //2.从指定路径获取数据
    val sensorDS: DataStream[String] = env.readTextFile("in/data.log")
    val myMapDS: DataStream[WaterSensor] = sensorDS.map(new MyRichMapFunction)
    //3.打印
    myMapDS.print()
    //4.执行
    env.execute("map")
  }

  /**
    * 自定义继承 MapFunction
    * MapFunction[T,O]
    * 自定义输入和输出
    */
  class MyRichMapFunction extends RichMapFunction[String, WaterSensor] {
    
    
    override def map(value: String): WaterSensor = {
    
    
      val datas: Array[String] = value.split(",")
      //      WaterSensor(datas(0), datas(1).toLong, datas(2).toInt)
      WaterSensor(getRuntimeContext.getTaskName, datas(1).toLong, datas(2).toInt)
    }
    // 富函数提供了生命周期方法
    override def open(parameters: Configuration): Unit = {
    
    }
    override def close(): Unit = {
    
    }
  }
  /**
    * 定义样例类：水位传感器：用于接收空高数据
    * @param id 传感器编号
    * @param ts 时间戳
    * @param vc 空高
    */
  case class WaterSensor(id: String, ts: Long, vc: Double)
}

Rich Function 有一个生命周期的概念。典型的生命周期方法有：

• open() 方法是 rich function 的初始化方法，当一个算子例如 map 或者 filter 被调用之前 open() 会被调用
• close() 方法是生命周期中的最后一个调用的方法，做一些清理工作
• getRuntimeContext() 方法提供了函数的 RuntimeContext 的一些信息，例如函数执行的并行度，任务的名字，以及 state 状态

3.1.3、flatMap

• 扁平映射：将数据流中的整体拆分成一个一个的个体使用，消费一个元素并产生零到多个元素
• 参数：Scala 匿名函数或 FlatMapFunction
• 返回：DataStream

import org.apache.flink.streaming.api.scala._

object Transform_FlatMap {
    
    
  def main(args: Array[String]): Unit = {
    
    
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    val listDS: DataStream[List[Int]] = env.fromCollection(
      List(
        List(1,  3, 4),
        List(5, 6, 7, 1)
      ))
    val resultDS: DataStream[Int] = listDS.flatMap(list => list)
    resultDS.print()
    env.execute()
  }
}

执行结果如下：

3.2、filter

• 过滤：根据指定的规则将满足条件（true）的数据保留，不满足条件(false)的数据丢弃
• 参数：Scala 匿名函数或 FilterFunction
• 返回：DataStream

import org.apache.flink.streaming.api.scala._

object Transform_Filter {
    
    
  def main(args: Array[String]): Unit = {
    
    
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val listDS: DataStream[List[Int]] = env.fromCollection(
      List(
        List(1, 2, 3, 4,1, 2, 3, 4),
        List(5, 6, 7,1,1,1,1, 2, 3, 4,1, 2, 3, 4),
        List(1, 2, 3, 4),
        List(5, 6, 7,1,1,1),
        List(1, 2, 3, 4)
      ))
    // true就留下，false就抛弃
    listDS.filter(num => {
    
    
      num.size>5
    }).print("filter")
    
    env.execute()
  }
}

执行结果如下：

3.3、keyBy

在 Spark 中有一个 GroupBy 的算子，用于根据指定的规则将数据进行分组，在 Flink 中也有类似的功能，那就是 keyBy，根据指定的 key 对数据进行分流

• 分流：根据指定的 Key 将元素发送到不同的分区，相同的Key会被分到一个分区（这里分区指的就是下游算子多个并行节点的其中一个）。keyBy() 是通过哈希来分区的
• 参数：Scala匿名函数或POJO属性或元组索引，不能使用数组
• 返回：KeyedStream

import org.apache.flink.streaming.api.scala._

object Transform_KeyBy {
    
    
  def main(args: Array[String]): Unit = {
    
    
    // 1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    // 2.读取数据
    val sensorDS: DataStream[String] = env.readTextFile("in/data.log")
    //3.转换为样例类
    val mapDS: DataStream[WaterSensor] = sensorDS.map(
      lines => {
    
    
        val datas = lines.split(",")
        WaterSensor(datas(0), datas(1).toLong, datas(2).toInt)
      })

    val sensorKS: KeyedStream[WaterSensor, String] = mapDS.keyBy(_.id)
    sensorKS.print().setParallelism(5)
    // 4. 执行
    env.execute()
  }

  /**
    * 定义样例类：水位传感器：用于接收空高数据
    * @param id 传感器编号
    * @param ts 时间戳
    * @param vc 空高
    */
  case class WaterSensor(id: String, ts: Long, vc: Double)
}

执行结果如下：

3.4、shuffle

• 打乱重组（洗牌）：将数据按照均匀分布打散到下游
• 参数：无
• 返回：DataStream

import org.apache.flink.streaming.api.scala._

object Transform_Shuffle {
    
    
  def main(args: Array[String]): Unit = {
    
    
    // 1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    // 2.读取数据
    val sensorDS: DataStream[String] = env.readTextFile("in/data.log")
    val shuffleDS = sensorDS.shuffle
    sensorDS.print("data")
    shuffleDS.print("shuffle")
    // 4. 执行
    env.execute()
  }
}

执行结果如下：

3.5、split

在某些情况下，我们需要将数据流根据某些特征拆分成两个或者多个数据流，给不同数据流增加标记以便于从流中取出。

需求：将水位传感器数据按照空高高低（以40cm，30cm为界），拆分成三个流

import org.apache.flink.streaming.api.scala._

object Transform_Split {
    
    
  def main(args: Array[String]): Unit = {
    
    
    // 1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    // 2.读取数据
    val sensorDS: DataStream[String] = env.readTextFile("in/data.log")
    // 3.转换成样例类
    val mapDS: DataStream[WaterSensor] = sensorDS.map(
      lines => {
    
    
        val datas: Array[String] = lines.split(",")
        WaterSensor(datas(0), datas(1).toLong, datas(2).toInt)
      })
    val splitDS: SplitStream[WaterSensor] = mapDS.split(
      sensor => {
    
    
        if (sensor.vc < 40) {
    
    
          Seq("info")
        } else if (sensor.vc < 80) {
    
    
          Seq("warn")
        } else {
    
    
          Seq("error")
        }
      })

    // 4. 执行
    env.execute()
  }
  /**
    * 定义样例类：水位传感器：用于接收空高数据
    * @param id 传感器编号
    * @param ts 时间戳
    * @param vc 空高
    */
  case class WaterSensor(id: String, ts: Long, vc: Double)
}

3.6、select

将数据流进行切分后，如何从流中将不同的标记取出呢，这时就需要使用 select 算子了

import org.apache.flink.streaming.api.scala._

object Transform_Split {
    
    
  def main(args: Array[String]): Unit = {
    
    
    // 1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    // 2.读取数据
    val sensorDS: DataStream[String] = env.readTextFile("in/data.log")
    // 3.转换成样例类
    val mapDS: DataStream[WaterSensor] = sensorDS.map(
      lines => {
    
    
        val datas: Array[String] = lines.split(",")
        WaterSensor(datas(0), datas(1).toLong, datas(2).toInt)
      })
    val splitDS: SplitStream[WaterSensor] = mapDS.split(
      sensor => {
    
    
        if (sensor.vc < 40) {
    
    
          Seq("info")
        } else if (sensor.vc < 80) {
    
    
          Seq("warn")
        } else {
    
    
          Seq("error")
        }
      })
    // 4.取不同数据流中的数据
    val errorDS: DataStream[WaterSensor] = splitDS.select("error")
    val warnDS: DataStream[WaterSensor] = splitDS.select("warn")
    val infoDS: DataStream[WaterSensor] = splitDS.select("info")
    
    infoDS.print("info")
    warnDS.print("warn")
    errorDS.print("error")
    // 5. 执行
    env.execute()
  }
  /**
    * 定义样例类：水位传感器：用于接收空高数据
    * @param id 传感器编号
    * @param ts 时间戳
    * @param vc 空高
    */
  case class WaterSensor(id: String, ts: Long, vc: Double)
}

执行结果如下：

3.7、connect

在某些情况下，我们需要将两个不同来源的数据流进行连接，实现数据匹配，比如订单支付和第三方交易信息，这两个信息的数据就来自于不同数据源，连接后，将订单支付和第三方交易信息进行对账，此时，才能算真正的支付完成

Flink 中的 connect 算子可以连接两个保持他们类型的数据流，两个数据流被 Connect 之后，只是被放在了一个同一个流中，内部依然保持各自的数据和形式不发生任何变化，两个流相互独立

import org.apache.flink.streaming.api.scala._

object Transform_Connect {
    
    
  def main(args: Array[String]): Unit = {
    
    
    // 1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    // 2.读取数据
    val sensorDS: DataStream[String] = env.readTextFile("in/data.log")
    // 3.转换成样例类
    val mapDS: DataStream[WaterSensor] = sensorDS.map(
      lines => {
    
    
        val datas: Array[String] = lines.split(",")
        WaterSensor(datas(0), datas(1).toLong, datas(2).toInt)
      })
    // 4. 从集合中再读取一条流
    val numDS: DataStream[Int] = env.fromCollection(List(1, 2, 3, 4, 5, 6))
    val resultCS: ConnectedStreams[WaterSensor, Int] = mapDS.connect(numDS)

    resultCS.map(
      sensor=>sensor.id,
      num=>num+1
    ).print()

    // 4. 执行
    env.execute()
  }
  /**
    * 定义样例类：水位传感器：用于接收空高数据
    * @param id 传感器编号
    * @param ts 时间戳
    * @param vc 空高
    */
  case class WaterSensor(id: String, ts: Long, vc: Double)
}

执行结果如下：

3.8、union

对两个或者两个以上的 DataStream 进行 union 操作，产生一个包含所有 DataStream 元素的新 DataStream

connect与 union 区别：

• union 之前两个流的类型必须是一样，connect 可以不一样
• connect 只能操作两个流，union 可以操作多个

import org.apache.flink.streaming.api.scala._

object Transform_Union {
    
    
  def main(args: Array[String]): Unit = {
    
    
    // 1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    // 2. 从集合中读取流
    val num1DS: DataStream[Int] = env.fromCollection(List(1, 2, 3, 4))
    val num2DS: DataStream[Int] = env.fromCollection(List(7, 8, 9, 10))
    val num3DS: DataStream[Int] = env.fromCollection(List(17, 18, 19, 110))

    num1DS.union(num2DS).union(num3DS).print()
    // 4. 执行
    env.execute()
  }
}

合并的流，类型必须一致
可以合并多条流，只要类型一致

执行结果如下：

3.9、Operator

Flink 作为计算框架，主要应用于数据计算处理上， 所以在 keyBy 对数据进行分流后，可以对数据进行相应的统计分析

3.9.1、滚动聚合算子（Rolling Aggregation）

这些算子可以针对KeyedStream的每一个支流做聚合。执行完成后，会将聚合的结果合成一个流返回，所以结果都是 DataStream

sum()：求和

min()：求最小值

max()：求最大值

3.9.2、reduce

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

import org.apache.flink.streaming.api.scala._

object Transform_Reduce {
    
    
  def main(args: Array[String]): Unit = {
    
    
    // 1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    // 设置并行度
    env.setParallelism(1)
    // 2.读取数据
    val sensorDS: DataStream[String] = env.readTextFile("in/data.log")
    // 3.转换成样例类
    val mapDS: DataStream[WaterSensor] = sensorDS.map(
      lines => {
    
    
        val datas: Array[String] = lines.split(",")
        WaterSensor(datas(0), datas(1).toLong, datas(2).toInt)
      })
    val sensorKS: KeyedStream[WaterSensor, String] = mapDS.keyBy(_.id)
    // 输入的类型一样，输出类型和输出类型也要一样
    // 组内的第一条数据，不进入reduce计算
    val reduceDS: DataStream[WaterSensor] = sensorKS.reduce(
      (ws1, ws2) => {
    
    
        println(ws1 + "<===>" + ws2)
        WaterSensor(ws1.id, System.currentTimeMillis(), ws1.vc + ws2.vc)
      })
    reduceDS.print("reduce")
    env.execute()
  }
  case class WaterSensor(id: String, ts: Long, vc: Double)
}

执行结果如下：

3.9.3、process

Flink 在数据流通过 keyBy 进行分流处理后，如果想要处理过程中获取环境相关信息，可以采用 process 算子自定义实现；继承 KeyedProcessFunction 抽象类，并定义泛型：[KEY, IN, OUT]

import org.apache.flink.streaming.api.functions.KeyedProcessFunction
import org.apache.flink.streaming.api.scala
import org.apache.flink.streaming.api.scala._
import org.apache.flink.util.Collector

case class WaterSensor(id: String, ts: Long, vc: Double)
object Transform_Process {
    
    
  def main(args: Array[String]): Unit = {
    
    
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    val sensorDS: DataStream[String] = env.readTextFile("in/data.log")
    val mapDS: DataStream[WaterSensor] = sensorDS.map(
      lines => {
    
    
        val datas: Array[String] = lines.split(",")
        WaterSensor(datas(0), datas(1).toLong, datas(2).toInt)
      })
    //按照ID  进行分组
    val sensorKS: scala.KeyedStream[WaterSensor, String] = mapDS.keyBy(_.id)
    sensorKS.process(new MyKeyedProcessFunction)
    env.execute()
  }
}

class MyKeyedProcessFunction
  extends KeyedProcessFunction[String,WaterSensor,String]{
    
    
  override def processElement(i: WaterSensor, context: KeyedProcessFunction[String, WaterSensor, String]#Context, collector: Collector[String]): Unit = {
    
    
    val key: String = context.getCurrentKey
    println(key)
    collector.collect("process key:" + key + " value:" + i)
  }
}

执行结果如下：

4、Sink

Sink有下沉的意思，在 Flink 中所谓的 Sink 其实可以表示为将数据存储起来的意思，也可以将范围扩大，表示将处理完的数据发送到指定的存储系统的输出操作

之前我们一直在使用的 print 方法其实就是一种 Sink

  @PublicEvolving
    public DataStreamSink<T> print(String sinkIdentifier) {
    
    
        PrintSinkFunction<T> printFunction = new PrintSinkFunction(sinkIdentifier, false);
        return this.addSink(printFunction).name("Print to Std. Out");
    }

官方提供了一部分的框架的 sink，除此以外，需要用户自定义实现 sink

例：存入 Kafka

将 Kafka 的 sensorin Topic 中的数据存入 Kafka 的 sensorout Topic 中

import java.util.Properties
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.connectors.kafka.{
    
    FlinkKafkaConsumer, FlinkKafkaProducer}
import org.apache.flink.streaming.util.serialization.SimpleStringSchema
import org.apache.kafka.clients.consumer.ConsumerConfig

object SinkKafka {
    
    
  def main(args: Array[String]): Unit = {
    
    
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    val prop = new Properties()
    prop.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.8.99:9092")
    prop.setProperty(ConsumerConfig.GROUP_ID_CONFIG, "flink-kafka-demo")
    prop.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer")
    prop.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer")
    prop.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "latest")
    val kafkaDS: DataStream[String] = env.addSource(new FlinkKafkaConsumer[String]("sensorin", new SimpleStringSchema(), prop))
    kafkaDS.addSink(new FlinkKafkaProducer[String]("192.168.8.99:9092", "sensorout", new SimpleStringSchema()))
    kafkaDS.print()
    env.execute()
  }
}

启动后，生产 sensorin 消息即可再控制台看到输出，相应的消费 sensorout 队列也可以查看到生产的消息

执行结果：

Flink核心技术及原理 && 窗口机制

Flink 核心技术及原理详解请查看：Flink核心技术及原理
Flink 窗口机制详解请查看：Flink窗口机制