Maven from Java

build.gradle

apply plugin: 'java'

repositories {
    mavenCentral()
}

dependencies {
    compile 'org.eclipse.aether:aether-api:1.1.0'
    compile 'org.eclipse.aether:aether-spi:1.1.0'
    compile 'org.eclipse.aether:aether-util:1.1.0'
    compile 'org.eclipse.aether:aether-impl:1.1.0'
    compile 'org.eclipse.aether:aether-connector-basic:1.1.0'
    compile 'org.eclipse.aether:aether-transport-file:1.1.0'
    compile 'org.eclipse.aether:aether-transport-http:1.1.0'
    compile('org.apache.maven:maven-aether-provider:3.1.0') {
        // sisu dependency injector is not used
        exclude group: 'org.eclipse.sisu'
    }
    testCompile 'junit:junit:4.+'
}

sourceSets {
    main {
        java {
            srcDir '.'
            exclude 'Test*.java'
        }
    }
    test {
        java {
            srcDir '.'
            include 'Test*.java'
        }
    }
}

test {
    testLogging {
        events 'passed', 'skipped', 'failed', 'standardOut', 'standardError'
    }
}

task run(type:JavaExec) {
    main = project.hasProperty('main') ? project.getProperty('main') : 'MavenFromJava'
    classpath = sourceSets.main.runtimeClasspath
}

MavenFromJava.java

import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.eclipse.aether.RepositorySystem;
import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.artifact.Artifact;
import org.eclipse.aether.resolution.ArtifactResult;
import org.eclipse.aether.resolution.DependencyRequest;
import org.eclipse.aether.resolution.DependencyResolutionException;
import org.eclipse.aether.repository.RemoteRepository;

public class MavenFromJava {
    public static void main(String[] args) throws DependencyResolutionException {
        RepositorySystem repositorySystem = newRepositorySystem();
        RepositorySystemSession repositorySystemSession =
            newRepositorySystemSession(repositorySystem, Paths.get("/tmp/foobar"));
        List<ArtifactResult> results = resolveArtifacts(
            repositorySystem, repositorySystemSession, DEFAULT_REPOSITORIES, "org.postgresql:postgresql:9.4.1211");
        for (ArtifactResult result : results) {
            System.out.println(result.toString());
        }
    }

    private static List<ArtifactResult> resolveArtifacts(
            RepositorySystem repositorySystem,
            RepositorySystemSession repositorySystemSession,
            List<RemoteRepository> repositories,
            String dependency) throws DependencyResolutionException {
        DependencyRequest request = buildDependencyRequest(repositories,
                                                           dependency,
                                                           org.eclipse.aether.util.artifact.JavaScopes.RUNTIME);
        try {
            return repositorySystem.resolveDependencies(repositorySystemSession, request).getArtifactResults();
        } catch (DependencyResolutionException ex) {
            throw ex;
        }
    }

    private static DependencyRequest buildDependencyRequest(
            List<RemoteRepository> repositories, String identifier, String scope) {
        Artifact artifact = new org.eclipse.aether.artifact.DefaultArtifact(identifier);

        org.eclipse.aether.graph.DependencyFilter classpathFlter =
            org.eclipse.aether.util.filter.DependencyFilterUtils.classpathFilter(scope);

        org.eclipse.aether.collection.CollectRequest collectRequest =
            new org.eclipse.aether.collection.CollectRequest();
        collectRequest.setRoot(new org.eclipse.aether.graph.Dependency(artifact, scope));
        collectRequest.setRepositories(repositories);

        return new DependencyRequest(collectRequest, classpathFlter);
    }

    private static RepositorySystem newRepositorySystem() {
        org.eclipse.aether.impl.DefaultServiceLocator locator =
            org.apache.maven.repository.internal.MavenRepositorySystemUtils.newServiceLocator();
        locator.addService(org.eclipse.aether.spi.connector.RepositoryConnectorFactory.class,
                           org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory.class);
        locator.addService(org.eclipse.aether.spi.connector.transport.TransporterFactory.class,
                           org.eclipse.aether.transport.file.FileTransporterFactory.class);
        locator.addService(org.eclipse.aether.spi.connector.transport.TransporterFactory.class,
                           org.eclipse.aether.transport.http.HttpTransporterFactory.class);
        return locator.getService(RepositorySystem.class);
    }

    private static RepositorySystemSession newRepositorySystemSession(
            RepositorySystem repositorySystem, Path localRepositoryPath) {
        org.eclipse.aether.DefaultRepositorySystemSession session =
            org.apache.maven.repository.internal.MavenRepositorySystemUtils.newSession();

        org.eclipse.aether.repository.LocalRepository localRepository =
            new org.eclipse.aether.repository.LocalRepository(localRepositoryPath.toString());
        session.setLocalRepositoryManager(repositorySystem.newLocalRepositoryManager(session, localRepository));
        return session;
    }

    static {
        ArrayList<RemoteRepository> defaultRepositories = new ArrayList<RemoteRepository>();
        defaultRepositories.add(
            new RemoteRepository.Builder("central", "default", "https://central.maven.org/maven2/").build());
        defaultRepositories.add(
            new RemoteRepository.Builder("jcenter", "default", "https://jcenter.bintray.com/").build());
        DEFAULT_REPOSITORIES = Collections.unmodifiableList(defaultRepositories);
    }

    private static final List<RemoteRepository> DEFAULT_REPOSITORIES;
}

TestMavenFromJava.java

import org.junit.Assert;
import org.junit.Test;

public class TestMavenFromJava {
    @Test
    public void test() {
        System.out.println("Hello, Test.");
        Assert.assertEquals(1 + 1, 2);
    }
}