Java ArtifactResolver类代码示例

import org.apache.maven.artifact.resolver.ArtifactResolver; //导入依赖的package包/类
ForkedRunner(final Log log, final int jmxPort, final String vmArgs, final List<String> testClasspathElements,
             final List<String> stepImplementationArtifacts, final ArtifactResolver artifactResolver,
             final ArtifactFactory artifactFactory, final ProjectBuilder projectBuilder,
             final ArtifactRepository localRepository, final List<ArtifactRepository> remoteRepositories,
             final ArtifactMetadataSource artifactMetadataSource) throws MojoExecutionException {

    this.log = log;
    this.jmxPort = jmxPort;
    this.vmArgs = vmArgs;
    this.testClasspathElements = testClasspathElements;
    this.stepImplementationArtifacts = stepImplementationArtifacts;
    this.artifactResolver = artifactResolver;
    this.artifactFactory = artifactFactory;
    this.projectBuilder = projectBuilder;
    this.localRepository = localRepository;
    this.remoteRepositories = remoteRepositories;
    this.artifactMetadataSource = artifactMetadataSource;

    this.substepsJmxClient = new SubstepsJMXClient();

    this.substepsJmxClient.setNotificiationHandler(this);

    this.consumer = startMBeanJVM();

    initialiseClient();
}
 

import org.apache.maven.artifact.resolver.ArtifactResolver; //导入依赖的package包/类
public void customize(@Nullable MavenWorkspaceMap workspaceMap,
                      boolean failOnUnresolvedDependency,
                      @NotNull MavenServerConsole console,
                      @NotNull MavenServerProgressIndicator indicator,
                      boolean alwaysUpdateSnapshots) {
  try {
    ((CustomArtifactFactory)getComponent(ArtifactFactory.class)).customize();
    ((CustomArtifactFactory)getComponent(ProjectArtifactFactory.class)).customize();
    ((CustomArtifactResolver)getComponent(ArtifactResolver.class)).customize(workspaceMap, failOnUnresolvedDependency);
    ((CustomRepositoryMetadataManager)getComponent(RepositoryMetadataManager.class)).customize(workspaceMap);
    ((CustomWagonManager)getComponent(WagonManager.class)).customize(failOnUnresolvedDependency);

    setConsoleAndIndicator(console, indicator);
  }
  catch (Exception e) {
    throw rethrowException(e);
  }
}
 

import org.apache.maven.artifact.resolver.ArtifactResolver; //导入依赖的package包/类
@Override
public void setComponents(
    MavenWorkspaceCache cache,
    boolean failOnUnresolvedDependency,
    MavenTerminal mavenTerminal,
    MavenServerProgressNotifier notifier,
    boolean alwaysUpdateSnapshot)
    throws RemoteException {

  container.addComponent(getMavenComponent(ArtifactResolver.class, "che"), ArtifactResolver.ROLE);
  ArtifactResolver artifactResolver = getMavenComponent(ArtifactResolver.class);
  if (artifactResolver instanceof CheArtifactResolver) {
    ((CheArtifactResolver) artifactResolver).setWorkspaceCache(cache, failOnUnresolvedDependency);
  }

  buildDate = new Date();
  workspaceCache = cache;
  updateSnapshots = updateSnapshots || alwaysUpdateSnapshot;
  terminalLogger.setTerminal(mavenTerminal);
  mavenProgressNotifier = new MavenServerProgressNotifierImpl(notifier);
}
 

import org.apache.maven.artifact.resolver.ArtifactResolver; //导入依赖的package包/类
public static Collection<Artifact> resolve(
		final ArtifactFactory artifactFactory,
		final ArtifactResolver artifactResolver,
		final ArtifactRepository localRepository,
		final ArtifactMetadataSource artifactMetadataSource,
		final Dependency[] dependencies, final MavenProject project)
		throws InvalidDependencyVersionException,
		ArtifactResolutionException, ArtifactNotFoundException {
	if (dependencies == null) {
		return Collections.emptyList();
	}

	@SuppressWarnings("unchecked")
	final Set<Artifact> artifacts = MavenMetadataSource.createArtifacts(
			artifactFactory, Arrays.asList(dependencies), "runtime", null,
			project);

	for (Artifact artifact : artifacts) {
		artifactResolver.resolve(artifact,

		project.getRemoteArtifactRepositories(), localRepository);
	}

	final Set<Artifact> resolvedArtifacts = artifacts;
	return resolvedArtifacts;
}
 

import org.apache.maven.artifact.resolver.ArtifactResolver; //导入依赖的package包/类
public static Artifact getResolvedArtifact(Dependency dependency, ArtifactFactory artifactFactory,
		List<?> remoteRepositories, ArtifactRepository localRepository, ArtifactResolver resolver, String scope,
		String artifactSystemPath) throws MojoExecutionException {
	String groupId = dependency.getGroupId();
	String artifactId = dependency.getArtifactId();
	String version = dependency.getVersion();
	String type = dependency.getType();

	if (null != artifactSystemPath) {
		return getResolvedArtifact(groupId, artifactId, version, type, scope, new File(artifactSystemPath),
				artifactFactory, remoteRepositories, localRepository, resolver);
	} else {
		return getResolvedArtifact(groupId, artifactId, version, type, scope, null, artifactFactory,
				remoteRepositories, localRepository, resolver);
	}
}
 

import org.apache.maven.artifact.resolver.ArtifactResolver; //导入依赖的package包/类
/**
 * Resolve maven POM of the given artifact
 * 
 * @param dependency
 * @param artifactFactory
 * @param remoteRepositories
 * @param localRepository
 * @param resolver
 * @return resolved POM artifact
 * @throws MojoExecutionException
 */
public static Artifact getResolvedArtifactPom(Dependency dependency, ArtifactFactory artifactFactory,
		List<?> remoteRepositories, ArtifactRepository localRepository, ArtifactResolver resolver)
		throws MojoExecutionException {
	Artifact artifact = artifactFactory.createProjectArtifact(dependency.getGroupId(), dependency.getArtifactId(),
			dependency.getVersion());
	if (null != dependency.getScope()) {
		artifact.setScope(dependency.getScope());
	}
	if (null != dependency.getSystemPath()) {
		artifact.setFile(new File(dependency.getSystemPath()));
	}

	try {
		resolver.resolve(artifact, remoteRepositories, localRepository);
	} catch (ArtifactResolutionException | ArtifactNotFoundException e) {
		throw new MojoExecutionException("Failed to resolve artifacts in specified repositories.", e);
	}
	return artifact;
}
 

import org.apache.maven.artifact.resolver.ArtifactResolver; //导入依赖的package包/类
public static ArrayList getProcessedP2LanucherFiles(ArrayList processedP2LauncherFiles, EquinoxLauncher equinoxLauncher, MavenProject project, ArtifactFactory artifactFactory, List remoteRepositories, ArtifactRepository localRepository, ArtifactResolver resolver) throws MojoExecutionException {
    if (processedP2LauncherFiles != null)
        return processedP2LauncherFiles;
    processedP2LauncherFiles = new ArrayList();
    Iterator iter = equinoxLauncher.getLauncherFiles().iterator();
    while (iter.hasNext()) {
        Object obj = iter.next();
        Bundle b;
        if (obj instanceof FeatureArtifact) {
            b = (Bundle) obj;
        } else if (obj instanceof String) {
            b = Bundle.getBundle(obj.toString());
        } else
            b = (Bundle) obj;
        try {
            b.resolveVersion(project);
        } catch (MojoExecutionException e) {
            b.setVersion(P2Constants.getDefaultVersion(b.getGroupId(), b.getArtifactId()));
            if (b.getVersion() == null)
                throw e;
        }
        b.setArtifact(MavenUtils.getResolvedArtifact(b, artifactFactory, remoteRepositories, localRepository, resolver));
        processedP2LauncherFiles.add(b);
    }
    return processedP2LauncherFiles;
}
 

import org.apache.maven.artifact.resolver.ArtifactResolver; //导入依赖的package包/类
public void customize(@Nullable MavenWorkspaceMap workspaceMap,
                      boolean failOnUnresolvedDependency,
                      @NotNull MavenServerConsole console,
                      @NotNull MavenServerProgressIndicator indicator) {
  try {
    ((CustomArtifactFactory)getComponent(ArtifactFactory.class)).customize();
    ((CustomArtifactFactory)getComponent(ProjectArtifactFactory.class)).customize();
    ((CustomArtifactResolver)getComponent(ArtifactResolver.class)).customize(workspaceMap, failOnUnresolvedDependency);
    ((CustomRepositoryMetadataManager)getComponent(RepositoryMetadataManager.class)).customize(workspaceMap);
    ((CustomWagonManager)getComponent(WagonManager.class)).customize(failOnUnresolvedDependency);

    setConsoleAndIndicator(console, indicator);
  }
  catch (Exception e) {
    throw rethrowException(e);
  }
}
 

import org.apache.maven.artifact.resolver.ArtifactResolver; //导入依赖的package包/类
public ArtifactResolverHelper( ArtifactResolver artifactResolver, Logger log,
                              final List<ArtifactRepository> remoteArtifactRepositories )
{
    this.artifactResolver = artifactResolver;
    this.log = log;
    this.remoteArtifactRepositories = remoteArtifactRepositories;
}
 

import org.apache.maven.artifact.resolver.ArtifactResolver; //导入依赖的package包/类
public DefaultArtifactDownloader(Log log,
                                 ArtifactFactory artifactFactory,
                                 ArtifactResolver artifactResolver,
                                 ArtifactRepository localRepository,
                                 List<ArtifactRepository> remoteArtifactRepositories,
                                 String remoteRepositories,
                                 Map<String, ArtifactRepositoryLayout> repositoryLayouts,
                                 ArtifactRepositoryFactory artifactRepositoryFactory,
                                 ArtifactMetadataSource artifactMetadataSource,
                                 boolean enableOpooPressRepos) {
    this.artifactFactory = artifactFactory;
    this.artifactResolver = artifactResolver;
    this.localRepository = localRepository;
    this.remoteArtifactRepositories = remoteArtifactRepositories;
    this.remoteRepositories = remoteRepositories;
    this.repositoryLayouts = repositoryLayouts;
    this.artifactRepositoryFactory = artifactRepositoryFactory;
    this.artifactMetadataSource = artifactMetadataSource;
    this.enableOpooPressRepos = enableOpooPressRepos;
    this.log = log;
}
 

import org.apache.maven.artifact.resolver.ArtifactResolver; //导入依赖的package包/类
@Test
public void testSimple() throws MojoFailureException {
	JApiCmpMojo mojo = new JApiCmpMojo();
	Version oldVersion = createVersion("groupId", "artifactId", "0.1.0");
	Version newVersion = createVersion("groupId", "artifactId", "0.1.1");
	PluginParameters pluginParameters = new PluginParameters(null, newVersion, oldVersion, new Parameter(), null, Optional.of(Paths.get(System.getProperty("user.dir"), "target", "simple").toFile()), Optional.<String>absent(), true, null, null, null, null);
	ArtifactResolver artifactResolver = mock(ArtifactResolver.class);
	ArtifactResolutionResult artifactResolutionResult = mock(ArtifactResolutionResult.class);
	Set<Artifact> artifactSet = new HashSet<>();
	Artifact resolvedArtifact = mock(Artifact.class);
	artifactSet.add(resolvedArtifact);
	when(resolvedArtifact.getFile()).thenReturn(Paths.get(System.getProperty("user.dir"), "target", "guava-18.0.jar").toFile());
	when(artifactResolutionResult.getArtifacts()).thenReturn(artifactSet);
	when(artifactResolver.resolve(Matchers.<ArtifactResolutionRequest>anyObject())).thenReturn(artifactResolutionResult);
	ArtifactFactory artifactFactory = mock(ArtifactFactory.class);
	when(artifactFactory.createArtifactWithClassifier(eq("groupId"), eq("artifactId"), eq("0.1.1"), anyString(), anyString())).thenReturn(mock(Artifact.class));
	MavenParameters mavenParameters = new MavenParameters(new ArrayList<ArtifactRepository>(), artifactFactory, mock(ArtifactRepository.class), artifactResolver, mock(MavenProject.class), mock(MojoExecution.class), "0.0.1", mock(ArtifactMetadataSource.class));
	mojo.executeWithParameters(pluginParameters, mavenParameters);
	assertThat(Files.exists(Paths.get(System.getProperty("user.dir"), "target", "simple", "japicmp", "japicmp.diff")), is(true));
	assertThat(Files.exists(Paths.get(System.getProperty("user.dir"), "target", "simple", "japicmp", "japicmp.xml")), is(true));
	assertThat(Files.exists(Paths.get(System.getProperty("user.dir"), "target", "simple", "japicmp", "japicmp.html")), is(true));
}
 

import org.apache.maven.artifact.resolver.ArtifactResolver; //导入依赖的package包/类
@Test
public void testIgnoreMissingVersions() throws MojoFailureException, IOException {
	JApiCmpMojo mojo = new JApiCmpMojo();
	Version oldVersion = createVersion("groupId", "artifactId", "0.1.0");
	Version newVersion = createVersion("groupId", "artifactId", "0.1.1");
	Parameter parameterParam = new Parameter();
	parameterParam.setIgnoreMissingNewVersion("true");
	parameterParam.setIgnoreMissingOldVersion("true");
	PluginParameters pluginParameters = new PluginParameters(null, newVersion, oldVersion, parameterParam, null, Optional.of(Paths.get(System.getProperty("user.dir"), "target", "simple").toFile()), Optional.<String>absent(), true, null, null, null, null);
	ArtifactResolver artifactResolver = mock(ArtifactResolver.class);
	ArtifactResolutionResult artifactResolutionResult = mock(ArtifactResolutionResult.class);
	Set<Artifact> artifactSet = new HashSet<>();
	when(artifactResolutionResult.getArtifacts()).thenReturn(artifactSet);
	when(artifactResolver.resolve(Matchers.<ArtifactResolutionRequest>anyObject())).thenReturn(artifactResolutionResult);
	ArtifactFactory artifactFactory = mock(ArtifactFactory.class);
	when(artifactFactory.createArtifactWithClassifier(eq("groupId"), eq("artifactId"), eq("0.1.1"), anyString(), anyString())).thenReturn(mock(Artifact.class));
	MojoExecution mojoExecution = mock(MojoExecution.class);
	String executionId = "ignoreMissingVersions";
	when(mojoExecution.getExecutionId()).thenReturn(executionId);
	MavenParameters mavenParameters = new MavenParameters(new ArrayList<ArtifactRepository>(), artifactFactory, mock(ArtifactRepository.class), artifactResolver, mock(MavenProject.class), mojoExecution, "0.0.1", mock(ArtifactMetadataSource.class));
	mojo.executeWithParameters(pluginParameters, mavenParameters);
	assertThat(Files.exists(Paths.get(System.getProperty("user.dir"), "target", "simple", "japicmp", executionId + ".diff")), is(false));
	assertThat(Files.exists(Paths.get(System.getProperty("user.dir"), "target", "simple", "japicmp", executionId + ".xml")), is(false));
	assertThat(Files.exists(Paths.get(System.getProperty("user.dir"), "target", "simple", "japicmp", executionId + ".html")), is(false));
}
 

import org.apache.maven.artifact.resolver.ArtifactResolver; //导入依赖的package包/类
/**
 * Gathers the project's artifacts and the artifacts of all its (transitive)
 * dependencies filtered by the given filter instance.
 * 
 * @param filter
 * @return
 * @throws ArtifactResolutionException
 * @throws ArtifactNotFoundException
 * @throws ProjectBuildingException
 * @throws InvalidDependencyVersionException
 */
@SuppressWarnings("unchecked")
public static Set<Artifact> findArtifacts(ArtifactFilter filter,
		ArtifactFactory factory, ArtifactResolver resolver,
		MavenProject project, Artifact artifact, ArtifactRepository local,
		List<ArtifactRepository> remoteRepos,
		ArtifactMetadataSource metadataSource)
		throws ArtifactResolutionException, ArtifactNotFoundException,
		ProjectBuildingException, InvalidDependencyVersionException {

	ArtifactResolutionResult result = resolver.resolveTransitively(
			project.getDependencyArtifacts(), artifact, local, remoteRepos,
			metadataSource, filter);

	return (Set<Artifact>) result.getArtifacts();
}
 

import org.apache.maven.artifact.resolver.ArtifactResolver; //导入依赖的package包/类
public DefaultArtifactsResolver( ArtifactResolver theResolver, ArtifactRepository theLocal,
                                List theRemoteRepositories, boolean theStopOnFailure )
{
    this.resolver = theResolver;
    this.local = theLocal;
    this.remoteRepositories = theRemoteRepositories;
    this.stopOnFailure = theStopOnFailure;
}
 

import org.apache.maven.artifact.resolver.ArtifactResolver; //导入依赖的package包/类
private static void setupContainer(PlexusContainer c) {
  MavenEmbedder.setImplementation(c, ArtifactFactory.class, CustomArtifactFactory.class);
  MavenEmbedder.setImplementation(c, ProjectArtifactFactory.class, CustomArtifactFactory.class);
  MavenEmbedder.setImplementation(c, ArtifactResolver.class, CustomArtifactResolver.class);
  MavenEmbedder.setImplementation(c, RepositoryMetadataManager.class, CustomRepositoryMetadataManager.class);
  MavenEmbedder.setImplementation(c, WagonManager.class, CustomWagonManager.class);
  MavenEmbedder.setImplementation(c, ModelInterpolator.class, CustomModelInterpolator.class);
}