Flink 源码解析1--StreamGraph的生成

最新推荐文章于 2025-03-13 16:50:36 发布
最新推荐文章于 2025-03-13 16:50:36 发布
阅读量555 收藏 2
点赞数
分类专栏： Flink学习 文章标签： flink StreamGraph transformations
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u012151684/article/details/108816348
版权

1. 先来简单看一下入门的WordCount程序

1、首先数据源会产生随机的数字数据流(0-10内的数字)形式，然后通过flink的transformation将数据进行单词计数，再print输出

// wordcount 计数demo代码
public class WordCountDemo {
    public static void main(String[] args) throws Exception {

        // conf设置，避免调试的时候心跳超时
        Configuration configuration = new Configuration();
        configuration.setLong(HeartbeatManagerOptions.HEARTBEAT_INTERVAL, 10 * 60 * 1000);
        configuration.setLong(HeartbeatManagerOptions.HEARTBEAT_TIMEOUT, 20 * 60 * 1000);
        configuration.setString(AkkaOptions.ASK_TIMEOUT, "600 s");
        configuration.setString(AkkaOptions.WATCH_HEARTBEAT_INTERVAL, "600 s");
        configuration.setString(AkkaOptions.WATCH_HEARTBEAT_PAUSE, "1000 s");
        configuration.setString(AkkaOptions.TCP_TIMEOUT, "600 s");
        configuration.setString(AkkaOptions.TRANSPORT_HEARTBEAT_INTERVAL, "600 s");
        configuration.setString(AkkaOptions.LOOKUP_TIMEOUT, "600 s");
        configuration.setString(AkkaOptions.CLIENT_TIMEOUT, "600 s");
        configuration.setLong(WebOptions.TIMEOUT, 10 * 60 * 1000L);

        // local环境初始化
        StreamExecutionEnvironment streamExecutionEnvironment = StreamExecutionEnvironment.createLocalEnvironment(1, configuration);

        // 添加自定义的数据源(每秒随机产生一个范围在(0-10)的数字)
        DataStream<Integer> dataStream = streamExecutionEnvironment.addSource(new RandomSource()).returns(Integer.class);
        dataStream.map(new MapFunction<Integer, Tuple2<String, Integer>>() { // 生成 k-v对
            @Override
            public Tuple2<String, Integer> map(Integer value) throws Exception {
                return new Tuple2<>("i" + value, 1);
            }
        }).keyBy(0).timeWindow(Time.seconds(5)).reduce(new ReduceFunction<Tuple2<String, Integer>>() { // 每5s按照key进行统计计数
            @Override
            public Tuple2<String, Integer> reduce(Tuple2<String, Integer> value1, Tuple2<String, Integer> value2) throws Exception {
                value2.f1 = value1.f1 + value2.f1;
                return value2;
            }
        }).filter(new FilterFunction<Tuple2<String, Integer>>() {
            @Override
            public boolean filter(Tuple2<String, Integer> value) throws Exception {
                return value.f0.compareTo("i5") != 0;
            }
        }).print();
        streamExecutionEnvironment.execute("word count run");
    }
}

// 数据源产生器
public class RandomSource extends RichSourceFunction<Integer> {
    private Random random;
    private volatile Boolean running = false;

    @Override
    public void open(Configuration parameters) throws Exception {
        super.open(parameters);
        random = new Random();
        running = true;
    }

    @Override
    public void close() throws Exception {
        super.close();
        random = null;
    }

    @Override
    public void run(SourceContext<Integer> sourceContext) throws Exception {
        while (running) {
            Integer out = random.nextInt(10);
            sourceContext.collect(out);
            Thread.sleep(1000);
        }
    }

    @Override
    public void cancel() {
        running = false;
    }
}

在数据源产生器中，主要关注运行的run方法，其会源源不断的产生随机的数据并形成dataStream供后续flink transformation的操作

1、StreamExecutionEnvironment简单说明

        以dataStream.map(MapFunction(...))作为flink算子操作分析的入口，查看StreamExecutionEnvironment源码可以知道流式计算环境中几个重要的数据结构；

StreamExecutionEnvironment中包含：

  • ExecutionConfig config = new ExecutionConfig(); // 程序执行时的配置；主要包括默认并行度，序列化器，执行模式(Batch or Pipelined)等等；
  • CheckpointConfig checkpointCfg = new CheckpointConfig(); // ckp检查点相关的配置；主要包括检查点模式(EXACTLY_ONCE or AT_LEAST_ONCE)，检查点时间间隔，检查点在程序退出后是否删除等等；
  • StateBackend defaultStateBackend; // 流式计算中设置存储中间状态、检查点、保存点的存储介质(MemoryStateBackend，FsStateBackend，RocksDBStateBackend等);
  • TimeCharacteristic timeCharacteristic; // 流式计算中的处理时间设置
  • List<Tuple2<String, DistributedCache.DistributedCacheEntry>> cacheFile; // 需要分布式缓存的文件
  • List<StreamTransformation<?>> transformations = new ArrayList<>(); // 存储用户定义的flink transformation的算子操作

其下有四个实现的子类，主要是 本地执行环境、远程执行环境、CliContext交互式执行环境、Plan-web端执行环境；

在调用了execute()方法后，其具体执行由子类实现，子类实现大致逻辑：获取

  • 生成StreamGraph。代表程序的拓扑结构，是从用户代码定义的transformation算子直接生成的图。
  • 生成JobGraph。这个图是要交给flink去生成task的图。
  • 生成一系列配置
  • 将JobGraph和配置交给flink集群去运行。如果不是本地运行的话，还会把jar文件通过网络发给其他节点。
  • 以本地模式运行的话，可以看到启动过程，如启动性能度量、web模块、JobManager、ResourceManager、taskManager等等
  • 启动任务。值得一提的是在启动任务之前，先启动了一个用户类加载器，这个类加载器可以用来做一些在运行时动态加载类的工作。

2、flink算子(Operator)的注册、声明

       在程序中以env.addSource()和dataStream.map(...)来跟踪分析flink transformation算子的注册、声明streamExecutionEnvironment.addSource(new RandomSource()).returns(Integer.class); // 添加自定义的输入源跟踪源代码可以知道

public <OUT> DataStreamSource<OUT> addSource(SourceFunction<OUT> function, String sourceName, TypeInformation<OUT> typeInfo) {
  if (typeInfo == null) { // 根据数据源方法反射解析数据的输出类型
    if (function instanceof ResultTypeQueryable) {
      typeInfo = ((ResultTypeQueryable<OUT>) function).getProducedType();
    } else {
      try {
        typeInfo = TypeExtractor.createTypeInfo(
            SourceFunction.class,
            function.getClass(), 0, null, null);
      } catch (final InvalidTypesException e) {
        typeInfo = (TypeInformation<OUT>) new MissingTypeInfo(sourceName, e);
      }
    }
  }
  boolean isParallel = function instanceof ParallelSourceFunction; // 是否并行

  clean(function);
  StreamSource<OUT, ?> sourceOperator;
  if (function instanceof StoppableFunction) {
    sourceOperator = new StoppableStreamSource<>(cast2StoppableSourceFunction(function));
  } else {
    sourceOperator = new StreamSource<>(function); // 构建包装StreamSource数据产生源
  }
  return new DataStreamSource<>(this, typeInfo, sourceOperator, isParallel, sourceName); // 构建返回 DataStreamSource 数据源
}

        DataStreamSource数据产生源中，使用SourceTransformation类封装了StreamSource类，其包含用户自定义的SourceFunction；后续flink transformation算子转换操作的数据源头DataStream具体子类就是DataStreamSource；接下来进行.map()算子操作的分析：

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))); 
}


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, // 当前dataStream转换算子
         operatorName,
         operator, // 进行变换的转换操作
         outTypeInfo,
         environment.getParallelism()); // 将当前

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

   getExecutionEnvironment().addOperator(resultTransform);

   return returnStream;
}

        首先会根据当前DataStream也就是初始的DataStreamSource的输出类型以及当前的转换函数MapFunction去确定当前Map transformation算子转换之后的输出类型； 然后将当前Map transformation算子使用OneInputTransformation类封装了StreamMap类，其包含用户自定义的MapFunction，并将其添加到streamExecutionEnvironment中的transformations算子列表中；并将SingleOutputStreamOperator作为map算子作用后输出的DataStream；

        在算子中，每一个StreamTransformation代表了生成 DataStream 的操作，每一个 DataStream 的底层都有对应的一个 StreamTransformation。在 DataStream 上面通过 map 等算子不断进行转换，就得到了由 StreamTransformation 构成的图。当需要执行的时候，底层的这个图就会被转换成 StreamGraph。StreamTransformation 在运行时并不一定对应着一个物理转换操作，有一些操作只是逻辑层面上的，比如 split/select/partitioning 等。

        每一个 StreamTransformation 都有一个关联的 Id，这个 Id 是全局递增的。除此以外，还有 uid, slotSharingGroup, parallelism 等信息。

        StreamTransformation有很多具体的子类，如SourceTransformation、OneInputStreamTransformation、TwoInputTransformation、SideOutputTransformation、SinkTransformation等等，这些分别对应了DataStream 上的不同转换操作。

其映射过程如下所示：

最终可以根据程序有以下DataStream以及transformation算子转换形式：

        可以看到WindowStream负责生成对应的时间窗口、窗口触发器等，在flink中，其会将KeyStream、windowStream作为其下游聚合数据的来源，也就是说key-window-reduce的上下游transformation作为统一的一个transformation进行添加，其余的DataStream都会对应自己的StreamTransformation，这些StreamTransformation都会添加到streamExecutionEnvironment中的transformations算子列表(source和window相关的被下游算子持有引用)：

  1. OneInputTransformation{id=2, name='Map', outputType=Java Tuple2<String, Integer>, parallelism=1}；
    表示Map操作的OneInputTransformation对象，其input属性指向的是数据源的转换SourceTransformation；
  2. OneInputTransformation{id=4, name='Window(TumblingProcessingTimeWindows(5000), ProcessingTimeTrigger, ReduceFunction$2, PassThroughWindowFunction)', outputType=Java Tuple2<String, Integer>, parallelism=1}；
    表示reduce操作的OneInputTransformation对象，其input属性指向的是表示keyBy的转换PartitionTransformation，而PartitionTransformation的input属性指向的是Map转换的OneInputTransformation；
  3. OneInputTransformation{id=5, name='Filter', outputType=Java Tuple2<String, Integer>, parallelism=1}；
    表示filter操作的OneInputTransformation对象，其input属性指向的是reduce转化的OneInputTransformation对象；
  4. SinkTransformation{id=6, name='Print to Std. Out', outputType=GenericType<java.lang.Object>, parallelism=1}；
    表示sink操作对应的SinkTransformation对象，其input属性指向的是fliter转化的OneInputTransformation对象；

3、StreamGraph的生成

        在transformations算子被注册、声明后，env.executor()会调用StreamGraph streamGraph = getStreamGraph(); 其会调用基类的streamGraph生成方法；StreamGraphGenerator.generate(env, transformations)；其中的transformations就是记录我们在流式转换的transform方法中放进来的转换算子的list列表；在遍历List<StreamTransformation>生成StreamGraph的时候，会递归调用StreamGraphGenerator#transform方法。对于每一个StreamTransformation，确保当前其上游已经完成转换。     

       StreamTransformations会被转换为StreamGraph中的节点StreamNode，并为上下游节点添加连接两个StreamNode节点的数据流边StreamEdge。其中涉及到StreamGraph生成的代码主要为两大块：

private Collection<Integer> transform(StreamTransformation<?> transform) { // 针对单个transformation进行转化

   if (alreadyTransformed.containsKey(transform)) { // 由于是递归调用的，可能已经完成了转换，避免多次重复转化
      return alreadyTransformed.get(transform);
   }

   LOG.debug("Transforming " + transform);

   if (transform.getMaxParallelism() <= 0) {

      // if the max parallelism hasn't been set, then first use the job wide max parallelism
      // from theExecutionConfig.
      int globalMaxParallelismFromConfig = env.getConfig().getMaxParallelism();
      if (globalMaxParallelismFromConfig > 0) {
         transform.setMaxParallelism(globalMaxParallelismFromConfig);
      }
   }

   // call at least once to trigger exceptions about MissingTypeInfo
   transform.getOutputType();

   // 这里对操作符的类型进行判断，并调用相应转换操作的图处理逻辑
   // 主要核心功能是递归的将该节点和节点的上游节点加入图
   Collection<Integer> transformedIds;
   if (transform instanceof OneInputTransformation<?, ?>) {
      transformedIds = transformOneInputTransform((OneInputTransformation<?, ?>) transform);
   } else if (transform instanceof TwoInputTransformation<?, ?, ?>) {
      transformedIds = transformTwoInputTransform((TwoInputTransformation<?, ?, ?>) transform);
   } else if (transform instanceof SourceTransformation<?>) {
      transformedIds = transformSource((SourceTransformation<?>) transform);
   } else if (transform instanceof SinkTransformation<?>) {
      transformedIds = transformSink((SinkTransformation<?>) transform);
   } else if (transform instanceof UnionTransformation<?>) {
      transformedIds = transformUnion((UnionTransformation<?>) transform);
   } else if (transform instanceof SplitTransformation<?>) {
      transformedIds = transformSplit((SplitTransformation<?>) transform);
   } else if (transform instanceof SelectTransformation<?>) {
      transformedIds = transformSelect((SelectTransformation<?>) transform);
   } else if (transform instanceof FeedbackTransformation<?>) {
      transformedIds = transformFeedback((FeedbackTransformation<?>) transform);
   } else if (transform instanceof CoFeedbackTransformation<?>) {
      transformedIds = transformCoFeedback((CoFeedbackTransformation<?>) transform);
   } else if (transform instanceof PartitionTransformation<?>) {
      transformedIds = transformPartition((PartitionTransformation<?>) transform);
   } else if (transform instanceof SideOutputTransformation<?>) {
      transformedIds = transformSideOutput((SideOutputTransformation<?>) transform);
   } else {
      throw new IllegalStateException("Unknown transformation: " + transform);
   }

   // need this check because the iterate transformation adds itself before
   // transforming the feedback edges
   if (!alreadyTransformed.containsKey(transform)) {
      alreadyTransformed.put(transform, transformedIds);
   }
   // ..................... 进行一些资源和配置上的设置
   return transformedIds;
}

以最典型的transformOneInputTransform为例进行转化StreamNode节点的操作分析：

private <IN, OUT> Collection<Integer> transformOneInputTransform(OneInputTransformation<IN, OUT> transform) {

   Collection<Integer> inputIds = transform(transform.getInput()); // 首先先确保上游节点都完成转换

   // the recursive call might have already transformed this
   if (alreadyTransformed.containsKey(transform)) {
      return alreadyTransformed.get(transform);
   }

   String slotSharingGroup = determineSlotSharingGroup(transform.getSlotSharingGroup(), inputIds); // 确定资源共享组，用户如果没有指定，默认是default
   
   streamGraph.addOperator(transform.getId(),  // 向StreamGraph中添加Operator, 这一步会生成对应的StreamNode
         slotSharingGroup,
         transform.getCoLocationGroupKey(),
         transform.getOperator(),
         transform.getInputType(),
         transform.getOutputType(),
         transform.getName());

   if (transform.getStateKeySelector() != null) {
      TypeSerializer<?> keySerializer = transform.getStateKeyType().createSerializer(env.getConfig());
      streamGraph.setOneInputStateKey(transform.getId(), transform.getStateKeySelector(), keySerializer);
   }

   streamGraph.setParallelism(transform.getId(), transform.getParallelism());
   streamGraph.setMaxParallelism(transform.getId(), transform.getMaxParallelism());

   for (Integer inputId: inputIds) { // 依次连接到上游节点, 创建并生成对应的StreamEdge
      streamGraph.addEdge(inputId, transform.getId(), 0);
   }

   return Collections.singleton(transform.getId());
}

        具体的StreamNode节点生成过程，在生成StreamNode中，保存了对应的 StreamOperator (从 StreamTransformation 得到)，并且还引入了变量 jobVertexClass 来表示该节点在 TaskManager 中运行时的实际任务类型；AbstractInvokable是所有可以在TaskManager中运行的任务的抽象基础类，包括流式任务和批任务。StreamTask是所有流式任务的基础类，其具体的子类包括SourceStreamTask, OneInputStreamTask, TwoInputStreamTask等等。

protected StreamNode addNode(Integer vertexID,
   String slotSharingGroup,
   @Nullable String coLocationGroup,
   Class<? extends AbstractInvokable> vertexClass,
   StreamOperator<?> operatorObject,
   String operatorName) {

   if (streamNodes.containsKey(vertexID)) {
      throw new RuntimeException("Duplicate vertexID " + vertexID);
   }

   StreamNode vertex = new StreamNode(environment,   // 创建StreamNode，这里保存了StreamOperator和vertexClass的信息
      vertexID,
      slotSharingGroup,
      coLocationGroup,
      operatorObject,
      operatorName,
      new ArrayList<OutputSelector<?>>(),
      vertexClass);

   streamNodes.put(vertexID, vertex);

   return vertex;
}

        前面提到，在每一个物理节点的转换上，会调用 StreamGraph#addEdge 在输入节点和当前节点之间建立边的连接；对于一些不包含物理转换操作的 StreamTransformation，如 Partitioning, split/select, union，并不会生成 StreamNode，而是生成一个带有特定属性的虚拟节点。当添加一条有虚拟节点指向下游节点的边时，会找到虚拟节点上游的物理节点，在两个物理节点之间添加边，并把虚拟转换操作的属性附着上去。

private void addEdgeInternal(Integer upStreamVertexID,
		Integer downStreamVertexID,
		int typeNumber,
		StreamPartitioner<?> partitioner,
		List<String> outputNames,
		OutputTag outputTag) {

	//先判断是不是虚拟节点上的边，如果是，则找到虚拟节点上游对应的物理节点
	//在两个物理节点之间添加边，并把对应的 StreamPartitioner,或者 OutputTag 等补充信息添加到StreamEdge中
	if (virtualSideOutputNodes.containsKey(upStreamVertexID)) {
		......
	} else if (virtualPartitionNodes.containsKey(upStreamVertexID)) {
		int virtualId = upStreamVertexID;
		upStreamVertexID = virtualPartitionNodes.get(virtualId).f0;
		if (partitioner == null) {
			partitioner = virtualPartitionNodes.get(virtualId).f1;
		}
		addEdgeInternal(upStreamVertexID, downStreamVertexID, typeNumber, partitioner, outputNames, outputTag);
	} else {
		//两个物理节点
		StreamNode upstreamNode = getStreamNode(upStreamVertexID);
		StreamNode downstreamNode = getStreamNode(downStreamVertexID);

		// If no partitioner was specified and the parallelism of upstream and downstream
		// operator matches use forward partitioning, use rebalance otherwise.
		if (partitioner == null && upstreamNode.getParallelism() == downstreamNode.getParallelism()) {
			partitioner = new ForwardPartitioner<Object>();
		} else if (partitioner == null) {
			partitioner = new RebalancePartitioner<Object>();
		}

		if (partitioner instanceof ForwardPartitioner) {
			if (upstreamNode.getParallelism() != downstreamNode.getParallelism()) {
				throw new UnsupportedOperationException("Forward partitioning does not allow " +
						"change of parallelism. Upstream operation: " + upstreamNode + " parallelism: " + upstreamNode.getParallelism() +
						", downstream operation: " + downstreamNode + " parallelism: " + downstreamNode.getParallelism() +
						" You must use another partitioning strategy, such as broadcast, rebalance, shuffle or global.");
			}
		}

		//创建 StreamEdge，保留了StreamPartitioner等属性
		StreamEdge edge = new StreamEdge(upstreamNode, downstreamNode, typeNumber, outputNames, partitioner, outputTag);

		//分别将StreamEdge添加到上游节点和下游节点
		getStreamNode(edge.getSourceId()).addOutEdge(edge);
		getStreamNode(edge.getTargetId()).addInEdge(edge);
	}
}
//StreamGraphGenerator#transformPartition
private <T> Collection<Integer> transformPartition(PartitionTransformation<T> partition) {
	StreamTransformation<T> input = partition.getInput();
	List<Integer> resultIds = new ArrayList<>();

	//递归地转换上游节点 (若上游已转换则直接返回转换ids)
	Collection<Integer> transformedIds = transform(input);

	for (Integer transformedId: transformedIds) {
		int virtualId = StreamTransformation.getNewNodeId();
		//添加虚拟的 Partition 节点
		streamGraph.addVirtualPartitionNode(transformedId, virtualId, partition.getPartitioner());
		resultIds.add(virtualId);
	}

	return resultIds;
}

// StreamGraph#addVirtualPartitionNode
public void addVirtualPartitionNode(Integer originalId, Integer virtualId, StreamPartitioner<?> partitioner) {

	if (virtualPartitionNodes.containsKey(virtualId)) {
		throw new IllegalStateException("Already has virtual partition node with id " + virtualId);
	}

	//添加一个虚拟节点，后续添加边的时候会连接到实际的物理节点
	virtualPartitionNodes.put(virtualId,
		new Tuple2<Integer, StreamPartitioner<?>>(originalId, partitioner));
}

针对上一节分析的WordCountDemo代码进行转化操作具体分析：1、针对第一个Map操作进行具体生成StreamNode节点的分析如下：

1、OneInputTransformation{id=2, name='Map', outputType=Java Tuple2<String, Integer>, parallelism=1}；
      表示Map操作的OneInputTransformation对象，其input属性指向的是数据源的转换SourceTransformation；

  • 其会先第一步对其Map#OneInputTransformation的上游输入input#SourceTransformation进行生成StreamNode节点处理；其会进一步调用streamGraph.addSource()，添加Source所对应的StreamNode节点，其会包括Source源#StreamOperator和可执行任务类型jobVertexClass#SourceStreamTask；
  • 后面则会对Map#OneInputTransformation当前算子进行处理，生成StreamNode节点；其会包括StreamMap#MapFunction和可执行任务类型jobVertexClass#OneInputStreamTask；
  • 之后便会对当前算子Map以及其上游输入Source算子进行StreamEdge的数据连接边的添加；最终形成Node#Source-- StreamEdge--Node#Map 这样的形式；

StreamNode#Source(Custom Source-1；inEdges=null, outEdges=StreamEdge#(sourceVertex=StreamNode#Source, targetVertex=StreamNode#Map))

               StreamEdge#(Source: Custom Source-1 -> Map-2, typeNumber=0, selectedNames=[], outputPartitioner=FORWARD, outputTag=null)

StreamNode#Map(Map-2；inEdges=StreamEdge#(sourceVertex=StreamNode#Source, targetVertex=StreamNode#Map), outEdges=null))

 

所有针对上诉转化代码，有最终的StreamGraph 图拓扑结构形成如下：
如下transformations算子列表(source和window相关的被下游算子持有引用)：

1、OneInputTransformation{id=2, name='Map', outputType=Java Tuple2<String, Integer>, parallelism=1}；
      表示Map操作的OneInputTransformation对象，其input属性指向的是数据源的转换SourceTransformation(StreamNode#1)；

2、OneInputTransformation{id=4, name='Window(TumblingProcessingTimeWindows(5000), ProcessingTimeTrigger, ReduceFunction$2, PassThroughWindowFunction)', outputType=Java Tuple2<String, Integer>, parallelism=1}；
      表示reduce操作的OneInputTransformation对象，其input属性指向的是表示keyBy的转换PartitionTransformation，而PartitionTransformation的input属性指向的是Map转换的OneInputTransformation；

3、OneInputTransformation{id=5, name='Filter', outputType=Java Tuple2<String, Integer>, parallelism=1}；
      表示filter操作的OneInputTransformation对象，其input属性指向的是reduce转化的OneInputTransformation对象；

4、SinkTransformation{id=6, name='Print to Std. Out', outputType=GenericType<java.lang.Object>, parallelism=1}；
      表示sink操作对应的SinkTransformation对象，其input属性指向的是fliter转化的OneInputTransformation对象；

 

1、StreamNode#1(SourceTransformation) --> StreamEdge --> StreamNode#2(MapTransformation)

2、StreamNode#2(MapTransformation) --> (先指向PartitionTransformation所在的虚拟节点StreamNode#3) --> StreamNode#4(WindowTransformation)；最终会使用StreamEdge 替换虚拟节点来连接两个实体StreamNode，其StreamEdge上包含虚拟节点所有的转换属性；

      StreamNode#2(MapTransformation) --> StreamEdge --> StreamNode#4(WindowTransformation)；

3、StreamNode#4(WindowTransformation) --> StreamEdge --> StreamNode#5(FilterTransformation)；

4、StreamNode#5(FilterTransformation) --> StreamEdge --> StreamNode#6(SinkTransformation)；

针对上述转化过程，其对数据流的相关转换操作，都可以通过streamExecutionEnvironment.getStreamGraph().getStreamingPlanAsJSON()来获取到StreamGraph实例的json字符串；将获取到的json字符串放如到 http://flink.apache.org/visualizer/ ，可以转化为图形表示，如下：

 

flink实战--StreamGraph，JobGraph，ExecutionGraph生成流程解析
阿华田的博客
03-26 902
简介 Flink在执行用户的任务时，会涉及到StreamGraph，JobGraph，ExecutionGraph，物理执行图。其中StreamGraph和JobGraph是在client端生成的，ExecutionGraph是在JobMaster中执行的，本文将详细介绍这些Graph的生成流程，方便大家对Flink内部执行流程有一个清晰的认识。 StreamGraph是根据用户代码生成的最原始执行图，也就是直接翻译用户逻辑得到的图 JobGraph是对StreamGraph进行优化.....
Flink源码解析系列--StreamExecutionEnvironment类
热门推荐
打酱油的葫芦娃
03-31 1万+
本文的Flink源码版本为: 1.15-SNAPSHOT，读者可自行从Github clone. Flink 程序看起来像一个转换 DataStream 的常规程序。每个程序由相同的基本部分组成： 获取一个执行环境（execution environment）； 加载/创建初始数据； 指定数据相关的转换； 指定计算结果的存储位置； 触发程序执行。 StreamExecutionEnvironment 是所有 Flink 程序的基础。 创建 你可以使用 StreamExecutionEnvironme.
flink源码分析-StreamGraph的生成
weixin_41197407的博客
12-28 1577
前提之一：DAG 理解StreamGraph的前提之一就是要对DAG有向无环图有所了解。需要知道什么是DAG的顶点和边，以及怎么通过顶点和边构建DAG。 前提之二：Transformation Flink流处理中的各个算子操作会转化成一系列的Transformation对象进行存储，StreamGraph就是通过一系列的Transformation对象进行构建。 Transformation类型 OneInputTransformation 只有一个输入的一类转化操作，如map、filter、proces
Flink 原理与实现：如何生成 StreamGraph
cache007的专栏
07-29 1057
继上文Flink 原理与实现：架构和拓扑概览中介绍了Flink的四层执行图模型，本文将主要介绍 Flink 是如何根据用户用Stream API编写的程序，构造出一个代表拓扑结构的StreamGraph的。 注：本文比较偏源码分析，所有代码都是基于 flink-1.0.x 版本，建议在阅读本文前先对Stream API有个了解，详见官方文档。 StreamGraph 相关的代码主要
深入Flink StreamGraph：构建流处理拓扑的奥秘
最新发布
qq_35485206的博客
03-13 708
⭐简单说两句⭐✨ 正在努力的小新~???? 超级爱分享，分享各种有趣干货！???????? 提供：模拟面试 | 简历诊断 | 独家简历模板???? 感谢关注，关注了你就是我的超级粉丝啦！???? 以下内容仅对你可见~作者：不正经小新????GZH：不正经小新????欢迎关注????点赞????收藏⭐️留言????Flink StreamGraph什么是StreamGraphStre...
Flink源码（一）：StreamGraph
Dengdz
07-23 1660
前提：由于最近需要在原有Flink CEP的基础上，实现动态加载CEP规则的需求，因此想到了通过自定义动态CEP算子以及自定义动态pattern加载的算子协调器实现规则的更新。因此在开发同时记录一下Flink数据处理的过程。
flink streamGraph生成
不说话装高手
02-07 546
当完成DataStream的配置后，调用其中环境上下文StreamExecutionEnvironment的getStreamGrahph()方法即可生成关于该DataStream的streamGraph。 @Internal public StreamGraph getStreamGraph() { if (transformations.size() &lt;= 0) { ...
Flink 源码-StreamGraph基本概念
jacky_wang_123的专栏
10-18 427
Flink的Graph有4层：Stream Graph - Job Graph - Execution Graph - 物理执行图 如图所示，Stream Graph中主要包含了：StreamNode 和 StreamEdge 实例代码： // get input data by connecting to the socket DataStream<String> source = env.socketTextStream(hostname, po.
Flink内核源码解析--Flink中重要的工作组件和机制
weixin_42492886的博客
08-16 968
这是因为Flink节点与节点之间，组件与组件之间通信采用的是Akka，但是数据交换，比如算子与算子之间的数据交换采用的是Netty，比如Flink中有JobManager，还有TaskManager从节点，而JobManager主节点里面有一些组件，比如JobMaster，Dispatcher等，组件与组件之间通信采用的是Akka，而Netty是算子与算子之间，比如Map算子后面跟着Filter,Filter后面跟着reducekeyby等操作这些算子之间采用的是Netty来通信的。
Flink源码解读(一)：StreamGraph源码解读
Stray_Lambs的博客
09-30 1196
目录 Flink流图基本概念 StreamGraph源码 StreamGraph的核心对象 StreamNode StreamEdge StreamNode和StreamEdge之间的关系 上传jar包 生成StreamGraph 生成StreamNode 生成Edge 核心方法 参考 Flink流图基本概念 这里简单介绍一下Flink流图的一些基本概念和过程，详情可以看Flink基础概念。根据不同图的生成顺序，主要是分为4层：StreamGraph-->JobGrap
一文搞懂Flink生成StreamGraph
shengjk1的博客
09-24 911
1. 前言 2. FlatMap 的转化 1.前言 通过一文搞懂这一系列的文章，我们已经知道了，Flink 作业的提交过程： 这篇文章主要聚焦在 我们以简单的代码为例 /** * @author shengjk1 * @date 2018/11/23 */ public class FlinkJava8Demo { public static void main(String[] args) throws Exception { StreamExecutionEnvironmen..
flink系列(7)-streamGraph
weixin_33753845的博客
04-17 216
2019独角兽企业重金招聘Python工程师标准>>> ...
Flink源码-StreamGraph的生成
bigdatakenan的博客
08-19 283
上个帖子我们分析到了我们代码中算子最终会通过transformation的add方法将自身的血缘依赖添加到一个transformations这个list中，接下来我们看一下transforamtions是如何把血缘依赖放进streamgraph中.
Apache Flink Client生成StreamGraph
VinoYang的专栏
07-23 7423
概述上文我们分析提交流程时，RemoteStreamEnvironment类的execute方法的第一步就是生成StreamGraph。StreamGraph是用于表示流的拓扑结构的数据结构，它包含了生成JobGraph的必要信息。
Flink源码系列——获取StreamGraph的过程
混混的博客
03-09 2166
接着《Flink源码系列——一个简单的数据处理功能的实现过程》一文的结尾继续分析，在完成对数据流的转换操作之后，需要执行任务，这时会调用如下代码： env.execute("Socket Window WordCount"); 在StreamExecutionEnvironment中，这是一个抽象方法，具体的实现在其子类中，其子类StreamContextEnvironment的实现如下：...
Flink1.15源码阅读——StreamGraph流图
京河小蚁的博客
08-07 964
StreamGraph 经过优化后生成了JobGraph，提交给Jobmanager的数据结构，主要的优化为，将多个符合条件的节点 chain在一起作为一个节点，这样可以减少数据在节点之间流动所需要的序列化/反序列化/传输消耗。JobManager根据Execution对job进行调度后，在各个TaskManager上部署Task后形成的图，并不是一个具体的数据结构。JobManager根据JobGraph生成的。是根据用户代码通过Stream API编写的代码生成的最初的图。用来表示程序的拓扑结构。...
Flink之StreamGraph生成源码分析
qq_18218071的博客
12-20 482
Flink之StreamGraph生成源码分析 一、StreamGraph是什么？ 是用户提交的代码，直接生产的数据流图 二、生成StreamGraph的过程 2.1 触发执行生成StreamGraph 程序执行即env.execute("Java WordCount")这行代码，这里以RemoteStreamEnvironment环境为例 @Override public JobExecutionResult execute(String jobName) throws ProgramInvocation
Flink 1.13 源码解析——Graph的转化以及StreamGraph的构建
EdwardWang_的博客
09-23 1472
Flink 1.13 源码解析 Graph的转化以及StreamGraph的构建
Flink作业提交之StreamGraph构建源码解析
qq_24186017的博客
09-22 598
Flink作业提交之StreamGraph构建源码解析
Flink流处理：StreamGraph生成深度解析
StreamGraph生成函数会根据这些转换链路，构建出一个有向无环图（DAG），每个节点代表一个算子，边则表示数据流的流向。 接着，生成的StreamGraph进一步发展成为JobGraph，这是Flink在分布式环境中的执行单元。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值