import org.eclipse.aether.internal.impl.DefaultRepositorySystem; //导入依赖的package包/类
private RepositorySystem newRepositorySystem() {

		RepositorySystem repoSystem = new DefaultRepositorySystem() {
			@Override
			public ArtifactResult resolveArtifact( RepositorySystemSession session, ArtifactRequest request )
			throws ArtifactResolutionException {

				ArtifactResult res = new ArtifactResult( request );
				Artifact mavenArtifact = ResolveMojoTest.this.artifactIdToArtifact.get( request.getArtifact().getArtifactId());
				if( mavenArtifact == null )
					throw new ArtifactResolutionException( new ArrayList<ArtifactResult>( 0 ), "Error in test wrapper and settings." );

				org.eclipse.aether.artifact.DefaultArtifact art =
						new org.eclipse.aether.artifact.DefaultArtifact(
								"groupId", "artifactId", "classifier", "extension", "version",
								null, mavenArtifact.getFile());

				res.setArtifact( art );
				return res;
			}
		};

		return repoSystem;
	}
 

import org.eclipse.aether.internal.impl.DefaultRepositorySystem; //导入依赖的package包/类
private static ServiceLocator createServiceLocator() {
	DefaultServiceLocator locator = MavenRepositorySystemUtils.newServiceLocator();
	locator.addService(RepositorySystem.class, DefaultRepositorySystem.class);
	locator.addService(RepositoryConnectorFactory.class,
			BasicRepositoryConnectorFactory.class);
	locator.addService(TransporterFactory.class, HttpTransporterFactory.class);
	locator.addService(TransporterFactory.class, FileTransporterFactory.class);
	return locator;
}
 

import org.eclipse.aether.internal.impl.DefaultRepositorySystem; //导入依赖的package包/类
protected RepositorySystem newRepositorySystem() throws PlexusContainerException, ComponentLookupException {
    DefaultServiceLocator locator = MavenRepositorySystemUtils.newServiceLocator();
    locator.addService(RepositorySystem.class, DefaultRepositorySystem.class);
    locator.addService(RepositoryConnectorFactory.class,
            BasicRepositoryConnectorFactory.class);
    locator.addService(TransporterFactory.class, HttpTransporterFactory.class);
    locator.addService(TransporterFactory.class, FileTransporterFactory.class);
    return locator.getService(RepositorySystem.class);
}
 

import org.eclipse.aether.internal.impl.DefaultRepositorySystem; //导入依赖的package包/类
@Override
public MavenArtifact resolveArtifact(
    MavenArtifactKey artifactKey, List<MavenRemoteRepository> repositories)
    throws RemoteException {
  Artifact artifact =
      getMavenComponent(ArtifactFactory.class)
          .createArtifactWithClassifier(
              artifactKey.getGroupId(),
              artifactKey.getArtifactId(),
              artifactKey.getVersion(),
              artifactKey.getPackaging(),
              artifactKey.getClassifier());

  List<ArtifactRepository> repos = new ArrayList<>();
  ArtifactRepositoryFactory factory = getMavenComponent(ArtifactRepositoryFactory.class);
  for (MavenRemoteRepository repository : repositories) {
    try {
      ArtifactRepository artifactRepository =
          ProjectUtils.buildArtifactRepository(
              MavenModelUtil.convertToMavenRepository(repository), factory, container);
      repos.add(artifactRepository);
    } catch (InvalidRepositoryException e) {
      MavenServerContext.getLogger().error(e);
    }
  }

  MavenExecutionRequest request =
      newMavenRequest(
          null, Collections.emptyList(), Collections.emptyList(), Collections.emptyList());
  repos.forEach(request::addRemoteRepository);

  DefaultMaven maven = (DefaultMaven) getMavenComponent(Maven.class);
  RepositorySystemSession repositorySystemSession = maven.newRepositorySession(request);

  org.eclipse.aether.impl.ArtifactResolver artifactResolver =
      getMavenComponent(org.eclipse.aether.impl.ArtifactResolver.class);
  InternalLoggerFactory loggerFactory = new InternalLoggerFactory();
  if (artifactResolver instanceof DefaultArtifactResolver) {
    ((DefaultArtifactResolver) artifactResolver).setLoggerFactory(loggerFactory);
  }

  org.eclipse.aether.RepositorySystem repositorySystem =
      getMavenComponent(org.eclipse.aether.RepositorySystem.class);
  if (repositorySystem instanceof DefaultRepositorySystem) {
    ((DefaultRepositorySystem) repositorySystem).setLoggerFactory(loggerFactory);
  }

  List<RemoteRepository> remoteRepositories =
      RepositoryUtils.toRepos(request.getRemoteRepositories());
  remoteRepositories =
      repositorySystem.newResolutionRepositories(repositorySystemSession, remoteRepositories);

  try {
    ArtifactResult artifactResult =
        repositorySystem.resolveArtifact(
            repositorySystemSession,
            new ArtifactRequest(RepositoryUtils.toArtifact(artifact), remoteRepositories, null));
    return MavenModelUtil.convertArtifact(
        RepositoryUtils.toArtifact(artifactResult.getArtifact()), localRepository);
  } catch (ArtifactResolutionException ignored) {
    // we need ignore exception, it's some times has class that client doesn't has
    // .printStackTrace() may be solution, but it will spam wsagent logs
  }
  return MavenModelUtil.convertArtifact(artifact, localRepository);
}
 

import org.eclipse.aether.internal.impl.DefaultRepositorySystem; //导入依赖的package包/类
public void execute() throws MojoExecutionException {
	IvySettings settings = new IvySettings();
	try {
		File settingsFile = new File(this.settings);
		if (settingsFile.exists()) {
			settings.load(settingsFile);
		} else {
			// maybe a URL?
			settings.load(new URL(this.settings));
		}
	} catch (Exception e) {
		throw new MojoExecutionException("couldn't load ivy settings from '" + this.settings + "'", e);
	}
	Ivy ivy = Ivy.newInstance(settings);

	for (ArtifactItem item : dependencies) {
		// we need to resolve now to calculate the transitive
		// dependencies (if required)
		Set<Artifact> allResolved = resolve(
			ivy,
			item.getGroupId(),
			item.getArtifactId(),
			item.getVersion(),
			item.getClassifier(),
			item.getType(),
			transitive,
			item.getBaseVersion());
		for (Artifact resolved : allResolved) {
			Dependency dep = new Dependency();
			dep.setGroupId(resolved.getGroupId());
			dep.setArtifactId(resolved.getArtifactId());
			dep.setScope(scope);
			dep.setClassifier(resolved.getClassifier());
			dep.setOptional(false);
			dep.setType(resolved.getType());
			dep.setVersion(resolved.getVersion());
			project.getModel().addDependency(dep);
		}
	}

	// force a re-calc of the dependencies so maven picks up our new ones
	project.setDependencyArtifacts(null);

	((DefaultRepositorySystem) repoSystem).setArtifactResolver(new IvyArtifactResolver(ivy, artifactResolver));
}