【04】Flink 之 DataStream API（二）：Transformations 操作

1、DataStream API Transformations 操作

Transformations 常见API：

• map：输入一个元素，然后返回一个元素，中间可以做一些清洗转换等操作
• flatmap：输入一个元素，可以返回零个，一个或者多个元素
• filter：过滤函数，对传入的数据进行判断，符合条件的数据会被留下
• keyBy：根据指定的key进行分组，相同key的数据会进入同一个分区
• Union：合并多个流，新的流会包含所有流中的数据，但是union是一个限制，就是所有合并的流类型必须是一致的。
• Connect：和union类似，但是只能连接两个流，两个流的数据类型可以不同，会对两个流中的数据应用不同的处理方法
• Split：根据规则把一个数据流切分为多个流，
• Select：和 Split 配合使用，选择切分后的流
• reduce：对数据进行聚合操作，结合当前元素和上一次reduce返回的值- 进行聚合操作，然后返回一个新的值
• aggregations：sum(),min(),max()等

2、map()、flatmap()

同Spark中的操作

3、filter()

3.1、Java代码实现filter()

package com.Streaming.StreamAPI;

import com.Streaming.custormSource.MyNoParalleSource;
import org.apache.flink.api.common.functions.FilterFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.time.Time;

/**
 * @Author: Henry
 * @Description: Filter演示
 * @Date: Create in 2019/5/12 13:57
 **/
public class StreamingDemoFilter {

    public static void main(String[] args) throws Exception {
        //获取Flink的运行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        //获取数据源
        DataStreamSource text = env.addSource(new MyNoParalleSource()).setParallelism(1);//注意：针对此source，并行度只能设置为1

        DataStream num = text.map(new MapFunction() {
            @Override
            public Long map(Long value) throws Exception {
                System.out.println("原始接收到数据：" + value);
                return value;
            }
        });

        //执行filter过滤，满足条件的数据会被留下
        DataStream filterData = num.filter(new FilterFunction() {
            //把所有的奇数过滤掉
            @Override
            public boolean filter(Long value) throws Exception {
                return value % 2 == 0;
            }
        });

        DataStream resultData = filterData.map(new MapFunction() {
            @Override
            public Long map(Long value) throws Exception {
                System.out.println("过滤之后的数据：" + value);
                return value;
            }
        });


        //每2秒钟处理一次数据
        DataStream sum = resultData.timeWindowAll(Time.seconds(2)).sum(0);

        //打印结果
        sum.print().setParallelism(1);

        String jobName = StreamingDemoFilter.class.getSimpleName();
        env.execute(jobName);
    }
}

3.2、运行结果

将满足条件的数据进行保留

3.3、Scala代码实现filter()

package cn.Streaming.StreamAPI

import cn.Streaming.custormSource.MyNoParallelSourceScala
import org.apache.flink.streaming.api.scala.StreamExecutionEnvironment
import org.apache.flink.streaming.api.windowing.time.Time

/**
  * @Author: Henry
  * @Description: 过滤偶数并求和
  * @Date: Create in 2019/5/14 22:03 
  **/
object StreamingDemoFilter {

  def main(args: Array[String]): Unit = {

    val env = StreamExecutionEnvironment.getExecutionEnvironment

    //隐式转换
    import org.apache.flink.api.scala._

    val text = env.addSource(new MyNoParallelSourceScala)

    val mapData = text.map(line=>{
      println("原始接收到的数据："+line)
      line
    }).filter(_ % 2 == 0)

    val sum = mapData.map(line=>{
      println("过滤之后的数据："+line)
      line
    }).timeWindowAll(Time.seconds(2)).sum(0)


    sum.print().setParallelism(1)

    env.execute("StreamingDemoWithMyNoParallelSourceScala")
  }
}

3.4、运行结果

4、keyBy()

4.1、keyBy()典型用法

keyBy()中的数据类型要不是tuple，要不是自定义类型，如Long就不可以进行
keyBy操作
两种典型用法：

1. dataStream.keyBy(“someKey”) // 指定对象中的 "someKey"字段作为分组key
2. dataStream.keyBy(0) // 指定Tuple中的第一个元素作为分组key

注意：以下类型是无法作为key的

1. 一个实体类对象，没有重写hashCode方法，并且依赖object的hashCode方法
2. 一个任意形式的数组类型
3. 基本数据类型，int，long

4.2、keyBy()实现代码

同SocketWordCount代码中使用部分：

        // 3.2、将输入的文本分为不相交的分区，每个分区包含的都是具有相同key的元素。
        // 也就是说，相同的单词被分在了同一个区域，下一步的reduce就是统计分区中的个数
        .keyBy("word")

4.3、运行结果

同SocketWordCount

5、Union

5.1、Union使用

合并多个数据流（可以大于2个流），新的流会包含所有流中的数据，但是union是一个限制，
就是所有合并的流类型必须是一致的。

DATAStreamSource text1 = env.addsource(...)
DATAStreamSource text2 = env.addsource(...)
// 把text1和text2组装到一起
DATAStreamSource text = text1.union(text2)

5.2、Java实现代码Union

package com.Streaming.StreamAPI;

import com.Streaming.custormSource.MyNoParalleSource;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.time.Time;
/**
 * @Author: Henry
 * @Description: 合并多个流，新的流会包含所有流中的数据，
 *               但是union是一个限制，就是所有合并的流类型必须是一致的
 * @Date: Create in 2019/5/12 13:58
 **/
public class StreamingDemoUnion {

    public static void main(String[] args) throws Exception {
        //获取Flink的运行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        //获取数据源
        DataStreamSource text1 = env.addSource(new MyNoParalleSource()).setParallelism(1);//注意：针对此source，并行度只能设置为1

        DataStreamSource text2 = env.addSource(new MyNoParalleSource()).setParallelism(1);

        //把text1和text2组装到一起
        DataStream text = text1.union(text2);

        DataStream num = text.map(new MapFunction() {
            @Override
            public Long map(Long value) throws Exception {
                System.out.println("原始接收到数据：" + value);
                return value;
            }
        });

        //每2秒钟处理一次数据
        DataStream sum = num.timeWindowAll(Time.seconds(2))
                .sum(0);

        //打印结果
        sum.print().setParallelism(1);

        String jobName = StreamingDemoUnion.class.getSimpleName();
        env.execute(jobName);
    }
}

5.3、运行结果

5.4、Scala实现代码Union

package cn.Streaming.StreamAPI

import cn.Streaming.custormSource.MyNoParallelSourceScala
import org.apache.flink.streaming.api.scala.StreamExecutionEnvironment
import org.apache.flink.streaming.api.windowing.time.Time

/**
  * @Author: Henry
  * @Description:
  * @Date: Create in 2019/5/14 22:09 
  **/
object StreamingDemoUnionScala {

  def main(args: Array[String]): Unit = {

    val env = StreamExecutionEnvironment.getExecutionEnvironment

    //隐式转换
    import org.apache.flink.api.scala._

    val text1 = env.addSource(new MyNoParallelSourceScala)
    val text2 = env.addSource(new MyNoParallelSourceScala)

    val unionall = text1.union(text2)

    val sum = unionall.map(line=>{
      println("接收到的数据："+line)
      line
    }).timeWindowAll(Time.seconds(2)).sum(0)

    sum.print().setParallelism(1)

    env.execute("StreamingDemoWithMyNoParallelSourceScala")
  }
}

5.5、运行结果

6、Connect

6.1、Connect使用

Connect和union类似，但是只能连接两个流，两个流的数据类型可以不同，
会对两个流中的数据应用不同的处理方法。
CoMap, CoFlatMap：在ConnectedStreams中需要使用这种函数，类似于map和flatmap。

6.2、Java代码实现Connect

package com.Streaming.StreamAPI;

import com.Streaming.custormSource.MyNoParalleSource;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.streaming.api.datastream.ConnectedStreams;
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.co.CoMapFunction;
import org.apache.flink.streaming.api.windowing.time.Time;

/**
 * @Author: Henry
 * @Description:  connect和union类似，但是只能连接两个流，
 *                两个流的数据类型可以不同，会对两个流中的数据应用不同的处理方法
 *
 * @Date: Create in 2019/5/12 13:58
 **/
public class StreamingDemoConnect {

    public static void main(String[] args) throws Exception {
        //获取Flink的运行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        //获取数据源
        DataStreamSource text1 = env.addSource(new MyNoParalleSource()).setParallelism(1);

        DataStreamSource text2 = env.addSource(new MyNoParalleSource()).setParallelism(1);
        SingleOutputStreamOperator text2_str = text2.map(new MapFunction() {
            @Override
            public String map(Long value) throws Exception {
                return "str_" + value;
            }
        });

        ConnectedStreams connectStream = text1.connect(text2_str);

        SingleOutputStreamOperator