import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
private Set<String> getBundleDependencies(Configuration compileClasspath,
                                          Set<? extends DependencyResult> bundleDependencies) {
    Set<String> bundleSets = new HashSet<>();
    for (DependencyResult dependencyResult : bundleDependencies) {
        bundleSets.add(dependencyResult.toString());
    }
    for (Dependency dependency : compileClasspath.getAllDependencies()) {
        if (dependency instanceof DefaultExternalModuleDependency) {
            DefaultExternalModuleDependency externalModuleDependency = (DefaultExternalModuleDependency)dependency;
            if (!((DefaultExternalModuleDependency)dependency).getArtifacts().isEmpty()) {
                if (StringUtils.equalsIgnoreCase("awb", ((DefaultExternalModuleDependency)dependency).getArtifacts()
                    .iterator().next().getType())) {
                    bundleSets.add(
                        dependency.getGroup() + ":" + dependency.getName() + ":" + dependency.getVersion());
                }
            }
        }
    }
    return bundleSets;
}
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
private ClassPath resolvePluginDependencies(final PluginUseMetaData metadata) {
    DependencyResolutionServices resolution = dependencyResolutionServicesFactory.create();

    RepositoryHandler repositories = resolution.getResolveRepositoryHandler();
    final String repoUrl = metadata.implementation.get("repo");
    repositories.maven(new Action<MavenArtifactRepository>() {
        public void execute(MavenArtifactRepository mavenArtifactRepository) {
            mavenArtifactRepository.setUrl(repoUrl);
        }
    });

    Dependency dependency = resolution.getDependencyHandler().create(metadata.implementation.get("gav"));

    ConfigurationContainerInternal configurations = (ConfigurationContainerInternal) resolution.getConfigurationContainer();
    ConfigurationInternal configuration = configurations.detachedConfiguration(dependency);

    try {
        Set<File> files = configuration.getResolvedConfiguration().getFiles(Specs.satisfyAll());
        return new DefaultClassPath(files);
    } catch (ResolveException e) {
        throw new DependencyResolutionException("Failed to resolve all plugin dependencies from " + repoUrl, e.getCause());
    }
}
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
private TaskDependency doGetTaskDependency(Spec<? super Dependency> dependencySpec, AttributeContainerInternal requestedAttributes) {
    synchronized (resolutionLock) {
        if (resolutionStrategy.resolveGraphToDetermineTaskDependencies()) {
            // Force graph resolution as this is required to calculate build dependencies
            resolveToStateOrLater(GRAPH_RESOLVED);
        }
        ResolverResults results;
        if (getState() == State.UNRESOLVED) {
            // Traverse graph
            results = new DefaultResolverResults();
            resolver.resolveBuildDependencies(this, results);
        } else {
            // Otherwise, already have a result, so reuse it
            results = cachedResolverResults;
        }
        List<Object> buildDependencies = new ArrayList<Object>();
        results.getVisitedArtifacts().select(dependencySpec, requestedAttributes).collectBuildDependencies(buildDependencies);
        return TaskDependencies.of(buildDependencies);
    }
}
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
/**
 * Gets IDE local file dependencies.
 *
 * @param configuration Configuration
 * @return IDE local file dependencies
 */
public List<IdeLocalFileDependency> getIdeLocalFileDependencies(Configuration configuration) {
    List<SelfResolvingDependency> externalDependencies = new ArrayList<SelfResolvingDependency>();
    findAllExternalDependencies(externalDependencies, new ArrayList<Dependency>(), configuration);
    List<IdeLocalFileDependency> ideLocalFileDependencies = new ArrayList<IdeLocalFileDependency>();

    for (SelfResolvingDependency externalDependency : externalDependencies) {
        Set<File> resolvedFiles = externalDependency.resolve();

        for (File resolvedFile : resolvedFiles) {
            IdeLocalFileDependency ideLocalFileDependency = new IdeLocalFileDependency(resolvedFile);
            ideLocalFileDependencies.add(ideLocalFileDependency);
        }
    }

    return ideLocalFileDependencies;
}
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
private File getBaseApFile(Project project, TBuildType tBuildType) {
    File apBaseFile;
    File buildTypeBaseApFile = tBuildType.getBaseApFile();
    if (null != buildTypeBaseApFile && buildTypeBaseApFile.exists()) {
        apBaseFile = buildTypeBaseApFile;
    } else if (!isNullOrEmpty(tBuildType.getBaseApDependency())) {
        String apDependency = tBuildType.getBaseApDependency();
        // Preconditions.checkNotNull(apDependency,
        //                            "You have to specify the baseApFile property or the baseApDependency
        // dependency");
        Dependency dependency = project.getDependencies().create(apDependency);
        Configuration configuration = project.getConfigurations().detachedConfiguration(dependency);
        configuration.setTransitive(false);
        apBaseFile = Iterables.getOnlyElement(Collections2.filter(configuration.getFiles(), new Predicate<File>() {
            @Override
            public boolean apply(@Nullable File file) {
                return file.getName().endsWith(".ap");
            }
        }));
    } else {
        throw new IllegalStateException("AP is missing");
    }
    return apBaseFile;
}
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
private void configureInstall(Project project) {
    Upload installUpload = project.getTasks().create(INSTALL_TASK_NAME, Upload.class);
    Configuration configuration = project.getConfigurations().getByName(Dependency.ARCHIVES_CONFIGURATION);
    installUpload.setConfiguration(configuration);
    MavenRepositoryHandlerConvention repositories = new DslObject(installUpload.getRepositories()).getConvention().getPlugin(MavenRepositoryHandlerConvention.class);
    repositories.mavenInstaller();
    installUpload.setDescription("Installs the 'archives' artifacts into the local Maven repository.");
}
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
private void configureConfigurations(final Project project) {

        ConfigurationContainer configurations = project.getConfigurations();
        Configuration moduleConfiguration = configurations.create(DEPLOY_CONFIGURATION_NAME).setVisible(false)
                .setTransitive(false).setDescription("Classpath for deployable modules, not transitive.");
        Configuration earlibConfiguration = configurations.create(EARLIB_CONFIGURATION_NAME).setVisible(false)
                .setDescription("Classpath for module dependencies.");

        configurations.getByName(Dependency.DEFAULT_CONFIGURATION)
                .extendsFrom(moduleConfiguration, earlibConfiguration);
    }
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
public Configuration addConfiguration(ConfigurationContainer configurations, final DependencyHandler dependencies, final EnvJsExtension extension) {
    Configuration configuration = configurations.create(EnvJsExtension.CONFIGURATION_NAME);
    configuration.defaultDependencies(new Action<DependencySet>() {
        @Override
        public void execute(DependencySet configDependencies) {
            String notation = EnvJsExtension.DEFAULT_DEPENDENCY_GROUP + ":" + EnvJsExtension.DEFAULT_DEPENDENCY_MODULE + ":" + extension.getVersion() + "@js";
            Dependency dependency = dependencies.create(notation);
            configDependencies.add(dependency);
        }

    });
    return configuration;
}
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
private Configuration addJsConfiguration(ConfigurationContainer configurations, final DependencyHandler dependencies, final CoffeeScriptExtension extension) {
    Configuration configuration = configurations.create(CoffeeScriptExtension.JS_CONFIGURATION_NAME);
    configuration.defaultDependencies(new Action<DependencySet>() {
        @Override
        public void execute(DependencySet configDependencies) {
            String notation = CoffeeScriptExtension.DEFAULT_JS_DEPENDENCY_GROUP + ":" + CoffeeScriptExtension.DEFAULT_JS_DEPENDENCY_MODULE + ":" + extension.getVersion() + "@js";
            Dependency dependency = dependencies.create(notation);
            configDependencies.add(dependency);
        }
    });
    return configuration;
}
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
private boolean exists(PluginRequest request) {
    // This works because the corresponding BackedByArtifactRepository PluginRepository sets
    // registers an ArtifactRepository in the DependencyResolutionServices instance which is
    // exclusively used by this ArtifactRepositoryPluginResolver. If the plugin marker
    // doesn't exist in that isolated ArtifactRepository, this resolver won't look anywhere else.
    Dependency dependency = resolution.getDependencyHandler().create(getMarkerCoordinates(request));

    ConfigurationContainer configurations = resolution.getConfigurationContainer();
    Configuration configuration = configurations.detachedConfiguration(dependency);
    configuration.setTransitive(false);

    return !configuration.getResolvedConfiguration().hasError();
}
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
public Set<ResolvedDependency> getFirstLevelModuleDependencies(Spec<? super Dependency> dependencySpec) {
    Set<ResolvedDependency> matches = new LinkedHashSet<ResolvedDependency>();
    for (DependencyGraphNodeResult node : getFirstLevelNodes(dependencySpec)) {
        matches.add(node.getPublicView());
    }
    return matches;
}
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
private Set<DependencyGraphNodeResult> getFirstLevelNodes(Spec<? super Dependency> dependencySpec) {
    Set<DependencyGraphNodeResult> matches = new LinkedHashSet<DependencyGraphNodeResult>();
    TransientConfigurationResults graphResults = loadTransientGraphResults(selectedArtifacts);
    for (Map.Entry<ModuleDependency, DependencyGraphNodeResult> entry : graphResults.getFirstLevelDependencies().entrySet()) {
        if (dependencySpec.isSatisfiedBy(entry.getKey())) {
            matches.add(entry.getValue());
        }
    }
    return matches;
}
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
/**
 * Recursive but excludes unsuccessfully resolved artifacts.
 */
public Set<File> getFiles(Spec<? super Dependency> dependencySpec) {
    Set<File> files = Sets.newLinkedHashSet();
    FilesAndArtifactCollectingVisitor visitor = new FilesAndArtifactCollectingVisitor(files);
    visitArtifacts(dependencySpec, configuration.getAttributes(), selectedArtifacts, selectedFileDependencies, visitor);
    files.addAll(getFiles(filterUnresolved(visitor.artifacts)));
    return files;
}
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
/**
 * Recursive, includes unsuccessfully resolved artifacts
 *
 * @param dependencySpec dependency spec
 */
private void visitArtifacts(Spec<? super Dependency> dependencySpec, AttributeContainerInternal requestedAttributes, SelectedArtifactResults artifactResults, SelectedFileDependencyResults fileDependencyResults, ArtifactVisitor visitor) {
    ArtifactVisitor transformingVisitor = artifactTransformer.visitor(visitor, requestedAttributes);

    //this is not very nice might be good enough until we get rid of ResolvedConfiguration and friends
    //avoid traversing the graph causing the full ResolvedDependency graph to be loaded for the most typical scenario
    if (dependencySpec == Specs.SATISFIES_ALL) {
        if (transformingVisitor.includeFiles()) {
            fileDependencyResults.getFiles().visit(transformingVisitor);
        }
        artifactResults.getArtifacts().visit(transformingVisitor);
        return;
    }

    if (transformingVisitor.includeFiles()) {
        for (Map.Entry<FileCollectionDependency, ResolvedArtifactSet> entry: fileDependencyResults.getFirstLevelFiles().entrySet()) {
            if (dependencySpec.isSatisfiedBy(entry.getKey())) {
                entry.getValue().visit(transformingVisitor);
            }
        }
    }

    CachingDirectedGraphWalker<DependencyGraphNodeResult, ResolvedArtifact> walker = new CachingDirectedGraphWalker<DependencyGraphNodeResult, ResolvedArtifact>(new ResolvedDependencyArtifactsGraph(transformingVisitor, fileDependencyResults));

    DependencyGraphNodeResult rootNode = loadTransientGraphResults(artifactResults).getRootNode();
    for (DependencyGraphNodeResult node : getFirstLevelNodes(dependencySpec)) {
        node.getArtifactsForIncomingEdge(rootNode).visit(transformingVisitor);
        walker.add(node);
    }
    walker.findValues();
}
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
@Override
public Set<ResolvedArtifact> getArtifacts(Spec<? super Dependency> dependencySpec) {
    try {
        return lenientConfiguration.getArtifacts(dependencySpec);
    } catch (Throwable e) {
        throw wrapException(e, resolveContext);
    }
}
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
@Override
public Set<ResolvedDependency> getFirstLevelModuleDependencies(Spec<? super Dependency> dependencySpec) {
    try {
        return lenientConfiguration.getFirstLevelModuleDependencies(dependencySpec);
    } catch (Throwable e) {
        throw wrapException(e, resolveContext);
    }
}
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
@Override
public Set<File> getFiles(Spec<? super Dependency> dependencySpec) {
    try {
        return lenientConfiguration.getFiles(dependencySpec);
    } catch (Throwable e) {
        throw wrapException(e, resolveContext);
    }
}
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
private void addDependencies(BuildableLocalComponentMetadata metaData, ConfigurationInternal configuration) {
    AttributeContainerInternal attributes = configuration.getAttributes().asImmutable();
    for (Dependency dependency : configuration.getDependencies()) {
        if (dependency instanceof ModuleDependency) {
            ModuleDependency moduleDependency = (ModuleDependency) dependency;
            metaData.addDependency(dependencyDescriptorFactory.createDependencyDescriptor(configuration.getName(), attributes, moduleDependency));
        } else if (dependency instanceof FileCollectionDependency) {
            final FileCollectionDependency fileDependency = (FileCollectionDependency) dependency;
            metaData.addFiles(configuration.getName(), new DefaultLocalFileDependencyMetadata(fileDependency));
        } else {
            throw new IllegalArgumentException("Cannot convert dependency " + dependency + " to local component dependency metadata.");
        }
    }
}
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
private void ensureConfigured(Configuration config) {
    for (Dependency dependency : config.getAllDependencies()) {
        if (dependency instanceof ProjectDependency) {
            ProjectDependency projectDependency = (ProjectDependency)dependency;
            project.evaluationDependsOn(projectDependency.getDependencyProject().getPath());
        }
    }
}
 

import org.gradle.api.artifacts.Dependency; //导入依赖的package包/类
private ConfigurationFileCollection(final Set<Dependency> dependencies) {
    this(new Spec<Dependency>() {
        public boolean isSatisfiedBy(Dependency element) {
            return dependencies.contains(element);
        }
    });
}