Aether dependency resolution, including managed dependencies - uses git://git.eclipse.org/gitroot/aether/aether-demo.git

FullyResolveDependencyHierarchy.java

package org.eclipse.aether.examples;

import org.eclipse.aether.DefaultRepositorySystemSession;
import org.eclipse.aether.RepositorySystem;
import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.artifact.Artifact;
import org.eclipse.aether.artifact.DefaultArtifact;
import org.eclipse.aether.collection.CollectRequest;
import org.eclipse.aether.examples.util.Booter;
import org.eclipse.aether.graph.Dependency;
import org.eclipse.aether.repository.RemoteRepository;
import org.eclipse.aether.resolution.*;
import org.eclipse.aether.util.artifact.SubArtifact;
import org.eclipse.aether.util.graph.manager.DependencyManagerUtils;
import org.eclipse.aether.util.graph.transformer.ConflictResolver;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class FullyResolveDependencyHierarchy {

    public static void main(String[] args) throws Exception {
        System.out.println("------------------------------------------------------------");
        System.out.println(FullyResolveDependencyHierarchy.class.getSimpleName());

        RepositorySystem system = Booter.newRepositorySystem();

        DefaultRepositorySystemSession session = Booter.newRepositorySystemSession(system);

        session.setConfigProperty(ConflictResolver.CONFIG_PROP_VERBOSE, true);
        session.setConfigProperty(DependencyManagerUtils.CONFIG_PROP_VERBOSE, true);

        Artifact artifact = new DefaultArtifact("org.springframework:spring-framework-bom:4.2.6.RELEASE");

        ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
        descriptorRequest.setArtifact(artifact);
        List<RemoteRepository> repositories = Booter.newRepositories(system, session);
        descriptorRequest.setRepositories(repositories);
        ArtifactDescriptorResult descriptorResult = system.readArtifactDescriptor(session, descriptorRequest);

        CollectRequest collectRequest = new CollectRequest();
        collectRequest.setRootArtifact(descriptorResult.getArtifact());
        java.util.List<Dependency> dependencies = Stream.concat(descriptorResult.getDependencies().stream(),
                descriptorResult.getManagedDependencies().stream()).collect(Collectors.toList());
        collectRequest.setDependencies(dependencies);
        collectRequest.setRepositories(descriptorRequest.getRepositories());

        DependencyRequest dependencyRequest = new DependencyRequest();
        dependencyRequest.setCollectRequest(collectRequest);

        System.out.println("------------------------------------------------------------");
        DependencyResult dependencyResult = system.resolveDependencies(session, dependencyRequest);
        dependencyResult.getArtifactResults().forEach(System.out::println);

        List<ArtifactResult> artifactResults = dependencyResult.getArtifactResults().stream()
                .map(ArtifactResult::getArtifact)
                .flatMap(FullyResolveDependencyHierarchy::mapSubArtifacts)
                .map(a -> new ArtifactRequest(a, repositories, null))
                .flatMap(r -> safelyResolveArtifact(system, session, r))
                .collect(Collectors.toList());

        artifactResults.forEach(System.out::println);
    }

    public static Stream<Artifact> mapSubArtifacts(Artifact artifact) {
        SubArtifact sources = new SubArtifact(artifact, "sources", "jar");
        SubArtifact javadoc = new SubArtifact(artifact, "javadoc", "jar");
        return Stream.<Artifact>builder().add(sources).add(javadoc).build();
    }

    public static Stream<ArtifactResult> safelyResolveArtifact(RepositorySystem system, RepositorySystemSession
            session, ArtifactRequest artifactRequest) {
        try {
            return Stream.of(system.resolveArtifact(session, artifactRequest));
        } catch (ArtifactResolutionException e) {
            System.err.println("Could not resolve artifact " + artifactRequest.getArtifact());
            return Stream.empty();
        }
    }
}