聊聊flink的JobManagerGateway

最新推荐文章于 2024-03-25 18:09:48 发布
最新推荐文章于 2024-03-25 18:09:48 发布
阅读量246 收藏
点赞数
文章标签： 大数据 java runtime
原文链接：https://my.oschina.net/go4it/blog/3023760
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

序

本文主要研究一下flink的JobManagerGateway

RestfulGateway

flink-1.7.2/flink-runtime/src/main/java/org/apache/flink/runtime/webmonitor/RestfulGateway.java

public interface RestfulGateway extends RpcGateway {

	CompletableFuture<Acknowledge> cancelJob(JobID jobId, @RpcTimeout Time timeout);

	CompletableFuture<Acknowledge> stopJob(JobID jobId, @RpcTimeout Time timeout);

	CompletableFuture<String> requestRestAddress(@RpcTimeout  Time timeout);

	CompletableFuture<? extends AccessExecutionGraph> requestJob(JobID jobId, @RpcTimeout Time timeout);

	CompletableFuture<JobResult> requestJobResult(JobID jobId, @RpcTimeout Time timeout);

	CompletableFuture<MultipleJobsDetails> requestMultipleJobDetails(
		@RpcTimeout Time timeout);

	CompletableFuture<ClusterOverview> requestClusterOverview(@RpcTimeout Time timeout);

	CompletableFuture<Collection<String>> requestMetricQueryServicePaths(@RpcTimeout Time timeout);

	CompletableFuture<Collection<Tuple2<ResourceID, String>>> requestTaskManagerMetricQueryServicePaths(@RpcTimeout Time timeout);

	default CompletableFuture<String> triggerSavepoint(
			JobID jobId,
			String targetDirectory,
			boolean cancelJob,
			@RpcTimeout Time timeout) {
		throw new UnsupportedOperationException();
	}

	default CompletableFuture<Acknowledge> disposeSavepoint(
			final String savepointPath,
			@RpcTimeout final Time timeout) {
		throw new UnsupportedOperationException();
	}

	default CompletableFuture<JobStatus> requestJobStatus(
			JobID jobId,
			@RpcTimeout Time timeout) {
		throw new UnsupportedOperationException();
	}

	default CompletableFuture<OperatorBackPressureStatsResponse> requestOperatorBackPressureStats(
			JobID jobId,
			JobVertexID jobVertexId) {
		throw new UnsupportedOperationException();
	}

	default CompletableFuture<Acknowledge> rescaleJob(
			JobID jobId,
			int newParallelism,
			RescalingBehaviour rescalingBehaviour,
			@RpcTimeout Time timeout) {
		throw new UnsupportedOperationException();
	}

	default CompletableFuture<Acknowledge> shutDownCluster() {
		throw new UnsupportedOperationException();
	}
}
  • RestfulGateway接口继承了RpcGateway接口，它定义了cancelJob、stopJob、requestRestAddress、requestJob、requestJobResult、requestMultipleJobDetails、requestClusterOverview、requestMetricQueryServicePaths、requestTaskManagerMetricQueryServicePaths方法；另外提供了triggerSavepoint、disposeSavepoint、requestJobStatus、requestOperatorBackPressureStats、rescaleJob、shutDownCluster这几个默认方法，其实现均抛出UnsupportedOperationException异常

JobManagerGateway

flink-1.7.2/flink-runtime/src/main/java/org/apache/flink/runtime/jobmaster/JobManagerGateway.java

public interface JobManagerGateway extends RestfulGateway {

	CompletableFuture<Integer> requestBlobServerPort(Time timeout);

	CompletableFuture<Acknowledge> submitJob(JobGraph jobGraph, ListeningBehaviour listeningBehaviour, Time timeout);

	CompletableFuture<String> cancelJobWithSavepoint(JobID jobId, @Nullable String savepointPath, Time timeout);

	CompletableFuture<Acknowledge> cancelJob(JobID jobId, Time timeout);

	CompletableFuture<Acknowledge> stopJob(JobID jobId, Time timeout);

	CompletableFuture<Optional<JobManagerMessages.ClassloadingProps>> requestClassloadingProps(JobID jobId, Time timeout);

	CompletableFuture<Optional<Instance>> requestTaskManagerInstance(ResourceID resourceId, Time timeout);

	CompletableFuture<Collection<Instance>> requestTaskManagerInstances(Time timeout);

	CompletableFuture<JobIdsWithStatusOverview> requestJobsOverview(Time timeout);
}
  • JobManagerGateway接口继承了RestfulGateway接口，它定义了requestBlobServerPort、submitJob、cancelJobWithSavepoint、cancelJob、stopJob、requestClassloadingProps、requestTaskManagerInstance、requestTaskManagerInstances、requestJobsOverview方法；它有一个实现类是AkkaJobManagerGateway

AkkaJobManagerGateway

flink-1.7.2/flink-runtime/src/main/java/org/apache/flink/runtime/akka/AkkaJobManagerGateway.java

public class AkkaJobManagerGateway implements JobManagerGateway {

	private final ActorGateway jobManagerGateway;
	private final String hostname;

	public AkkaJobManagerGateway(ActorGateway jobManagerGateway) {
		this.jobManagerGateway = Preconditions.checkNotNull(jobManagerGateway);

		final Option<String> optHostname = jobManagerGateway.actor().path().address().host();
		hostname = optHostname.isDefined() ? optHostname.get() : "localhost";
	}

	@Override
	public String getAddress() {
		return jobManagerGateway.path();
	}

	@Override
	public String getHostname() {
		return hostname;
	}

	@Override
	public CompletableFuture<Integer> requestBlobServerPort(Time timeout) {
		return FutureUtils.toJava(
			jobManagerGateway
				.ask(JobManagerMessages.getRequestBlobManagerPort(), FutureUtils.toFiniteDuration(timeout))
				.mapTo(ClassTag$.MODULE$.apply(Integer.class)));
	}

	//--------------------------------------------------------------------------------
	// Job control
	//--------------------------------------------------------------------------------

	@Override
	public CompletableFuture<Acknowledge> submitJob(JobGraph jobGraph, ListeningBehaviour listeningBehaviour, Time timeout) {
		return FutureUtils
			.toJava(
				jobManagerGateway.ask(
					new JobManagerMessages.SubmitJob(
						jobGraph,
						listeningBehaviour),
					FutureUtils.toFiniteDuration(timeout)))
			.thenApply(
				(Object response) -> {
					if (response instanceof JobManagerMessages.JobSubmitSuccess) {
						JobManagerMessages.JobSubmitSuccess success = ((JobManagerMessages.JobSubmitSuccess) response);

						if (Objects.equals(success.jobId(), jobGraph.getJobID())) {
							return Acknowledge.get();
						} else {
							throw new CompletionException(new FlinkException("JobManager responded for wrong Job. This Job: " +
								jobGraph.getJobID() + ", response: " + success.jobId()));
						}
					} else if (response instanceof JobManagerMessages.JobResultFailure) {
						JobManagerMessages.JobResultFailure failure = ((JobManagerMessages.JobResultFailure) response);

						throw new CompletionException(new FlinkException("Job submission failed.", failure.cause()));
					} else {
						throw new CompletionException(new FlinkException("Unknown response to SubmitJob message: " + response + '.'));
					}
				}
			);
	}

	@Override
	public CompletableFuture<String> cancelJobWithSavepoint(JobID jobId, String savepointPath, Time timeout) {
		CompletableFuture<JobManagerMessages.CancellationResponse> cancellationFuture = FutureUtils.toJava(
			jobManagerGateway
				.ask(new JobManagerMessages.CancelJobWithSavepoint(jobId, savepointPath), FutureUtils.toFiniteDuration(timeout))
				.mapTo(ClassTag$.MODULE$.apply(JobManagerMessages.CancellationResponse.class)));

		return cancellationFuture.thenApply(
			(JobManagerMessages.CancellationResponse response) -> {
				if (response instanceof JobManagerMessages.CancellationSuccess) {
					return ((JobManagerMessages.CancellationSuccess) response).savepointPath();
				} else {
					throw new CompletionException(new FlinkException("Cancel with savepoint failed.", ((JobManagerMessages.CancellationFailure) response).cause()));
				}
			});
	}

	@Override
	public CompletableFuture<Acknowledge> cancelJob(JobID jobId, Time timeout) {
		CompletableFuture<JobManagerMessages.CancellationResponse> responseFuture = FutureUtils.toJava(
			jobManagerGateway
				.ask(new JobManagerMessages.CancelJob(jobId), FutureUtils.toFiniteDuration(timeout))
				.mapTo(ClassTag$.MODULE$.apply(JobManagerMessages.CancellationResponse.class)));

		return responseFuture.thenApply(
			(JobManagerMessages.CancellationResponse response) -> {
				if (response instanceof JobManagerMessages.CancellationSuccess) {
					return Acknowledge.get();
				} else {
					throw new CompletionException(new FlinkException("Cancel job failed " + jobId + '.', ((JobManagerMessages.CancellationFailure) response).cause()));
				}
			});
	}

	@Override
	public CompletableFuture<Acknowledge> stopJob(JobID jobId, Time timeout) {
		CompletableFuture<JobManagerMessages.StoppingResponse> responseFuture = FutureUtils.toJava(
			jobManagerGateway
				.ask(new JobManagerMessages.StopJob(jobId), FutureUtils.toFiniteDuration(timeout))
				.mapTo(ClassTag$.MODULE$.apply(JobManagerMessages.StoppingResponse.class)));

		return responseFuture.thenApply(
			(JobManagerMessages.StoppingResponse response) -> {
				if (response instanceof JobManagerMessages.StoppingSuccess) {
					return Acknowledge.get();
				} else {
					throw new CompletionException(new FlinkException("Stop job failed " + jobId + '.', ((JobManagerMessages.StoppingFailure) response).cause()));
				}
			});
	}

	//--------------------------------------------------------------------------------
	// JobManager information
	//--------------------------------------------------------------------------------

	@Override
	public CompletableFuture<Optional<Instance>> requestTaskManagerInstance(ResourceID resourceId, Time timeout) {
		return FutureUtils.toJava(
			jobManagerGateway
				.ask(new JobManagerMessages.RequestTaskManagerInstance(resourceId), FutureUtils.toFiniteDuration(timeout))
				.mapTo(ClassTag$.MODULE$.<JobManagerMessages.TaskManagerInstance>apply(JobManagerMessages.TaskManagerInstance.class)))
			.thenApply(
				(JobManagerMessages.TaskManagerInstance taskManagerResponse) -> {
					if (taskManagerResponse.instance().isDefined()) {
						return Optional.of(taskManagerResponse.instance().get());
					} else {
						return Optional.empty();
					}
				});
	}

	@Override
	public CompletableFuture<Collection<Instance>> requestTaskManagerInstances(Time timeout) {
		CompletableFuture<JobManagerMessages.RegisteredTaskManagers> taskManagersFuture = FutureUtils.toJava(
			jobManagerGateway
				.ask(JobManagerMessages.getRequestRegisteredTaskManagers(), FutureUtils.toFiniteDuration(timeout))
				.mapTo(ClassTag$.MODULE$.apply(JobManagerMessages.RegisteredTaskManagers.class)));

		return taskManagersFuture.thenApply(
			JobManagerMessages.RegisteredTaskManagers::asJavaCollection);
	}

	@Override
	public CompletableFuture<Optional<JobManagerMessages.ClassloadingProps>> requestClassloadingProps(JobID jobId, Time timeout) {
		return FutureUtils
			.toJava(jobManagerGateway
				.ask(
					new JobManagerMessages.RequestClassloadingProps(jobId),
					FutureUtils.toFiniteDuration(timeout)))
			.thenApply(
				(Object response) -> {
					if (response instanceof JobManagerMessages.ClassloadingProps) {
						return Optional.of(((JobManagerMessages.ClassloadingProps) response));
					} else if (response instanceof JobManagerMessages.JobNotFound) {
						return Optional.empty();
					} else {
						throw new CompletionException(new FlinkException("Unknown response: " + response + '.'));
					}
				});
	}

	@Override
	public CompletableFuture<MultipleJobsDetails> requestMultipleJobDetails(Time timeout) {
		return FutureUtils.toJava(
			jobManagerGateway
				.ask(new RequestJobDetails(true, true), FutureUtils.toFiniteDuration(timeout))
				.mapTo(ClassTag$.MODULE$.apply(MultipleJobsDetails.class)));
	}

	@Override
	public CompletableFuture<AccessExecutionGraph> requestJob(JobID jobId, Time timeout) {
		CompletableFuture<JobManagerMessages.JobResponse> jobResponseFuture = FutureUtils.toJava(
			jobManagerGateway
				.ask(new JobManagerMessages.RequestJob(jobId), FutureUtils.toFiniteDuration(timeout))
				.mapTo(ClassTag$.MODULE$.apply(JobManagerMessages.JobResponse.class)));

		return jobResponseFuture.thenApply(
			(JobManagerMessages.JobResponse jobResponse) -> {
				if (jobResponse instanceof JobManagerMessages.JobFound) {
					return ((JobManagerMessages.JobFound) jobResponse).executionGraph();
				} else {
					throw new CompletionException(new FlinkJobNotFoundException(jobId));
				}
			});
	}

	@Override
	public CompletableFuture<JobResult> requestJobResult(JobID jobId, Time timeout) {
		return requestJob(jobId, timeout).thenApply(JobResult::createFrom);
	}

	@Override
	public CompletableFuture<ClusterOverview> requestClusterOverview(Time timeout) {
		return FutureUtils.toJava(
			jobManagerGateway
				.ask(RequestStatusOverview.getInstance(), FutureUtils.toFiniteDuration(timeout))
				.mapTo(ClassTag$.MODULE$.apply(ClusterOverview.class)));
	}

	@Override
	public CompletableFuture<Collection<String>> requestMetricQueryServicePaths(Time timeout) {
		final String jobManagerPath = getAddress();
		final String jobManagerMetricQueryServicePath = jobManagerPath.substring(0, jobManagerPath.lastIndexOf('/') + 1) + MetricQueryService.METRIC_QUERY_SERVICE_NAME;

		return CompletableFuture.completedFuture(
			Collections.singleton(jobManagerMetricQueryServicePath));
	}

	@Override
	public CompletableFuture<Collection<Tuple2<ResourceID, String>>> requestTaskManagerMetricQueryServicePaths(Time timeout) {
		return requestTaskManagerInstances(timeout)
			.thenApply(
				(Collection<Instance> instances) ->
					instances
						.stream()
						.map(
							(Instance instance) -> {
								final String taskManagerAddress = instance.getTaskManagerGateway().getAddress();
								final String taskManagerMetricQuerServicePath = taskManagerAddress.substring(0, taskManagerAddress.lastIndexOf('/') + 1) +
									MetricQueryService.METRIC_QUERY_SERVICE_NAME + '_' + instance.getTaskManagerID().getResourceIdString();

								return Tuple2.of(instance.getTaskManagerID(), taskManagerMetricQuerServicePath);
							})
						.collect(Collectors.toList()));
	}

	@Override
	public CompletableFuture<JobIdsWithStatusOverview> requestJobsOverview(Time timeout) {
		return FutureUtils.toJava(
			jobManagerGateway
				.ask(RequestJobsWithIDsOverview.getInstance(), FutureUtils.toFiniteDuration(timeout))
				.mapTo(ClassTag$.MODULE$.apply(JobIdsWithStatusOverview.class)));
	}

	@Override
	public CompletableFuture<String> requestRestAddress(Time timeout) {
		return FutureUtils.toJava(
			jobManagerGateway
				.ask(JobManagerMessages.getRequestRestAddress(), FutureUtils.toFiniteDuration(timeout))
				.mapTo(ClassTag$.MODULE$.apply(String.class)));
	}
}
  • AkkaJobManagerGateway实现了JobManagerGateway接口，其构造器要求传入jobManagerGateway
  • requestBlobServerPort方法传递RequestBlobManagerPort消息；submitJob方法传递SubmitJob消息；cancelJobWithSavepoint方法传递CancelJobWithSavepoint消息；cancelJob方法传递CancelJob消息；stopJob方法传递StopJob消息
  • requestTaskManagerInstance方法传递RequestTaskManagerInstance消息；requestTaskManagerInstances方法传递RequestRegisteredTaskManagers消息；requestClassloadingProps方法传递RequestClassloadingProps消息；requestMultipleJobDetails方法传递RequestJobDetails消息；requestJob方法传递RequestJob消息；requestClusterOverview方法传递RequestStatusOverview消息；requestJobsOverview方法传递RequestJobsWithIDsOverview消息；requestRestAddress方法传递RequestRestAddress消息

小结

  • RestfulGateway接口继承了RpcGateway接口，它定义了cancelJob、stopJob、requestRestAddress、requestJob、requestJobResult、requestMultipleJobDetails、requestClusterOverview、requestMetricQueryServicePaths、requestTaskManagerMetricQueryServicePaths方法；另外提供了triggerSavepoint、disposeSavepoint、requestJobStatus、requestOperatorBackPressureStats、rescaleJob、shutDownCluster这几个默认方法，其实现均抛出UnsupportedOperationException异常
  • JobManagerGateway接口继承了RestfulGateway接口，它定义了requestBlobServerPort、submitJob、cancelJobWithSavepoint、cancelJob、stopJob、requestClassloadingProps、requestTaskManagerInstance、requestTaskManagerInstances、requestJobsOverview方法；它有一个实现类是AkkaJobManagerGateway
  • AkkaJobManagerGateway实现了JobManagerGateway接口，其构造器要求传入jobManagerGateway；其大部分方法的实现均通过jobManagerGateway来传递消息，其中大量使用了JobManagerMessages里头定义的消息对象

doc

转载于:https://my.oschina.net/go4it/blog/3023760

weixin_34253539
关注
一文聊透 Flink 的 Temporal Join
Laurence的技术博客
03-25 2119
Flink的Temporal Join以及Temporal Table （时态表）关系密切，在知识结构上有点混乱，可能是历史原因造成的。本文希望把所有与 Temporal Join 相关的概念进行一次统一梳理，用更规范的知识结构把 Flink 的 Temporal Join 介绍清楚，包括：以 Temporal Table DDL 方式实现基于事件时间的 Temporal Join;以 Temporal Table DDL 方式实现基于处理时间的 Temporal Join;以 Temporal Table
聊一聊Flink的监控和预警
03-31 2231
在实际的Flink 项目中，如何观察Flink的性能，如何监控Flink的运行状态，如何设置报警策略？下面简单讲下我的经验吧。 一、Flink webUI 首先聊下Flink webUI。如下图所示: 如果是本地调试模式，默认是不开启webui的。 StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); 上面的初始化方式，本地调试默认不开启webui。 StreamExe
job manager
06-19
job management system job management system job management system job management systemjob management systemjob management systemjob management systemjob management system
flink-sql-gateway
03-21
Flink SQL网关 Flink SQL网关是一项服务，允许其他应用程序通过REST API轻松与Flink群集进行交互。 用户应用程序（例如Java / Python / Shell程序，Postman）可以使用REST API提交查询，取消作业，检索结果等。 使JDBC客户端可以基于REST API连接到Flink SQL网关。 当前，REST API是一组内部API，我们建议用户通过JDBC API与网关进行交互。 Flink SQL网关现在将会话属性存储在内存中。如果服务停止或崩溃，则所有属性都将丢失。我们将在未来对此进行改进。 该项目尚处于初期阶段。如果您遇到任何问题或有任何建议，请随时提出问题。 启动网关服务 从头开始启动服务有四个步骤： 下载（或构建）Flink程序包。 Flink SQL网关当前仅支持Apache Flink 1.10，您可以从下载Flink 1.10。
Flink系列之：Flink SQL Gateway
最新发布
zhengzaifeidelushang的博客
03-25 2160
SQL Gateway 捆绑在常规 Flink 发行版中，因此可以开箱即用。它只需要一个正在运行的Flink集群，可以在其中执行表程序。根据端点的类型，用户可以使用不同的实用程序进行连接。凭借灵活的架构，用户可以通过调用来启动具有指定端点的SQL Gateway。注意：如果 Flink 配置文件中还包含 sql-gateway.endpoint.type 选项，则 CLI 命令具有更高的优先级。返回结果中的operationHandle用于SQL Gateway唯一标识提交的SQL。第 3 步：获取结果。
Flink 中JobManager和TaskManager
qq_41982570的博客
04-29 6143
Flink 中JobManager和TaskManager
flink mysql sink_聊聊flink的sink
weixin_35492602的博客
02-23 1431
概述flink的sink是flink三大逻辑结构之一(source，transform，sink),功能就是负责把flink处理后的数据输出到外部系统中，flink 的sink和source的代码结构类似。在编写代码的过程中，我们可以使用flink已经提供的sink，如kafka，jdbc,es等，当然我们也可以通过自定义的方式，来实现我们自己的sink。下面说明核心类核心类SinkFunctio...
聊一聊Flink 写 Hive 的小文件问题
03-12 4894
Flink 1.11 引入了写Hive的功能后，已经在上线了一段时间。下面就聊聊我自己对Flink 写Hive 小文件的一些问题和看法。 问题1： 1.Flink 写 Hive 可能会产生小文件吗？ 简单的说，答案是会。 简单总结下Flink 读kafka写Hive的流程 1.Flink 将kafka数据根据设置的分区策略，实时写入对应分区hdfs 目录的临时文件 inprogress，如下图所示。 在inprogress文件的数据，通过hive是无法查询到的。 2.打checkp..
【深入浅出flink】第10篇：聊聊flink窗口计算的触发器（Trigger）
雷恩Layne
01-17 7147
Trigger（触发器）决定了什么时候窗口准备就绪了，一旦窗口准备就绪就可以使用WindowFunction（窗口计算操作）进行计算。每一个 WindowAssigner（窗口分配器） 都会有一个默认的Trigger。如果默认的Trigger不满足用户的需求，用户可以自定义Trigger。
JobManager-开源
05-09
这是任务管理软件，适用于想要记录，提醒和监视任何任务/工作/项目的人员。 它提供了将任务分解为越来越小的任务的功能。 所有版本均附带netbeans项目和图形文件。
Gateway for flinksql
lodaner的博客
03-25 324
Gateway for flinksql 简介 github: flink-sql-gateway Flink SQL gateway is a service that allows other applications to easily interact with a Flink cluster through a REST API. User applications (e.g. Java/Python/Shell program, Postman) can use the REST API to
JobManager--启动
sugar-foxs
02-25 2770
JobManager启动 JobManager里有个main方法,通过脚本启动，主要做的工作如下： 首先做一些检查，加载日志环境和配置 启动jobManager try { SecurityUtils.getInstalledContext.runSecured(new Callable[Unit] { override def call(): Unit = { ...
Flink运行时之TaskManager执行Task
VinoYang的专栏
01-24 9567
TaskManager执行任务当一个任务被JobManager部署到TaskManager之后，它将会被执行。本篇我们将分析任务的执行细节。
flink sql gateway初探
不爱学习的小妞博客
12-07 1527
flink 1.16版本中发布了一个新功能–SQL gateway，本篇文章就来实践测试下该功能。
Flink GateWay、HiveServer2 和 hive on spark
weixin_51981189的博客
03-21 1123
bin/hive , 就是Hive Shell的客户端 , 直接写SQLHiveServer2是Hive的一个服务组件，它提供了一个多客户端访问的接口，允许用户通过多种方式 (如JDBC、ODBC等) 连接Hive，并执行HiveQL语句。HiveServer2可以独立于Hive运行，并且可以与其他应用程序进行集成，使得用户可以更加灵活地使用Hive.1.支持多客户端连接HiveServer2可以同时处理多个客户端的连接请求，每个客户端可以独立地执行HiveQL语句。
Flink JobManger、TaskManger、TaskSlots、Client作用
热门推荐
胖虎儿的博客
05-17 1万+
JobManager、TaskManager、taskSlot你真的了解吗？我且问你，我如果设置并行度为2，我需要多少个taskManger、taskSlot？
flink1.16 系统集成了 sql gateway 功能
celltobig的专栏
02-20 734
# flink1.16 系统集成了 sql gateway 功能，其中包括两种方式，1. rest 2.hiveserver2 # 测试 read write. hive iceberg 都可以
Flink SQL Gateway使用
aciddzz的博客
01-30 4263
注：本文主要介绍Flink SQL Gateway on Yarn Session & on Yarn per Job 两种模式下的使用 一：Flink SQL Gateway on Yarn Session 1.1 下载Flink版本环境包，注意SQL Gateway目前仅支持Flink 1.10 & 1.11.1+版本 1.1 启动一个yarn session cluster， #!/bin/bash export HADOOP_CONF_DIR=/data/hadoop_conf .
聊聊flink的ParameterTool
06-10
Flink的ParameterTool是一个工具类，用于从命令行或者属性文件中读取参数配置，方便地将参数传递给Flink程序。ParameterTool可以读取key-value形式的参数，支持从命令行或者属性文件中读取，支持默认值设置，提供了一些方便的方法来获取参数值，如getInt、getLong、getFloat、getBoolean等。 使用ParameterTool可以方便地将参数传递给Flink程序，从而灵活地配置程序的运行参数。例如，可以在命令行中指定程序所需的资源，或者在属性文件中指定程序的配置参数。在Flink程序中，可以通过ParameterTool来获取这些参数，从而更加灵活地控制程序的行为。 需要注意的是，ParameterTool是不可变的，一旦创建就不能修改，因此在使用ParameterTool时需要注意参数的获取顺序，以免获取到错误的参数值。同时，ParameterTool也不是线程安全的，在多线程环境下需要进行同步处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值