import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
public AboutController(StreamDeployer streamDeployer, TaskLauncher taskLauncher, FeaturesProperties featuresProperties,
		VersionInfoProperties versionInfoProperties, SecurityStateBean securityStateBean) {
	this.streamDeployer = streamDeployer;
	this.taskLauncher = taskLauncher;
	this.featuresProperties = featuresProperties;
	this.versionInfoProperties = versionInfoProperties;
	this.securityStateBean = securityStateBean;
}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
/**
 * Initializes the {@link DefaultTaskService}.
 *
 * @param dataSourceProperties the data source properties.
 * @param taskDefinitionRepository the {@link TaskDefinitionRepository} this service will
 * use for task CRUD operations.
 * @param taskExecutionRepository the repository this service will use for deployment IDs.
 * @param taskExplorer the explorer this service will use to lookup task executions
 * @param registry URI registry this service will use to look up app URIs.
 * @param resourceLoader the {@link ResourceLoader} that will resolve URIs to
 * {@link Resource}s.
 * @param taskLauncher the launcher this service will use to launch task apps.
 * @param metaDataResolver the metadata resolver
 * @param taskConfigurationProperties the properties used to define the behavior of tasks
 * @param deploymentIdRepository the repository that maps deployment keys to IDs
 * @param dataflowServerUri the data flow server URI
 */
public DefaultTaskService(DataSourceProperties dataSourceProperties,
		TaskDefinitionRepository taskDefinitionRepository, TaskExplorer taskExplorer,
		TaskRepository taskExecutionRepository, AppRegistryCommon registry, ResourceLoader resourceLoader,
		TaskLauncher taskLauncher, ApplicationConfigurationMetadataResolver metaDataResolver,
		TaskConfigurationProperties taskConfigurationProperties, DeploymentIdRepository deploymentIdRepository,
		String dataflowServerUri) {
	Assert.notNull(dataSourceProperties, "DataSourceProperties must not be null");
	Assert.notNull(taskDefinitionRepository, "TaskDefinitionRepository must not be null");
	Assert.notNull(taskExecutionRepository, "TaskExecutionRepository must not be null");
	Assert.notNull(taskExplorer, "TaskExplorer must not be null");
	Assert.notNull(registry, "UriRegistry must not be null");
	Assert.notNull(resourceLoader, "ResourceLoader must not be null");
	Assert.notNull(taskLauncher, "TaskLauncher must not be null");
	Assert.notNull(metaDataResolver, "metaDataResolver must not be null");
	Assert.notNull(taskConfigurationProperties, "taskConfigurationProperties must not be null");
	Assert.notNull(deploymentIdRepository, "deploymentIdRepository must not be null");
	this.dataSourceProperties = dataSourceProperties;
	this.taskDefinitionRepository = taskDefinitionRepository;
	this.taskExecutionRepository = taskExecutionRepository;
	this.taskExplorer = taskExplorer;
	this.registry = registry;
	this.taskLauncher = taskLauncher;
	this.resourceLoader = resourceLoader;
	this.whitelistProperties = new WhitelistProperties(metaDataResolver);
	this.taskConfigurationProperties = taskConfigurationProperties;
	this.deploymentIdRepository = deploymentIdRepository;
	this.dataflowServerUri = dataflowServerUri;
}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
@Bean
@ConditionalOnBean(TaskDefinitionRepository.class)
public TaskService taskService(TaskDefinitionRepository repository, TaskExplorer taskExplorer,
		TaskRepository taskExecutionRepository, AppRegistryCommon registry, DelegatingResourceLoader resourceLoader,
		TaskLauncher taskLauncher, ApplicationConfigurationMetadataResolver metadataResolver,
		TaskConfigurationProperties taskConfigurationProperties, DeploymentIdRepository deploymentIdRepository) {
	return new DefaultTaskService(dataSourceProperties, repository, taskExplorer, taskExecutionRepository, registry,
			resourceLoader, taskLauncher, metadataResolver, taskConfigurationProperties, deploymentIdRepository,
			this.dataflowServerUri);
}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
@Bean
@ConditionalOnBean(TaskDefinitionRepository.class)
public TaskDefinitionController taskDefinitionController(TaskDefinitionRepository repository,
		DeploymentIdRepository deploymentIdRepository, TaskLauncher taskLauncher, AppRegistryCommon appRegistry,
		TaskService taskService) {
	return new TaskDefinitionController(repository, deploymentIdRepository, taskLauncher, appRegistry,
			taskService);
}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
@Bean
public AboutController aboutController(ObjectProvider<StreamDeployer> streamDeployer, TaskLauncher taskLauncher,
		FeaturesProperties featuresProperties, VersionInfoProperties versionInfoProperties,
		SecurityStateBean securityStateBean) {
	return new AboutController(streamDeployer.getIfAvailable(), taskLauncher, featuresProperties, versionInfoProperties,
			securityStateBean);
}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
@Bean
public AboutController aboutController(VersionInfoProperties versionInfoProperties, FeaturesProperties featuresProperties) {
	StreamDeployer streamDeployer = mock(StreamDeployer.class);
	TaskLauncher taskLauncher = mock(TaskLauncher.class);
	RuntimeEnvironmentInfo.Builder builder = new RuntimeEnvironmentInfo.Builder();
	RuntimeEnvironmentInfo appDeployerEnvInfo = builder.implementationName("testAppDepImplementationName").
			implementationVersion("testAppDepImplementationVersion").
			platformType("testAppDepPlatformType").
			platformApiVersion("testAppDepPlatformApiVersion").
			platformClientVersion("testAppDepPlatformClientVersion").spiClass(Class.class).
			platformHostVersion("testAppDepPlatformHostVersion").build();
	RuntimeEnvironmentInfo taskDeployerEnvInfo = builder.implementationName("testTaskDepImplementationName").
			implementationVersion("testTaskDepImplementationVersion").
			platformType("testTaskDepPlatformType").
			platformApiVersion("testTaskDepPlatformApiVersion").
			platformClientVersion("testTaskDepPlatformClientVersion").spiClass(Class.class).
			platformHostVersion("testTaskDepPlatformHostVersion").build();
	if (!featuresProperties.isSkipperEnabled()) {
		when(streamDeployer.environmentInfo()).thenReturn(appDeployerEnvInfo);
	}
	else {
		when(streamDeployer.environmentInfo()).thenThrow(new UnsupportedOperationException());
	}
	when(taskLauncher.environmentInfo()).thenReturn(taskDeployerEnvInfo);
	return new AboutController(streamDeployer, taskLauncher,
			mock(FeaturesProperties.class), versionInfoProperties,
			mock(SecurityStateBean.class));
}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
@Bean
public DefaultTaskService defaultTaskService(TaskDefinitionRepository taskDefinitionRepository, TaskExplorer taskExplorer,
		TaskRepository taskExecutionRepository, AppRegistry appRegistry,
		ResourceLoader resourceLoader, TaskLauncher taskLauncher,
		ApplicationConfigurationMetadataResolver metadataResolver) {
	return new DefaultTaskService(dataSourceProperties, taskDefinitionRepository, taskExplorer,
			taskExecutionRepository, appRegistry, resourceLoader, taskLauncher, metadataResolver,
			new TaskConfigurationProperties(), new InMemoryDeploymentIdRepository(), null);

}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
@Bean
public TaskService taskService(TaskDefinitionRepository repository, TaskExplorer explorer, AppRegistry registry,
		ResourceLoader resourceLoader, TaskLauncher taskLauncher,
		ApplicationConfigurationMetadataResolver metadataResolver, DeploymentIdRepository deploymentIdRepository) {
	return new DefaultTaskService(new DataSourceProperties(), repository, explorer, taskRepository(), registry,
			resourceLoader, taskLauncher, metadataResolver, new TaskConfigurationProperties(),
			deploymentIdRepository, null);
}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
@Test
public void testLaunch() throws IOException {
	assertNotNull(this.sink.input());

	TaskLauncher testTaskLauncher =
			 context.getBean(TaskLauncher.class);

	Map<String, String> properties = new HashMap();
	properties.put("server.port", "0");
	TaskLaunchRequest request = new TaskLaunchRequest(
			"maven://org.springframework.cloud.task.app:"
			+ "timestamp-task:jar:1.0.1.RELEASE", null, properties,
			null, null);
	GenericMessage<TaskLaunchRequest> message = new GenericMessage<TaskLaunchRequest>(request);
	this.sink.input().send(message);

	ArgumentCaptor<AppDeploymentRequest> deploymentRequest = ArgumentCaptor.forClass(AppDeploymentRequest.class);

	verify(testTaskLauncher).launch(deploymentRequest.capture());

	AppDeploymentRequest actualRequest = deploymentRequest.getValue();

	assertTrue(actualRequest.getCommandlineArguments().isEmpty());
	assertEquals("0", actualRequest.getDefinition().getProperties().get("server.port"));
	assertTrue(actualRequest.getResource().toString()
			.contains("maven://org.springframework.cloud.task.app:timestamp-task:jar:1.0.1.RELEASE"));
}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
@Bean
public TaskLauncher taskLauncher() {
	LocalDeployerProperties props = new LocalDeployerProperties();
	props.setDeleteFilesOnExit(false);

	return new LocalTaskLauncher(props);
}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
public DeployerPartitionHandler(TaskLauncher taskLauncher,
		JobExplorer jobExplorer,
		Resource resource,
		String stepName) {
	Assert.notNull(taskLauncher, "A taskLauncher is required");
	Assert.notNull(jobExplorer, "A jobExplorer is required");
	Assert.notNull(resource, "A resource is required");
	Assert.hasText(stepName, "A step name is required");

	this.taskLauncher = taskLauncher;
	this.jobExplorer = jobExplorer;
	this.resource = resource;
	this.stepName = stepName;
}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
private void validateConstructorValidation(TaskLauncher taskLauncher, JobExplorer jobExplorer, Resource resource, String stepName, String expectedMessage) {
	try {
		new DeployerPartitionHandler(taskLauncher, jobExplorer, resource, stepName);
	}
	catch (IllegalArgumentException iae) {
		assertEquals(expectedMessage, iae.getMessage());
	}
}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
@Bean
public TaskLauncher taskLauncher() {
	return mock(TaskLauncher.class);
}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
@Override
public RuntimeEnvironmentInfo environmentInfo() {
	return super.createRuntimeEnvironmentInfo(TaskLauncher.class, this.getClass());
}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
@Bean
public TaskLauncher taskDeployer(KubernetesClient kubernetesClient,
                                 ContainerFactory containerFactory) {
	return new KubernetesTaskLauncher(properties, kubernetesClient, containerFactory);
}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
@Override
protected TaskLauncher provideTaskLauncher() {
	return taskLauncher;
}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
public TaskLauncherWrapper(TaskLauncher wrapped) {
	this.wrapped = wrapped;
}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
@Bean
@RefreshScope
public TaskLauncher taskDeployer(ChronosTaskLauncherProperties chronosProperties, Chronos chronos) {
	return new ChronosTaskLauncher(chronosProperties, chronos);
}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
@Bean
public TaskLauncher taskLauncher() {
	return new TestTaskLauncher();
}
 

import org.springframework.cloud.deployer.spi.task.TaskLauncher; //导入依赖的package包/类
@Bean
TaskLauncher taskLauncher() {
	return 	mock(TaskLauncher.class);

}