import org.springframework.boot.loader.tools.LibraryScope; //导入依赖的package包/类
@Override
public void doWithLibraries(LibraryCallback callback) throws IOException {
	Set<GradleLibrary> custom = getLibraries(this.customConfigurationName,
			LibraryScope.CUSTOM);
	if (custom != null) {
		libraries(custom, callback);
	}
	else {
		Set<GradleLibrary> runtime = getLibraries("runtime", LibraryScope.RUNTIME);
		Set<GradleLibrary> provided = getLibraries(this.providedConfigurationName,
				LibraryScope.PROVIDED);
		if (provided != null) {
			runtime = minus(runtime, provided);
		}
		libraries(runtime, callback);
		libraries(provided, callback);
	}
}
 

import org.springframework.boot.loader.tools.LibraryScope; //导入依赖的package包/类
private Set<GradleLibrary> getLibrariesForFileDependencies(
		Configuration configuration, LibraryScope scope) {
	Set<GradleLibrary> libraries = new LinkedHashSet<GradleLibrary>();
	for (Dependency dependency : configuration.getIncoming().getDependencies()) {
		if (dependency instanceof FileCollectionDependency) {
			FileCollectionDependency fileDependency = (FileCollectionDependency) dependency;
			for (File file : fileDependency.resolve()) {
				libraries.add(
						new GradleLibrary(fileDependency.getGroup(), file, scope));
			}
		}
		else if (dependency instanceof ProjectDependency) {
			ProjectDependency projectDependency = (ProjectDependency) dependency;
			libraries.addAll(getLibrariesForFileDependencies(
					projectDependency.getProjectConfiguration(), scope));
		}
	}
	return libraries;
}
 

import org.springframework.boot.loader.tools.LibraryScope; //导入依赖的package包/类
@Override
public void doWithLibraries(LibraryCallback callback) throws IOException {
	Set<String> duplicates = getDuplicates(this.artifacts);
	for (Artifact artifact : this.artifacts) {
		LibraryScope scope = SCOPES.get(artifact.getScope());
		if (scope != null && artifact.getFile() != null) {
			String name = artifact.getFile().getName();
			if (duplicates.contains(name)) {
				this.log.debug("Duplicate found: " + name);
				name = artifact.getGroupId() + "-" + name;
				this.log.debug("Renamed to: " + name);
			}
			callback.library(new Library(name, artifact.getFile(), scope,
					isUnpackRequired(artifact)));
		}
	}
}
 

import org.springframework.boot.loader.tools.LibraryScope; //导入依赖的package包/类
protected void bootRepackage(final IPackageFragmentRoot[] roots, File packagedFile) throws CoreException {
	Repackager bootRepackager = new Repackager(packagedFile);
	try {
		bootRepackager.repackage(new Libraries() {

			public void doWithLibraries(LibraryCallback callBack) throws IOException {
				for (IPackageFragmentRoot root : roots) {

					if (root.isArchive()) {

						File rootFile = new File(root.getPath().toOSString());
						if (rootFile.exists()) {
							callBack.library(new Library(rootFile, LibraryScope.COMPILE));
						}
					}
				}
			}
		});
	} catch (IOException e) {
		errorHandler.handleApplicationDeploymentFailure(
				NLS.bind(Messages.JavaCloudFoundryArchiver_ERROR_REPACKAGE_SPRING, e.getMessage()));
	}
}
 

import org.springframework.boot.loader.tools.LibraryScope; //导入依赖的package包/类
@Override
public void doWithLibraries(LibraryCallback callback) throws IOException {
	Set<GradleLibrary> custom = getLibraries(this.customConfigurationName,
			LibraryScope.CUSTOM);
	if (custom != null) {
		libraries(custom, callback);
	}
	else {
		Set<GradleLibrary> compile = getLibraries("compile", LibraryScope.COMPILE);
		Set<GradleLibrary> runtime = getLibraries("runtime", LibraryScope.RUNTIME);
		runtime = minus(runtime, compile);
		Set<GradleLibrary> provided = getLibraries(this.providedConfigurationName,
				LibraryScope.PROVIDED);
		if (provided != null) {
			compile = minus(compile, provided);
			runtime = minus(runtime, provided);
		}
		libraries(compile, callback);
		libraries(runtime, callback);
		libraries(provided, callback);
	}
}
 

import org.springframework.boot.loader.tools.LibraryScope; //导入依赖的package包/类
@Override
public Layout getLayout(File file) {
    return new Layout() {
        @Override
        public String getLauncherClassName() {
            return null;
        }

        @Override
        public String getLibraryDestination(String libraryName, LibraryScope scope) {
            if (LIB_DESTINATION_SCOPES.contains(scope)) {
                return "lib/";
            }

            return null;
        }

        @Override
        public String getClassesLocation() {
            return null;
        }

        @Override
        public boolean isExecutable() {
            return false;
        }
    };
}
 

import org.springframework.boot.loader.tools.LibraryScope; //导入依赖的package包/类
@Override
protected LibraryScope getLibraryScope(File file) {
	String fileName = file.getName();
	if (fileName.contains("tomcat-embed")
			|| fileName.contains("spring-boot-starter-tomcat")) {
		return LibraryScope.PROVIDED;
	}
	return LibraryScope.COMPILE;
}
 

import org.springframework.boot.loader.tools.LibraryScope; //导入依赖的package包/类
private List<Library> addClasspathEntries(JarWriter writer,
		List<MatchedResource> entries) throws IOException {
	List<Library> libraries = new ArrayList<Library>();
	for (MatchedResource entry : entries) {
		if (entry.isRoot()) {
			libraries.add(new Library(entry.getFile(), LibraryScope.COMPILE));
		}
		else {
			writer.writeEntry(entry.getName(),
					new FileInputStream(entry.getFile()));
		}
	}
	return libraries;
}
 

import org.springframework.boot.loader.tools.LibraryScope; //导入依赖的package包/类
private Set<GradleLibrary> getLibraries(String configurationName,
		LibraryScope scope) {
	Configuration configuration = (configurationName == null ? null
			: this.project.getConfigurations().findByName(configurationName));
	if (configuration == null) {
		return null;
	}
	Set<GradleLibrary> libraries = new LinkedHashSet<GradleLibrary>();
	for (ResolvedArtifact artifact : configuration.getResolvedConfiguration()
			.getResolvedArtifacts()) {
		libraries.add(new ResolvedArtifactLibrary(artifact, scope));
	}
	libraries.addAll(getLibrariesForFileDependencies(configuration, scope));
	return libraries;
}
 

import org.springframework.boot.loader.tools.LibraryScope; //导入依赖的package包/类
@Override
protected LibraryScope getLibraryScope(File file) {
	return LibraryScope.COMPILE;
}
 

import org.springframework.boot.loader.tools.LibraryScope; //导入依赖的package包/类
GradleLibrary(String group, File file, LibraryScope scope) {
	super(file, scope);
	this.group = group;
}
 

import org.springframework.boot.loader.tools.LibraryScope; //导入依赖的package包/类
ResolvedArtifactLibrary(ResolvedArtifact artifact, LibraryScope scope) {
	super(artifact.getModuleVersion().getId().getGroup(), artifact.getFile(),
			scope);
	this.artifact = artifact;
}
 

import org.springframework.boot.loader.tools.LibraryScope; //导入依赖的package包/类
protected abstract LibraryScope getLibraryScope(File file);