【Flink学习笔记】Flink DataStream API之Transformation算子小结

1、map算子

1）理解：通过对DataStream对象调用其map方法，对数据流中的每一个元素进行转换逻辑操作，最终返回每一个输入元素转换后的结果数据继续封装成一个DataStream对象返回（输入多少个元素，就会返回多少个元素，中间过程可以进行一系列的数据结构转换操作）

2）map算子使用入门代码示例

（1）java API代码

package com.flink.datastream.transformation;

import org.apache.flink.api.common.functions.MapFunction;
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 java.util.Arrays;

public class MapDemo {
    public static void main(String[] args) throws Exception {
        // 获取flink的运行环境对象
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        // 构建数据流对象
        DataStreamSource collectionDataStreamSource = env.fromCollection(Arrays.asList(1, 2, 3, 4));

        // 调用map算子对集合数据源中的每个元素做累加1操作
        // new MapFunction匿名内部类中泛型的第1个参数类型是数据流输入的数据类型，第2个泛型参数类型是经过map方法转换后返回的数据类型
        SingleOutputStreamOperator dataStream = collectionDataStreamSource.map(new MapFunction() {

            @Override
            public String map(Integer integer) throws Exception {
                return "map" + integer;
            }
        });

        // 打印数据流中的内容
        dataStream.print().setParallelism(1);

        env.execute("mapDemo");
    }
}

（2）Scala API代码

package com.flink.datastream_scala.transformations

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

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

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

    // 通过官方提供的API来构造数据源
    val dataStream = env.generateSequence(1,10)

    // 调用map算子执行转换操作
    val result = dataStream.map(e => "map"+e)

    // 打印数据流中的内容
    result.print().setParallelism(1)

    // 执行数据流
    env.execute("MapDemoByScala")
  }
}

---

2、flatMap算子

1）理解：通过对DataStream对象调用其flatMap方法，对每个输入元素进行压平、压扁操作，即输入一个元素，根据你的业务逻辑决定返回几个元素，可以返回0个元素或1个元素或者n个元素，其最后的结果还是会封装成一个DataStream对象返回。

2）java API代码

package com.flink.datastream.transformation;

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;

import java.util.Arrays;

/**
 * Flink DataStream API之transformations
 * flatMap算子：输入一个元素，可以返回零个、多个或者一个元素
 */
public class FlatMapDemo {
    public static void main(String[] args) throws Exception {
        // 获取flink的运行环境对象
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 构建一个集合数据源
        DataStream collectionDataStream = env.fromCollection(Arrays.asList(1, 2, 3, 4, 5));

        // 使用flatMap来过滤掉不是偶数的集合元素
        DataStream oddDataStream = collectionDataStream.flatMap(new FlatMapFunction() {
            @Override
            public void flatMap(Integer integer, Collector collector) throws Exception {
                if (integer % 2 == 0) {
                    collector.collect(integer);
                }
            }
        });

        // 打印输出到控制台
        oddDataStream.print().setParallelism(1);

        // 执行任务
        env.execute("flatMapDemo");
    }
}

3）Scala API代码

package com.flink.datastream_scala.transformations

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

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

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

    // 通过官方提供的API来构造数据源
    val dataStream = env.fromCollection(List("flink dataStream", "spark streaming", "storm bolt", "hive hql"))

    // 调用flatMap算子执行转换操作
    val result = dataStream.flatMap(_.split(" "))

    // 打印数据流中的内容
    result.print().setParallelism(1)

    // 执行数据流
    env.execute("FlatMapDemoByScala")
  }
}

---

3、filter算子

1）理解：过滤数据流中数据的函数，对传入的数据进行判断，返回true表示符合条件的数据会保留，返回false表示不符合条件的数据会被丢掉，最终返回的结果会被封装成一个DataStream对象返回。

（1）使用场景：根据你的业务来调用filter算子对执行了map算子或者flatMap算子之后的结果进行过滤掉不需要的数据。

2）java API代码

package com.flink.datastream.transformation;

import org.apache.flink.api.common.functions.FilterFunction;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

import java.util.Arrays;

/**
 * filter算子：过滤元素，返回值是一个boolean类型，返回true表示不过滤该元素，返回false表示过滤掉该元素
 */
public class FilterDemo {
    public static void main(String[] args) throws Exception {
        // 获取flink的运行环境对象
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 构建一个集合数据源
        DataStream collectionDataStream = env.fromCollection(Arrays.asList(1, 2, 3, 4, 5));

        // 使用filter算子来过滤掉不是偶数的集合元素
        SingleOutputStreamOperator oddDataStream = collectionDataStream.filter(new FilterFunction() {
            @Override
            public boolean filter(Integer element) throws Exception {
                return element % 2 == 0;
            }
        });

        // 打印输出到控制台
        oddDataStream.print().setParallelism(1);

        // 执行任务
        env.execute("filterDemo");
    }
}

3）Scala API代码

package com.flink.datastream_scala.transformations

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

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

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

    // 通过官方提供的API来构造数据源
    val dataStream = env.fromCollection(List(1,2,3,4,5,6))

    // 调用filter算子对数据流中的数据进行过滤操作
    val result = dataStream.filter( e => e % 2 == 0)

    // 打印数据流中的内容
    result.print().setParallelism(1)

    // 执行数据流
    env.execute("FilterDemoByScala")
  }
}

 

未完待续...