flink Datastream组装

transformation是flink中stream的静态对象，通过组装包含sink和source的transformation根据定义的代码可以组成stream的静态拓扑图，如下所示：

*   Source              Source
*      +                   +
*      |                   |
*      v                   v
*  Rebalance          HashPartition
*      +                   +
*      |                   |
*      |                   |
*      +------>Union<------+
*                +
*                |
*                v
*              Split
*                +
*                |
*                v
*              Select
*                +
*                v
*               Map
*                +
*                |
*                v
*              Sink

其中Source和SInk分别为拓扑图中的起点和终点，其中的spilt,select则是中间具体对数据进行操作的transformation。

同时DataStream类也是一个完成的一个stream数据抽象，其成员如下：

protected final StreamExecutionEnvironment environment;

protected final StreamTransformation<T> transformation;

其中envirorment是整个流的上下文，其中的以数组的形式依次保存着之前的所有transformation，而transformation则是当前strean在组装过程中，逻辑上最后一个transformation。

 

下面也是一个简单的stream拓扑图例子：

*  Source              Source
*    +                   +
*    |                   |
*    |                   |
*    +------->Map<-------+
*              +
*              |
*              v
*             Sink

其中的map也是一个具体的streamTransformation，由DataStream调用map()方法具体加入到stream操作中。

public <R> SingleOutputStreamOperator<R> map(MapFunction<T, R> mapper) {

   TypeInformation<R> outType = TypeExtractor.getMapReturnTypes(clean(mapper), getType(),
         Utils.getCallLocationName(), true);

   return transform("Map", outType, new StreamMap<>(clean(mapper)));
}

在此处，当前一个DataStream调用map()方法的时候，首先需要得到当前DataStream的treanformation中输出的数据类型，根据其数据类型作为新的transformation的输入数据类型。

并需要具体实现map逻辑的MapFunction作为参数，否则没有意义。

之后将这一数据类型作为参数的一部分，在根据参数中的MapFunction生成新的StreamMap,也就是动态操作符，通过transform()方法，得到新的DataStream。

@PublicEvolving
public <R> SingleOutputStreamOperator<R> transform(String operatorName, TypeInformation<R> outTypeInfo, OneInputStreamOperator<T, R> operator) {

   // read the output type of the input Transform to coax out errors about MissingTypeInfo
   transformation.getOutputType();

   OneInputTransformation<T, R> resultTransform = new OneInputTransformation<>(
         this.transformation,
         operatorName,
         operator,
         outTypeInfo,
         environment.getParallelism());

   @SuppressWarnings({ "unchecked", "rawtypes" })
   SingleOutputStreamOperator<R> returnStream = new SingleOutputStreamOperator(environment, resultTransform);

   getExecutionEnvironment().addOperator(resultTransform);

   return returnStream;
}

在此处，由于是一个map操作，自然输入输出只需要一个，所以首先生成OneInputTransformation，这里的参数需要前一个transformation和当前的map操作和输入数据类型，以及当前上下文环境的并行度。

最后将生成的tramsform和上下文生成新的DataStream返回，作为新的DataStream进行下面的transform组装。

 

另一种例子是union操作，这一操作将会合并两个不同的DataStream。

@SafeVarargs
public final DataStream<T> union(DataStream<T>... streams) {
   List<StreamTransformation<T>> unionedTransforms = new ArrayList<>();
   unionedTransforms.add(this.transformation);

   for (DataStream<T> newStream : streams) {
      if (!getType().equals(newStream.getType())) {
         throw new IllegalArgumentException("Cannot union streams of different types: "
               + getType() + " and " + newStream.getType());
      }

      unionedTransforms.add(newStream.getTransformation());
   }
   return new DataStream<>(this.environment, new UnionTransformation<>(unionedTransforms));
}
public UnionTransformation(List<StreamTransformation<T>> inputs) {
   super("Union", inputs.get(0).getOutputType(), inputs.get(0).getParallelism());

   for (StreamTransformation<T> input: inputs) {
      if (!input.getOutputType().equals(getOutputType())) {
         throw new UnsupportedOperationException("Type mismatch in input " + input);
      }
   }

   this.inputs = Lists.newArrayList(inputs);
}

此处会将所有需要合并的DataStream保存在数组当中，并生成一个新的UnionTransformation，其中将所有需要合并的DataStream数组参数作为例子保存在其中。新的UnionTransformation也将会作为新的DataStream的transform参数返回。

 

spilt和select同时使用可以达到分流的目的。

spilt()在被调用的时候需要一个OutputSelect并重写其select()方法，根据相应流入的数据返回不同的输出结果，而接下来再调用select()方法，并在参数中确定制定的返回结果，将会依照前者的输出结果定位到指定的流当中去。