import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
public ModuleService(SpinnakerConfiguration spinnakerConfiguration,
					 CloudFoundryAppDeployerFactory appDeployerFactory,
					 ResourcePatternResolver ctx,
					 CounterService counterService,
					 TempFileManager fileManager,
					 MavenProperties mavenProperties,
					 ResourceLoader resourceLoader) {

	this.spinnakerConfiguration = spinnakerConfiguration;
	this.appDeployerFactory = appDeployerFactory;
	this.ctx = ctx;
	this.counterService = counterService;
	this.fileManager = fileManager;
	this.mavenProperties = mavenProperties;
	this.resourceLoader = resourceLoader;
}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
@Bean
public LRUCleaningResourceLoaderBeanPostProcessor lruCleaningResourceLoaderBeanPostProcessor(
		SkipperServerProperties skipperServerProperties, MavenProperties mavenProperties) {
	return new LRUCleaningResourceLoaderBeanPostProcessor(
			skipperServerProperties.getFreeDiskSpacePercentage() / 100F,
			new File(mavenProperties.getLocalRepository()));
}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
@Bean
public ResourceLoader resourceLoader() {
	MavenProperties mavenProperties = new MavenProperties();
	mavenProperties.setRemoteRepositories(new HashMap<>(Collections.singletonMap("springRepo",
			new MavenProperties.RemoteRepository("https://repo.spring.io/libs-snapshot"))));

	Map<String, ResourceLoader> resourceLoaders = new HashMap<>();
	resourceLoaders.put("maven", new MavenResourceLoader(mavenProperties));
	resourceLoaders.put("file", new FileSystemResourceLoader());

	DelegatingResourceLoader delegatingResourceLoader = new DelegatingResourceLoader(resourceLoaders);
	return delegatingResourceLoader;
}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
@Bean
ModuleService moduleService(SpinnakerConfiguration spinnakerConfiguration,
							CloudFoundryAppDeployerFactory appDeployerFactoryBean,
							ApplicationContext ctx,
							CounterService counterService,
							TempFileManager fileManager,
							MavenProperties mavenProperties,
							LRUCleaningResourceLoader resourceLoader) {
	return new ModuleService(spinnakerConfiguration, appDeployerFactoryBean, ctx, counterService, fileManager, mavenProperties, resourceLoader);
}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
@Bean
LRUCleaningResourceLoader lruCleaningResourceLoader(MavenResourceLoader resourceLoader,
													CloudFoundryServerConfigurationProperties serverConfigurationProperties,
													MavenProperties mavenProperties) {
	float fRatio = serverConfigurationProperties.getFreeDiskSpacePercentage() / 100F;
	File repositoryCache = new File(mavenProperties.getLocalRepository());
	repositoryCache.deleteOnExit();
	return new LRUCleaningResourceLoader(resourceLoader, fRatio, repositoryCache);
}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
@Bean
MavenProperties mavenProperties() {

	MavenProperties properties = new MavenProperties();
	properties.getRemoteRepositories().put("jcenter", new MavenProperties.RemoteRepository("http://jcenter.bintray.com/"));
	properties.getRemoteRepositories().put("spring-snapshots", new MavenProperties.RemoteRepository("http://repo.spring.io/snapshot"));
	properties.getRemoteRepositories().put("spring-milestones", new MavenProperties.RemoteRepository("http://repo.spring.io/milestone"));
	properties.getRemoteRepositories().put("spring-releases", new MavenProperties.RemoteRepository("http://repo.spring.io/release"));
	return properties;
}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
@Bean
ModuleService moduleService(SpinnakerConfiguration spinnakerConfiguration,
							CloudFoundryAppDeployerFactory appDeployerFactoryBean,
							ApplicationContext ctx,
							CounterService counterService,
							TempFileManager fileManager,
							MavenProperties mavenProperties,
							LRUCleaningResourceLoader resourceLoader) {
	return new ModuleService(spinnakerConfiguration, appDeployerFactoryBean, mockPatternResolver(ctx), counterService, fileManager, mavenProperties, resourceLoader);
}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
@Bean
		MavenProperties mavenProperties() throws IOException {

			MavenProperties properties = new MavenProperties();
			Path tempDirectory = Files.createTempDirectory("spring-cloud-spinnaker-tests-");
			tempDirectory.toFile().deleteOnExit();
			properties.setLocalRepository(tempDirectory.toString());
			properties.getRemoteRepositories().put("spring-snapshots", new MavenProperties.RemoteRepository("http://repo.spring.io/snapshot"));
			properties.getRemoteRepositories().put("spring-milestones", new MavenProperties.RemoteRepository("http://repo.spring.io/milestone"));
//			properties.getRemoteRepositories().put("spring-releases", new MavenProperties.RemoteRepository("http://repo.spring.io/release"));
			return properties;
		}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
/**
 * Retrieve the corresponding {@link Resource} instance based on the URI String.
 * Maven properties are used if the URI corresponds to maven resource.
 *
 * @param uriString String representation of the resource URI
 * @param mavenProperties the maven properties to use in case of maven resource
 * @return the resource instance
 */
public static Resource getResource(String uriString, MavenProperties mavenProperties) {
	Assert.isTrue(StringUtils.hasText(uriString), "Resource URI must not be empty");
	try {
		URI uri = new URI(uriString);
		String scheme = uri.getScheme();
		Assert.notNull(scheme, "a scheme (prefix) is required");
		if (scheme.equals("maven")) {
			String coordinates = uriString.replaceFirst("maven:\\/*", "");
			MavenResource mavenResource = MavenResource.parse(coordinates, mavenProperties);
			return mavenResource;
		}
		else if (scheme.equals("docker")) {
			String dockerUri = uriString.replaceFirst("docker:\\/*", "");
			return new DockerResource(dockerUri);
		}
		else {
			ResourceLoader resourceLoader = null;
			if (!scheme.equalsIgnoreCase("http") && !scheme.equalsIgnoreCase("https")) {
				resourceLoader = new DefaultResourceLoader();
			}
			else {
				resourceLoader = new DownloadingUrlResourceLoader();
			}
			return resourceLoader.getResource(uriString);
		}
	}
	catch (URISyntaxException e) {
		throw new RuntimeException(e);
	}
}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
public DefaultAppRegistryService(AppRegistrationRepository appRegistrationRepository,
		ResourceLoader resourceLoader, MavenProperties mavenProperties) {
	super(resourceLoader, mavenProperties);
	Assert.notNull(appRegistrationRepository, "'appRegistrationRepository' must not be null");
	Assert.notNull(resourceLoader, "'resourceLoader' must not be null");
	this.appRegistrationRepository = appRegistrationRepository;
}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
public VersionedAppRegistryController(AppRegistryService appRegistryService,
		ApplicationConfigurationMetadataResolver metadataResolver,
		ForkJoinPool forkJoinPool, MavenProperties mavenProperties) {
	this.appRegistryService = appRegistryService;
	this.metadataResolver = metadataResolver;
	this.forkJoinPool = forkJoinPool;
	this.mavenProperties = mavenProperties;
}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
@Bean
public DelegatingResourceLoader resourceLoader(MavenProperties mavenProperties) {
	Map<String, ResourceLoader> resourceLoaders = new HashMap<>();
	resourceLoaders.put("maven", new MavenResourceLoader(mavenProperties));
	resourceLoaders.put("file", new FileSystemResourceLoader());

	DelegatingResourceLoader delegatingResourceLoader = new DelegatingResourceLoader(resourceLoaders);
	return delegatingResourceLoader;
}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
@Bean
public DelegatingResourceLoader delegatingResourceLoader(MavenProperties mavenProperties) {
	DockerResourceLoader dockerLoader = new DockerResourceLoader();
	MavenResourceLoader mavenResourceLoader = new MavenResourceLoader(mavenProperties);
	Map<String, ResourceLoader> loaders = new HashMap<>();
	loaders.put("docker", dockerLoader);
	loaders.put("maven", mavenResourceLoader);
	return new DelegatingResourceLoader(loaders);
}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
@Bean
public LRUCleaningResourceLoaderBeanPostProcessor lruCleaningResourceLoaderInstaller(
		LocalDeployerProperties localDeployerProperties,
		MavenProperties mavenProperties) {
	File repositoryCache = new File(mavenProperties.getLocalRepository());
	float fRatio = localDeployerProperties.getFreeDiskSpacePercentage() / 100F;
	return new LRUCleaningResourceLoaderBeanPostProcessor(fRatio, repositoryCache);
}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
@Test
public void testTaskLauncher() {
	MavenResourceLoader mavenResourceLoader =
			context.getBean(MavenResourceLoader.class);
	assertNotNull(mavenResourceLoader);

	DelegatingResourceLoader delegatingResourceLoader =
			context.getBean(DelegatingResourceLoader.class);
	assertNotNull(delegatingResourceLoader);

	MavenProperties mavenProperties =
			context.getBean(MavenProperties.class);
	assertNotNull(mavenProperties);
}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
@Bean
public MavenResourceLoader mavenResourceLoader(MavenProperties properties) {
	return new MavenResourceLoader(properties);
}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
@Bean
public MavenProperties mavenProperties() {
	return new MavenConfigurationProperties();
}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
@Bean
MavenResourceLoader mavenResourceLoader(MavenProperties mavenProperties) {
	return new MavenResourceLoader(mavenProperties);
}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
@Bean
@ConfigurationProperties("maven")
public MavenProperties mavenProperties() {
	return new MavenProperties();
}
 

import org.springframework.cloud.deployer.resource.maven.MavenProperties; //导入依赖的package包/类
public AbstractAppRegistryCommon(ResourceLoader resourceLoader, MavenProperties mavenProperties) {
	this.resourceLoader = resourceLoader;
	this.mavenProperties = mavenProperties;
}