How to use org.eclipse.aether.resolution

  @Override
  public boolean apply(ArtifactResult artifactResult) {
    return artifactResult.isMissing();
  }
});

private int getPolicy( RepositorySystemSession session, Artifact a, ArtifactDescriptorRequest request )
{
  ArtifactDescriptorPolicy policy = session.getArtifactDescriptorPolicy();
  if ( policy == null )
  {
    return ArtifactDescriptorPolicy.STRICT;
  }
  return policy.getPolicy( session, new ArtifactDescriptorPolicyRequest( a, request.getRequestContext() ) );
}

private static void printMissingArtifactsToSysErr(Iterable<ArtifactResult> missingArtifacts) {
  for (ArtifactResult artifactResult : missingArtifacts) {
    System.err.println("ArtifactResult : " + artifactResult + " / Errors : " + artifactResult.getExceptions());
  }
}

ArtifactRequest pomRequest = new ArtifactRequest();
pomRequest.setArtifact( pomArtifact );
pomRequest.setRepositories( config.repositories );
ArtifactResult pomResult = repoSystem.resolveArtifact( config.session, pomRequest );
pomArtifact = pomResult.getArtifact();
localProject = pomResult.getRepository() instanceof WorkspaceRepository;
if ( e.getResults().get( 0 ).isMissing() && allowStubModel )
                  "Error resolving project artifact: " + e.getMessage(), e );

@Override
public ModelSource resolveModel( String groupId, String artifactId, String version )
  throws UnresolvableModelException
{
  Artifact pomArtifact = new DefaultArtifact( groupId, artifactId, "", "pom", version );
  try
  {
    ArtifactRequest request = new ArtifactRequest( pomArtifact, repositories, context );
    request.setTrace( trace );
    pomArtifact = resolver.resolveArtifact( session, request ).getArtifact();
  }
  catch ( ArtifactResolutionException e )
  {
    throw new UnresolvableModelException( e.getMessage(), groupId, artifactId, version, e );
  }
  File pomFile = pomArtifact.getFile();
  return new FileModelSource( pomFile );
}

public Path findMavenArtifact(
    final Artifact artifact) throws MavenArtifactNotFoundException {
  final ArtifactResult result;
  try {
    result = this.repositorySystem.resolveArtifact(
        this.repositorySystemSession, new ArtifactRequest().setArtifact(artifact));
  } catch (ArtifactResolutionException ex) {
    throw new MavenArtifactNotFoundException(artifact,
                         this.givenLocalMavenRepositoryPath,
                         this.absoluteLocalMavenRepositoryPath,
                         ex);
  }
  return result.getArtifact().getFile().toPath();
}

  new ArtifactDescriptorRequest( pluginArtifact, repositories, REPOSITORY_CONTEXT );
request.setTrace( trace );
ArtifactDescriptorResult result = repoSystem.readArtifactDescriptor( pluginSession, request );
pluginArtifact = result.getArtifact();
String requiredMavenVersion = (String) result.getProperties().get( "prerequisites.maven" );
if ( requiredMavenVersion != null )
ArtifactRequest request = new ArtifactRequest( pluginArtifact, repositories, REPOSITORY_CONTEXT );
request.setTrace( trace );
pluginArtifact = repoSystem.resolveArtifact( session, request ).getArtifact();

                        "pom", dependency.getVersion() );
final VersionRangeRequest versionRangeRequest = new VersionRangeRequest( artifact, repositories, context );
versionRangeRequest.setTrace( trace );
if ( versionRangeResult.getHighestVersion() == null )
if ( versionRangeResult.getVersionConstraint() != null
     && versionRangeResult.getVersionConstraint().getRange() != null
     && versionRangeResult.getVersionConstraint().getRange().getUpperBound() == null )
dependency.setVersion( versionRangeResult.getHighestVersion().toString() );
throw new UnresolvableModelException( e.getMessage(), dependency.getGroupId(), dependency.getArtifactId(),
                   dependency.getVersion(), e );

private static Map<String, String> transformArtifactResultToArtifactToPaths(List<ArtifactResult> artifactResults) {
  Map<String, String> artifactToPath = new LinkedHashMap<>();
  for (ArtifactResult artifactResult : artifactResults) {
    Artifact artifact = artifactResult.getArtifact();
    artifactToPath.put(AetherUtils.artifactToString(artifact), artifact.getFile().getAbsolutePath());
  }
  return artifactToPath;
}

/**
 * Resolve dependencies and return downloaded information of artifacts.
 *
 * @param dependencies the list of dependency
 * @return downloaded information of artifacts
 * @throws DependencyResolutionException If the dependency tree could not be built or any dependency
 *     artifact could not be resolved.
 * @throws ArtifactResolutionException If the artifact could not be resolved.
 */
public List<ArtifactResult> resolve(List<Dependency> dependencies) throws
    DependencyResolutionException, ArtifactResolutionException {
  if (dependencies.size() == 0) {
    return Collections.EMPTY_LIST;
  }
  CollectRequest collectRequest = new CollectRequest();
  collectRequest.setRoot(dependencies.get(0));
  for (int idx = 1; idx < dependencies.size(); idx++) {
    collectRequest.addDependency(dependencies.get(idx));
  }
  for (RemoteRepository repository : remoteRepositories) {
    collectRequest.addRepository(repository);
  }
  DependencyFilter classpathFilter = DependencyFilterUtils
      .classpathFilter(JavaScopes.COMPILE, JavaScopes.RUNTIME);
  DependencyRequest dependencyRequest = new DependencyRequest(collectRequest, classpathFilter);
  return system.resolveDependencies(session, dependencyRequest).getArtifactResults();
}

RequestTrace trace = RequestTrace.newChild( request.getTrace(), request );
  new DefaultMetadata( request.getArtifact().getGroupId(), request.getArtifact().getArtifactId(),
             MAVEN_METADATA_XML, Metadata.Nature.RELEASE_OR_SNAPSHOT );
List<MetadataRequest> metadataRequests = new ArrayList<>( request.getRepositories().size() );
metadataRequests.add( new MetadataRequest( metadata, null, request.getRequestContext() ) );
for ( RemoteRepository repository : request.getRepositories() )
  MetadataRequest metadataRequest = new MetadataRequest( metadata, repository, request.getRequestContext() );
  metadataRequest.setDeleteLocalCopyIfMissing( true );
  metadataRequest.setTrace( trace );
  metadataRequests.add( metadataRequest );
if ( workspace != null )
  List<String> versions = workspace.findVersions( request.getArtifact() );
  for ( String version : versions )
  result.addException( metadataResult.getException() );
  ArtifactRepository repository = metadataResult.getRequest().getRepository();
  if ( repository == null )
  Versioning versioning = readVersions( session, trace, metadataResult.getMetadata(), repository, result );
  for ( String version : versioning.getVersions() )

private void process( DefaultDependencyResolutionResult result, Collection<ArtifactResult> results )
{
  for ( ArtifactResult ar : results )
  {
    DependencyNode node = ar.getRequest().getDependencyNode();
    if ( ar.isResolved() )
    {
      result.addResolvedDependency( node.getDependency() );
    }
    else
    {
      result.setResolutionErrors( node.getDependency(), ar.getExceptions() );
    }
  }
}

private ArtifactDescriptorResult describeMavenArtifact(
    final String groupId,
    final String artifactId,
    final String classifier,
    final String extension,
    final String version)
    throws ArtifactDescriptorException {
  // |classifier| can be null for |org.eclipse.aether.artifact.DefaultArtifact|.
  final ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest()
      .setArtifact(new DefaultArtifact(groupId, artifactId, classifier, extension, version));
  return this.repositorySystem.readArtifactDescriptor(this.repositorySystemSession, descriptorRequest);
}

private PluginPrefixResult processResults( PluginPrefixRequest request, RequestTrace trace,
                      List<MetadataResult> results, List<MetadataRequest> requests )
{
  for ( MetadataResult res : results )
  {
    org.eclipse.aether.metadata.Metadata metadata = res.getMetadata();
    if ( metadata != null )
    {
      ArtifactRepository repository = res.getRequest().getRepository();
      if ( repository == null )
      {
        repository = request.getRepositorySession().getLocalRepository();
      }
      PluginPrefixResult result =
        resolveFromRepository( request, trace, metadata.getGroupId(), metadata, repository );
      if ( result != null )
      {
        return result;
      }
    }
    if ( requests != null && !res.isUpdated() )
    {
      requests.add( res.getRequest() );
    }
  }
  return null;
}

private boolean resolve( VersionResult result, Map<String, VersionInfo> infos, String key )
{
  VersionInfo info = infos.get( key );
  if ( info != null )
  {
    result.setVersion( info.version );
    result.setRepository( info.repository );
  }
  return info != null;
}

public ArtifactDescriptorResult readArtifactDescriptor( RepositorySystemSession session,
                            ArtifactDescriptorRequest request )
  throws ArtifactDescriptorException
{
  ArtifactDescriptorResult result = new ArtifactDescriptorResult( request );
  Model model = loadPom( session, request, result );
  if ( model != null )
  {
    Map<String, Object> config = session.getConfigProperties();
    ArtifactDescriptorReaderDelegate delegate =
      (ArtifactDescriptorReaderDelegate) config.get( ArtifactDescriptorReaderDelegate.class.getName() );
    if ( delegate == null )
    {
      delegate = new ArtifactDescriptorReaderDelegate();
    }
    delegate.populateResult( session, result, model );
  }
  return result;
}

public ModelSource resolveModel( String groupId, String artifactId, String version )
  throws UnresolvableModelException
{
  File pomFile = null;
  if ( modelPool != null )
  {
    pomFile = modelPool.get( groupId, artifactId, version );
  }
  if ( pomFile == null )
  {
    Artifact pomArtifact = new DefaultArtifact( groupId, artifactId, "", "pom", version );
    try
    {
      ArtifactRequest request = new ArtifactRequest( pomArtifact, repositories, context );
      request.setTrace( trace );
      pomArtifact = resolver.resolveArtifact( session, request ).getArtifact();
    }
    catch ( ArtifactResolutionException e )
    {
      throw new UnresolvableModelException( e.getMessage(), groupId, artifactId, version, e );
    }
    pomFile = pomArtifact.getFile();
  }
  return new FileModelSource( pomFile );
}

                        "pom", dependency.getVersion() );
final VersionRangeRequest versionRangeRequest = new VersionRangeRequest( artifact, repositories, context );
versionRangeRequest.setTrace( trace );
if ( versionRangeResult.getHighestVersion() == null )
if ( versionRangeResult.getVersionConstraint() != null
     && versionRangeResult.getVersionConstraint().getRange() != null
     && versionRangeResult.getVersionConstraint().getRange().getUpperBound() == null )
dependency.setVersion( versionRangeResult.getHighestVersion().toString() );
throw new UnresolvableModelException( e.getMessage(), dependency.getGroupId(), dependency.getArtifactId(),
                   dependency.getVersion(), e );

                        parent.getVersion() );
final VersionRangeRequest versionRangeRequest = new VersionRangeRequest( artifact, repositories, context );
versionRangeRequest.setTrace( trace );
if ( versionRangeResult.getHighestVersion() == null )
if ( versionRangeResult.getVersionConstraint() != null
     && versionRangeResult.getVersionConstraint().getRange() != null
     && versionRangeResult.getVersionConstraint().getRange().getUpperBound() == null )
parent.setVersion( versionRangeResult.getHighestVersion().toString() );
throw new UnresolvableModelException( e.getMessage(), parent.getGroupId(), parent.getArtifactId(),
                   parent.getVersion(), e );

                        parent.getVersion() );
final VersionRangeRequest versionRangeRequest = new VersionRangeRequest( artifact, repositories, context );
versionRangeRequest.setTrace( trace );
if ( versionRangeResult.getHighestVersion() == null )
if ( versionRangeResult.getVersionConstraint() != null
     && versionRangeResult.getVersionConstraint().getRange() != null
     && versionRangeResult.getVersionConstraint().getRange().getUpperBound() == null )
parent.setVersion( versionRangeResult.getHighestVersion().toString() );
throw new UnresolvableModelException( e.getMessage(), parent.getGroupId(), parent.getArtifactId(),
                   parent.getVersion(), e );