import org.eclipse.aether.resolution.ArtifactDescriptorException; //导入依赖的package包/类
public Set<Artifact> getRejectedDependencies(Artifact artifact) throws ArtifactDescriptorException {
    Set<Dependency> allDependencies = getAllDependencies(artifact);

    Set<Artifact> rejected = new HashSet<>();
    for (Dependency dependency : allDependencies) {
        Scope scope = Scope.compile;
        try {
            scope = Scope.valueOf(dependency.getScope().toLowerCase());
        } catch (Throwable ignored) { }

        if (ignoredScopes.contains(scope)) {
            continue;
        }

        if ((dependency.getArtifact().isSnapshot() && rejectSnapshots) || notAllowed(allowedArtifacts, dependency)) {
            rejected.add(dependency.getArtifact());
        }
    }

    return rejected;
}
 

import org.eclipse.aether.resolution.ArtifactDescriptorException; //导入依赖的package包/类
private boolean hasTransitiveSnapshots(Dependency dependency) throws MojoFailureException {
    ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
    descriptorRequest.setArtifact(
            new DefaultArtifact(dependency.getGroupId(), dependency.getArtifactId(), dependency.getClassifier(), dependency.getType(), dependency.getVersion()));
    descriptorRequest.setRepositories(remoteRepos);

    try {
        ArtifactDescriptorResult result = repoSystem.readArtifactDescriptor(repoSession, descriptorRequest);
        Optional<org.eclipse.aether.graph.Dependency> snapshotDependency = result.getDependencies().stream()
                .filter(d -> d.getArtifact().isSnapshot())
                .findFirst();
        return snapshotDependency.isPresent();
    } catch (ArtifactDescriptorException e) {
        throw new MojoFailureException(e.getMessage(), e);
    }
}
 

import org.eclipse.aether.resolution.ArtifactDescriptorException; //导入依赖的package包/类
public Set<Dependency> getAllDependencies(Artifact artifact) throws ArtifactDescriptorException {
    ArtifactDescriptorRequest request = new ArtifactDescriptorRequest(artifact, repositories, null);
    ArtifactDescriptorResult result = system.readArtifactDescriptor(session, request);

    Set<Dependency> dependencies = new HashSet<>(result.getManagedDependencies());
    dependencies.addAll(result.getDependencies());

    return dependencies;
}
 

import org.eclipse.aether.resolution.ArtifactDescriptorException; //导入依赖的package包/类
public Collection<String> getDependencies(String moduleId, String version) throws ArtifactDescriptorException {
    Artifact artifact = new DefaultArtifact(groupId, moduleId, "jar", version);

    ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
    descriptorRequest.setArtifact(artifact);
    descriptorRequest.setRepositories(repos);

    ArtifactDescriptorResult descriptorResult = system.readArtifactDescriptor(session, descriptorRequest);

    List<String> deps = Lists.newArrayList();
    for (Dependency dep : descriptorResult.getDependencies()) {
        deps.add(dep.getArtifact().getArtifactId());
    }
    return deps;
}
 

import org.eclipse.aether.resolution.ArtifactDescriptorException; //导入依赖的package包/类
private ArtifactDescriptorResult readArtifactDescriptor(AddonId addonId) throws ArtifactDescriptorException
{
   String coords = toMavenCoords(addonId);
   RepositorySystem system = container.getRepositorySystem();
   Settings settings = getSettings();
   DefaultRepositorySystemSession session = container.setupRepoSession(system, settings);
   List<RemoteRepository> repositories = MavenRepositories.getRemoteRepositories(container, settings);
   ArtifactDescriptorRequest request = new ArtifactDescriptorRequest();
   request.setArtifact(new DefaultArtifact(coords));
   request.setRepositories(repositories);

   ArtifactDescriptorResult result = system.readArtifactDescriptor(session, request);
   return result;
}
 

import org.eclipse.aether.resolution.ArtifactDescriptorException; //导入依赖的package包/类
private List<Dependency> getDependenciesOf(Artifact dep) throws ArtifactDescriptorException {
  ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
  descriptorRequest.setArtifact(dep);
  descriptorRequest.setRepositories(repos);
  descriptorRequest.setRequestContext(JavaScopes.RUNTIME);

  ArtifactDescriptorResult result = repoSys.readArtifactDescriptor(session, descriptorRequest);
  return result.getDependencies();
}
 

import org.eclipse.aether.resolution.ArtifactDescriptorException; //导入依赖的package包/类
private MutableDirectedGraph<Artifact> buildDependencyGraph(Map<String, Artifact> knownDeps)
    throws ArtifactDescriptorException {
  MutableDirectedGraph<Artifact> graph;
  graph = new MutableDirectedGraph<>();
  for (Map.Entry<String, Artifact> entry : knownDeps.entrySet()) {
    String key = entry.getKey();
    Artifact artifact = entry.getValue();

    graph.addNode(artifact);

    List<Dependency> dependencies = getDependenciesOf(artifact);

    for (Dependency dependency : dependencies) {
      if (dependency.getArtifact() == null) {
        System.out.println("Skipping because artifact missing: " + dependency);
        continue;
      }

      String depKey = buildKey(dependency.getArtifact());
      Artifact actualDep = knownDeps.get(depKey);
      if (actualDep == null) {
        continue;
      }
      // It's possible that the runtime dep of an artifact is the test time dep of another.
      if (isTestTime(dependency)) {
        continue;
      }

      // TODO(simons): Do we always want optional dependencies?
      //        if (dependency.isOptional()) {
      //          continue;
      //        }

      Preconditions.checkNotNull(
          actualDep, key + " -> " + artifact + " in " + knownDeps.keySet());
      graph.addNode(actualDep);
      graph.addEdge(actualDep, artifact);
    }
  }
  return graph;
}
 

import org.eclipse.aether.resolution.ArtifactDescriptorException; //导入依赖的package包/类
@Test
public void getDependenciesTest() throws ArtifactDescriptorException {

    Collection<String> file = connector.getDependencies("CopperAndBronze", "0.1.0-SNAPSHOT");

    Assert.assertThat(file, IsCollectionContaining.hasItem("engine"));
}