【零基础学flink】flink中的转换算子(transform operator)

转化算子(transform operator)将一个或多个DataStream转换为新的DataStream,如此下去可以将多个转换组合成复杂的数据流拓扑。

本节介绍了基本转换,应用这些转换的有效物理分区(partition),以及对Flink转换chain的深入介绍。

目录

  • DataStream转换
  • 物理分区
  • 任务链和资源组

DataStream转换

  • map
    DataStream→DataStream |
    读取一个元素并生成一个元素。例如,一个map函数,它将输入流的值加倍:
DataStream dataStream = //...
dataStream.map(new MapFunction() {
    @Override
    public Integer map(Integer value) throws Exception {
        return 2 * value;
    }
});
  • FlatMap
    DataStream→DataStream
    读取一个元素,并生成零个、一个或多个元素。例如:将句子分割为单词的flatmap函数:
dataStream.flatMap(new FlatMapFunction() {
    @Override
    public void flatMap(String value, Collector out)
        throws Exception {
        for(String word: value.split(" ")){
            out.collect(word);
        }
    }
});
  • Filter
    DataStream→DataStream
    将每个元素输入的filter布尔函数:仅保留filter函数返回true的那部分元素,filter返回false的元素会被过滤掉。例如:过滤掉零值的过滤器:
dataStream.filter(new FilterFunction() {
    @Override
    public boolean filter(Integer value) throws Exception {
        return value != 0;
    }
});
  • KeyBy
    DataStream→KeyedStream |

在逻辑上将流分区为互不相交的分区。具有相同key的所有记录会分配给到同一分区。在内部,keyBy()是使用hash分区实现。在flink中有多种指定键的方法
此转换返回的是KeyedStream,其中包括key-state。

dataStream.keyBy("someKey") // Key by field "someKey"
dataStream.keyBy(0) // Key by the first element of a Tuple

注意 :

  1. 它是POJO类型,但不覆盖hashCode()方法,key内部是hash分区依赖于hashCode()方法的实现。
  2. 任何类型的数组也不能成为key。
  • reduce
    KeyedStream→DataStream

注意reduce函数是将KeyedStream转换为DataStream,也就是reduce调用前必须进行分区,即得先调用keyBy()函数

在分区的数据流上调用reduce函数:将当前元素与最后一个reduce的值合并生成新值。

例如:一个求和的reduce函数:

keyedStream.reduce(new ReduceFunction() {
    @Override
    public Integer reduce(Integer value1, Integer value2)
    throws Exception {
        return value1 + value2;
    }
});
  • Fold
    KeyedStream→DataStream
    注意Fold转换必须是基于KeyedStream(比如先执行keyBy操作)。

在一个初始值上进行Fold操作:将当前值和上一次Fold产生的值进行合并产生一个新的值:

比如:将Fold函数应用于(1,2,3,4,5)时,结果为:“start-1”,“start-1-2”,“start-1-2-3”,. ..

DataStream result =
  keyedStream.fold("start", new FoldFunction() {
    @Override
    public String fold(String current, Integer value) {
        return current + "-" + value;
    }
  });
  • Aggregations(聚合)
    KeyedStream→DataStream
    min和minBy之间的差异是min返回最小值,而minBy返回该字段中具有最小值的元素(max和maxBy相同)。
keyedStream.sum(0);
keyedStream.sum("key");
keyedStream.min(0);
keyedStream.min("key");
keyedStream.max(0);
keyedStream.max("key");
keyedStream.minBy(0);
keyedStream.minBy("key");
keyedStream.maxBy(0);
keyedStream.maxBy("key");
  • Window
    KeyedStream→WindowedStream

可以在已经分区的KeyedStream上定义Windows。Windows根据某些特征(例如,在最后5秒内到达的数据)对每个key中的数据进行分组。有关窗口的完整说明,请参见windows。

dataStream.keyBy(0).window(TumblingEventTimeWindows.of(Time.seconds(5))); // Last 5 seconds of data

  • WindowAll
    DataStream→AllWindowedStream

Windows可以在常规DataStream上定义。Windows根据某些特征(例如,在最后5秒内到达的数据)对所有流事件进行分组。有关窗口的完整说明,请参见windows。

警告:在许多情况下,这是非并行转换。对于indowAll运算算子来说所有记录将收集在一个任务中。

dataStream.windowAll(TumblingEventTimeWindows.of(Time.seconds(5))); // Last 5 seconds of data

  • Window Apply
    WindowedStream→DataStream
    AllWindowedStream→DataStream |

将一般性函数应用于整个窗口。下面是一个求和窗口函数。

注意:如果您正在使用windowAll转换,则需要使用AllWindowFunction。

windowedStream.apply (new WindowFunction, Integer, Tuple, Window>() {
    public void apply (Tuple tuple,
            Window window,
            Iterable> values,
            Collector out) throws Exception {
        int sum = 0;
        for (value t: values) {
            sum += t.f1;
        }
        out.collect (new Integer(sum));
    }
});

// applying an AllWindowFunction on non-keyed window stream
allWindowedStream.apply (new AllWindowFunction, Integer, Window>() {
    public void apply (Window window,
            Iterable> values,
            Collector out) throws Exception {
        int sum = 0;
        for (value t: values) {
            sum += t.f1;
        }
        out.collect (new Integer(sum));
    }
});

  • Window Reduce
    WindowedStream→DataStream |

将reduce函数应用于窗口。返回reduce后的新结果。

windowedStream.reduce (new ReduceFunction>() {
    public Tuple2 reduce(Tuple2 value1, Tuple2 value2) throws Exception {
        return new Tuple2(value1.f0, value1.f1 + value2.f1);
    }
});

  • Window Fold
    WindowedStream→DataStream

将fold函数应用于窗口并返回新的值。示例函数应用于序列(1,2,3,4,5)时,fold函数的输出为字符串“start-1-2-3-4-5”:

windowedStream.fold("start", new FoldFunction() {
    public String fold(String current, Integer value) {
        return current + "-" + value;
    }
});
  • Windows上的聚合
    WindowedStream→DataStream

聚合窗口上的内容。min和minBy之间的差异是:min返回最小值,而minBy返回该字段中具有最小值的元素(max和maxBy相同)。

windowedStream.sum(0);
windowedStream.sum("key");
windowedStream.min(0);
windowedStream.min("key");
windowedStream.max(0);
windowedStream.max("key");
windowedStream.minBy(0);
windowedStream.minBy("key");
windowedStream.maxBy(0);
windowedStream.maxBy("key");
  • Union
    DataStream *→DataStream

两个或多个数据流的联合,创建包含来自所有流的所有元素的新流。注意:如果将数据流与其自身联合,则会在结果流中获取两次元素。

dataStream.union(otherStream1, otherStream2, ...);
  • Window join
    DataStream,DataStream→DataStream |

在给定key和公共窗口上连接两个数据流。

dataStream.join(otherStream)
    .where().equalTo()
    .window(TumblingEventTimeWindows.of(Time.seconds(3)))
    .apply (new JoinFunction () {...});

  • Window CoGroup
    DataStream,DataStream→DataStream |

在给定key和公共窗口上对两个数据流进行Cogroup。

dataStream.coGroup(otherStream)
    .where(0).equalTo(1)
    .window(TumblingEventTimeWindows.of(Time.seconds(3)))
    .apply (new CoGroupFunction () {...});

  • Connect
    DataStream,DataStream→ConnectedStreams |

“连接”两个保留其类型的数据流。连接操作允许两个流之间的共享状态。

DataStream someStream = //...
DataStream otherStream = //...

ConnectedStreams connectedStreams = someStream.connect(otherStream);

  • CoMap,CoFlatMap
    ConnectedStreams→DataStream

类似于ConnectedStreams上的map和flatMap

connectedStreams.map(new CoMapFunction() {
    @Override
    public Boolean map1(Integer value) {
        return true;
    }

    @Override
    public Boolean map2(String value) {
        return false;
    }
});
connectedStreams.flatMap(new CoFlatMapFunction() {

   @Override
   public void flatMap1(Integer value, Collector out) {
       out.collect(value.toString());
   }

   @Override
   public void flatMap2(String value, Collector out) {
       for (String word: value.split(" ")) {
         out.collect(word);
       }
   }
});

  • Split
    DataStream→SplitStream

根据某些标准将流拆分为两个或更多个流。

SplitStream split = someDataStream.split(new OutputSelector() {
    @Override
    public Iterable select(Integer value) {
        List output = new ArrayList();
        if (value % 2 == 0) {
            output.add("even");
        }
        else {
            output.add("odd");
        }
        return output;
    }
});

  • Select
    SplitStream→DataStream

从split流中选择一个或多个流。

SplitStream split;
DataStream even = split.select("even");
DataStream odd = split.select("odd");
DataStream all = split.select("even","odd");
  • 迭代
    DataStream→IterativeStream→DataStream |

通过将一个运算符的输出重定向到某个先前的运算符,在流中创建“反馈”循环。这对于定义不断更新模型的算法特别有用。以下代码以流开头并连续应用迭代体。大于0的元素将被发送回反馈通道,其余元素将向下游转发。有关完整说明,请参阅迭代。

IterativeStream iteration = initialStream.iterate();
DataStream iterationBody = iteration.map (/*do something*/);
DataStream feedback = iterationBody.filter(new FilterFunction(){
    @Override
    public boolean filter(Long value) throws Exception {
        return value > 0;
    }
});
iteration.closeWith(feedback);
DataStream output = iterationBody.filter(new FilterFunction(){
    @Override
    public boolean filter(Long value) throws Exception {
        return value <= 0;
    }
});

物理分区

Flink还通过以下函数对转换后的stream进行精确分区、进行low-level控制(如果需要)。

  • 自定义分区
    DataStream→DataStream

使用用户定义的分区程序(Partitioner )为每个元素选择目标分区。

dataStream.partitionCustom(partitioner, "someKey");
dataStream.partitionCustom(partitioner, 0);

  • 随机分区
    DataStream→DataStream
    均匀分布随机分配元素:(均匀分布)
dataStream.shuffle();
  • 重新平衡(循环分区)
    DataStream→DataStream
    对元素循环分区,每个分区的负载相等。在存在数据偏斜时,用于性能优化。
dataStream.rebalance();

你可能感兴趣的:(【零基础学flink】flink中的转换算子(transform operator))