import org.eclipse.aether.util.filter.DependencyFilterUtils; //导入依赖的package包/类
private Stream<? extends Artifact> resolveArtifacts(String coordinator) {
    log.debug("resolving {}", coordinator);
    try {
        // build resolve filters
        CollectRequest collectRequest = new CollectRequest();
        collectRequest.setRoot(new Dependency(new DefaultArtifact(coordinator), JavaScopes.COMPILE));
        DependencyRequest dependencyRequest = new DependencyRequest(
                collectRequest,
                DependencyFilterUtils.classpathFilter(JavaScopes.COMPILE, JavaScopes.RUNTIME)
        );
        // resolve
        final List<Artifact> artifacts = teslaAether.resolveArtifacts(dependencyRequest);
        if (CollectionUtils.isEmpty(artifacts)) {
            throw new DependencyResolveException(String.format("cannot resolve %s", coordinator));
        }
        return artifacts.stream();
    } catch (DependencyResolutionException e) {
        final String message = String.format("cannot resolve %s : %s", coordinator, e.getLocalizedMessage());
        throw new DependencyResolveException(message, e);
    }
}
 

import org.eclipse.aether.util.filter.DependencyFilterUtils; //导入依赖的package包/类
private List<Artifact> resolveDependencies(final Artifact artifact) throws DependencyResolutionException {
    List<Artifact> result = new ArrayList<Artifact>();

    RepositorySystem system = newRepositorySystem();
    CollectRequest collectRequest = new CollectRequest();
    collectRequest.setRoot(new org.eclipse.aether.graph.Dependency(artifact, JavaScopes.COMPILE));
    List<ArtifactResult> dependenciesTree = system.resolveDependencies(
            session,
            new DependencyRequest(collectRequest, DependencyFilterUtils.classpathFilter(JavaScopes.COMPILE))
    ).getArtifactResults();
    for (final ArtifactResult res : dependenciesTree) {
        result.add(res.getArtifact());
    }

    return result;
}
 

import org.eclipse.aether.util.filter.DependencyFilterUtils; //导入依赖的package包/类
public List<Artifact> getDependencies(String groupId, String artifactId, String extension, String version) throws Exception {
  Artifact artifact = new DefaultArtifact(groupId, artifactId, extension, version);
  CollectRequest collectRequest = new CollectRequest();
  collectRequest.setRoot(new Dependency( artifact, ""));
  collectRequest.setRepositories(Collections.emptyList());
  DependencyRequest dependencyRequest = new DependencyRequest(collectRequest, DependencyFilterUtils.classpathFilter(JavaScopes.COMPILE));
  DependencyResult dependencyResult = system.resolveDependencies(session, dependencyRequest);
  List<Artifact> dependencies = new ArrayList<>();
  for (ArtifactResult artifactResult : dependencyResult.getArtifactResults()) {
    if (!artifactResult.isResolved()) {
      throw new Exception("Could not resolve artifact " + artifactResult.getRequest().getArtifact());
    }
    dependencies.add(artifactResult.getArtifact());
  }
  return dependencies;
}
 

import org.eclipse.aether.util.filter.DependencyFilterUtils; //导入依赖的package包/类
public List<File> resolveArtifactsAndDependencies(List<Artifact> artifacts) throws ArtifactResolutionException, DependencyResolutionException {
    List<Dependency> dependencies = new ArrayList<Dependency>();

    for (Artifact artifact : artifacts) {
        dependencies.add(new Dependency(artifact, JavaScopes.RUNTIME));
    }
    
    CollectRequest collectRequest = new CollectRequest((Dependency)null, dependencies, repositories);
    DependencyFilter classpathFilter = DependencyFilterUtils.classpathFilter(JavaScopes.RUNTIME);
    DependencyRequest dependencyRequest = new DependencyRequest(collectRequest, classpathFilter);
    DependencyResult result = system.resolveDependencies(session, dependencyRequest);
    
    List<File> files = new ArrayList<File>();
    
    for (ArtifactResult artifactResult : result.getArtifactResults()) {
        files.add(artifactResult.getArtifact().getFile());
    }
    
    return files;
}
 

import org.eclipse.aether.util.filter.DependencyFilterUtils; //导入依赖的package包/类
private ImmutableMap<String, Artifact> getRunTimeTransitiveDeps(Iterable<Dependency> mavenCoords)
    throws RepositoryException {

  CollectRequest collectRequest = new CollectRequest();
  collectRequest.setRequestContext(JavaScopes.RUNTIME);
  collectRequest.setRepositories(repos);

  for (Dependency dep : mavenCoords) {
    collectRequest.addDependency(dep);
  }

  DependencyFilter filter = DependencyFilterUtils.classpathFilter(JavaScopes.RUNTIME);
  DependencyRequest dependencyRequest = new DependencyRequest(collectRequest, filter);

  DependencyResult dependencyResult = repoSys.resolveDependencies(session, dependencyRequest);

  ImmutableSortedMap.Builder<String, Artifact> knownDeps = ImmutableSortedMap.naturalOrder();
  for (ArtifactResult artifactResult : dependencyResult.getArtifactResults()) {
    Artifact node = artifactResult.getArtifact();
    knownDeps.put(buildKey(node), node);
  }
  return knownDeps.build();
}
 

import org.eclipse.aether.util.filter.DependencyFilterUtils; //导入依赖的package包/类
/**
 * Resolves and downloads an artifact with its dependencies.
 * 
 * @param artifact
 *          artifact to resolve
 * @param javadoc
 *          <code>true</code> if javadoc attachment should be retrieved too
 * @param sources
 *          <code>true</code> if sources attachment should be retrieved too
 * @throws DependencyCollectionException
 *           if the dependency graph could not be properly assembled
 * @throws DependencyResolutionException
 *           if a dependency is not resolvable
 */
public void downloadDependencyTree(DefaultArtifact artifact, boolean javadoc, boolean sources)
    throws DependencyCollectionException, DependencyResolutionException {
  log.info("Resolving: {} with these dependencies ...", artifact.toString());

  Dependency dependency = new Dependency(artifact, JavaScopes.COMPILE);

  DependencyNode jarNode = repoSystemHelper.collectDependencies(dependency);

  DependencyFilter classpathFilter = DependencyFilterUtils.classpathFilter(JavaScopes.TEST);
  jarNode.accept(new TreeDependencyVisitor(new FilteringDependencyVisitor(new DependencyGraphPrinter(), classpathFilter)));

  DependencyRequest dependencyRequest = new DependencyRequest(jarNode, classpathFilter);
  DependencyResult dependencyResult = repoSystemHelper.resolveDependencies(dependencyRequest);

  if (javadoc) {
    downloadAttachments(dependencyResult, "javadoc");
  }

  if (sources) {
    downloadAttachments(dependencyResult, "sources");
  }
}
 

import org.eclipse.aether.util.filter.DependencyFilterUtils; //导入依赖的package包/类
private void validateBomDependency(ValidatorContext ctx, Model bom, Dependency bomDependency, Dependency dependency) {
    CollectRequest collectRequest = new CollectRequest(
            bomDependency,
            Collections.singletonList(dependency),
            ctx.getRemoteRepositories());

    DependencyRequest dependencyRequest = new DependencyRequest(
            collectRequest,
            DependencyFilterUtils.classpathFilter(JavaScopes.COMPILE));

    try {
        repositorySystem.resolveDependencies(repositorySystemSession, dependencyRequest);
    } catch (DependencyResolutionException e) {
        ArtifactResolutionException are = findCause(e, ArtifactResolutionException.class);
        if( are == null ) {
            ctx.addError(this, bom.getPomFile(), e);
        } else {
            DependencyNode dependencyNode = e.getResult().getRoot();
            Artifact validatedArtifact = new DefaultArtifact(bom.getGroupId(), bom.getArtifactId(), bom.getPackaging(), bom.getVersion());
            for (Artifact missingArtifact : Utils.collectMissingArtifacts(are)) {
                ctx.addError(this, bom.getPomFile(), new BomDependencyNotFoundException(e, missingArtifact, validatedArtifact, dependencyNode));                
            }
        }
    }
}
 

import org.eclipse.aether.util.filter.DependencyFilterUtils; //导入依赖的package包/类
@Override
public void load(Dependency dependency) throws DependencyResolutionException, DependencyProvisionException {
    List<RemoteRepository> remoteRepositories = remoteRepositoriesSupplier.get();
    CollectRequest collectRequest = new CollectRequest(dependency, remoteRepositories);
    DependencyRequest dependencyRequest = new DependencyRequest(collectRequest, DependencyFilterUtils.classpathFilter(JavaScopes.COMPILE));

    DependencyResult dependencyResult = repositorySystem.resolveDependencies(repositorySystemSession, dependencyRequest);
    for (ArtifactResult artifactResult : dependencyResult.getArtifactResults())
        inject(artifactResult);
}
 

import org.eclipse.aether.util.filter.DependencyFilterUtils; //导入依赖的package包/类
/**
 * Prepare an import with dependencies
 * <p>
 * This method does resolve even transient dependencies and also adds the
 * sources if requested
 * </p>
 */
public static AetherResult prepareDependencies ( final Path tmpDir, final ImportConfiguration cfg ) throws RepositoryException
{
    Objects.requireNonNull ( tmpDir );
    Objects.requireNonNull ( cfg );

    final RepositoryContext ctx = new RepositoryContext ( tmpDir, cfg.getRepositoryUrl (), cfg.isAllOptional () );

    // add all coordinates

    final CollectRequest cr = new CollectRequest ();
    cr.setRepositories ( ctx.getRepositories () );
    for ( final MavenCoordinates coords : cfg.getCoordinates () )
    {
        final Dependency dep = new Dependency ( new DefaultArtifact ( coords.toString () ), COMPILE );
        cr.addDependency ( dep );
    }

    final DependencyFilter filter = DependencyFilterUtils.classpathFilter ( COMPILE );
    final DependencyRequest deps = new DependencyRequest ( cr, filter );

    // resolve

    final DependencyResult dr = ctx.getSystem ().resolveDependencies ( ctx.getSession (), deps );
    final List<ArtifactResult> arts = dr.getArtifactResults ();

    if ( !cfg.isIncludeSources () )
    {
        // we are already done here
        return asResult ( arts, cfg, of ( dr ) );
    }

    // resolve sources

    final List<ArtifactRequest> requests = extendRequests ( arts.stream ().map ( ArtifactResult::getRequest ), ctx, cfg );

    return asResult ( resolve ( ctx, requests ), cfg, of ( dr ) );
}
 

import org.eclipse.aether.util.filter.DependencyFilterUtils; //导入依赖的package包/类
private static DependencyRequest buildDependencyRequest(List<RemoteRepository> repositories, String identifier, String scope)
{
    Artifact artifact = new DefaultArtifact(identifier);

    DependencyFilter classpathFlter = DependencyFilterUtils.classpathFilter(scope);

    CollectRequest collectRequest = new CollectRequest();
    collectRequest.setRoot(new Dependency(artifact, scope));
    collectRequest.setRepositories(repositories);

    return new DependencyRequest(collectRequest, classpathFlter);
}
 

import org.eclipse.aether.util.filter.DependencyFilterUtils; //导入依赖的package包/类
private Collection<File> getArtifactsFiles(List<Dependency> dependencies) {
	String reposFileName = config.getString(WebjarModuleConfig.REPOS_FILE, WebjarModuleConfig.REPOS_FILE_DEFAULT);

	RepositoryConfig repositoryConfig = new RepositoryConfig(container.logger(), reposFileName);

	RepositorySystem system = createRepositorySystem();
	RepositorySystemSession session = createRepositorySystemSession(system, repositoryConfig.getLocalRepository());

	DependencyFilter classpathFilter = DependencyFilterUtils.classpathFilter(JavaScopes.COMPILE);

	CollectRequest collectRequest = new CollectRequest(dependencies, null, repositoryConfig.getRemoteRepositories());
	DependencyRequest dependencyRequest = new DependencyRequest(collectRequest, classpathFilter);

	try {
		List<ArtifactResult> artifactResults = system.resolveDependencies(session, dependencyRequest)
				.getArtifactResults();

		Collection<File> artifactsFiles = new HashSet<>();
		for (ArtifactResult artifactResult : artifactResults) {
			checkArtifactResultStatus(artifactResult);
			artifactsFiles.add(artifactResult.getArtifact().getFile());
		}
		return artifactsFiles;
	} catch (DependencyResolutionException e) {
		throw new WebjarModuleException("Failed to resolve dependencies", e);
	}
}
 

import org.eclipse.aether.util.filter.DependencyFilterUtils; //导入依赖的package包/类
DependencyRequest createDependencyRequest(CollectRequest collectRequest) {
  DependencyFilter compileFilter = DependencyFilterUtils.classpathFilter(JavaScopes.COMPILE);
  return createDependencyRequest(collectRequest, compileFilter);
}
 

import org.eclipse.aether.util.filter.DependencyFilterUtils; //导入依赖的package包/类
public static Set<DependencyWrapper> listTransitiveDependencies(Set<DependencyWrapper> dependencySet) {
    Set<DependencyWrapper> dependencies = Sets.newHashSet();

    for (DependencyWrapper dependency : dependencySet) {
        RepositorySystem system = Booter.newRepositorySystem();

        RepositorySystemSession session = Booter.newRepositorySystemSession(system);

        Artifact artifact = new DefaultArtifact(
                String.format("%s:%s:%s", dependency.getGroupId(), dependency.getArtifactId(), dependency.getVersion()));

        DependencyFilter classpathFlter = DependencyFilterUtils.classpathFilter(JavaScopes.COMPILE);

        CollectRequest collectRequest = new CollectRequest();
        collectRequest.setRoot(new Dependency(artifact, JavaScopes.COMPILE));
        collectRequest.setRepositories(Booter.newRepositories(system, session));

        DependencyRequest dependencyRequest = new DependencyRequest(collectRequest, classpathFlter);

        List<ArtifactResult> artifactResults = null;
        try {
            artifactResults = system.resolveDependencies(session, dependencyRequest).getArtifactResults();
        } catch (DependencyResolutionException e) {
            continue;
        }

        for (ArtifactResult artifactResult : artifactResults) {

            if (artifactResult.getRepository() == null) {
                continue;
            }

            Artifact artifact1 = artifactResult.getArtifact();

            org.apache.maven.model.Dependency dependency1 = new org.apache.maven.model.Dependency();
            dependency1.setArtifactId(artifact1.getArtifactId());
            dependency1.setGroupId(artifact1.getGroupId());
            dependency1.setVersion(artifact1.getVersion());
            dependency1.setClassifier(artifact1.getClassifier());
            if (!MavenUtils.isDependencyResolvable(dependency1)) {
                continue;
            }

            dependencies
                    .add(new DependencyWrapper(artifact1.getGroupId(), artifact1.getArtifactId(), artifact1.getVersion()));
        }
    }

    return dependencies;
}
 

import org.eclipse.aether.util.filter.DependencyFilterUtils; //导入依赖的package包/类
private DependencyRequest getDependencyRequest(CollectRequest collectRequest) {
	DependencyRequest dependencyRequest = new DependencyRequest(collectRequest,
			DependencyFilterUtils.classpathFilter(JavaScopes.COMPILE,
					JavaScopes.RUNTIME));
	return dependencyRequest;
}