使用Maven 2 API获得WAR工件的依赖关系

Question

我发现了一些围绕工件检索问题的帖子，但是在我的具体情况下，答案似乎不起作用。

我正在写一个插件，将有助于skinny war EAR一代，我正在运行一个我为我的EAR maven模块编写的插件。在插件代码中，我已经到了想要获得WAR依赖关系的依赖关系/工件的阶段 - 目前这些并没有通过我尝试过的任何东西。我认为这是因为即使在我的EAR模块上运行依赖项：树也不包含它们，它们不是“传递”依赖项。

// Neither of the two below return WAR transitive dependencies, just the WARs 
project.getDependencies() 
project.getArtifacts() 

我的新方法是目前这样的：

ArtifactRepository localRepository = project.getDistributionManagementArtifactRepository(); 
List remoteRepositories = project.getRemoteArtifactRepositories(); 

ResolutionGroup resolutionGroup = artifactMetadataSource.retrieve(warArtifact, localRepository, remoteRepositories); 
Set<Artifact> artifactDependencies = resolutionGroup.getArtifacts(); 

（注：这是利用项目的ArtifactMetadataSource组件对象和依赖maven-dependency-plugin:2.4）

这是不工作。 artifactDependencies设置为空。现在这一定是可能的，因为在模块warArtifact的目录中运行mvn dependency:tree可以正常工作。

任何想法？

Answer 1

我终于有了答案。诚然，它不能正确回答我原来的问题，但这是我所做的。

原因，它不完全回答我的原帖：它需要的Maven 3

这无论如何对于那些有兴趣：

import org.apache.maven.plugin.AbstractMojo; 
import org.apache.maven.plugin.MojoExecutionException; 
import org.apache.maven.project.MavenProject; 
import org.sonatype.aether.RepositorySystem; 
import org.sonatype.aether.RepositorySystemSession; 
import org.sonatype.aether.artifact.Artifact; 
import org.sonatype.aether.collection.CollectRequest; 
import org.sonatype.aether.graph.Dependency; 
import org.sonatype.aether.graph.DependencyNode; 
import org.sonatype.aether.repository.RemoteRepository; 
import org.sonatype.aether.resolution.DependencyRequest; 
import org.sonatype.aether.util.artifact.DefaultArtifact; 
import org.sonatype.aether.util.graph.PreorderNodeListGenerator; 

import java.util.ArrayList; 
import java.util.List; 

/** 
* 
* @goal findShareables 
* @phase process-resources 
*/ 
@SuppressWarnings("unchecked") 
public class ShareableJarsInWarsExtractor extends AbstractMojo 
{ 
    // ... 

    /** 
    * The MavenProject object. 
    * 
    * @parameter expression="${project}" 
    * @readonly 
    */ 
    private MavenProject project; 

    /** 
    * The entry point to Aether, i.e. the component doing all the work. 
    * 
    * @component 
    */ 
    private RepositorySystem repoSystem; 

    /** 
    * The current repository/network configuration of Maven. 
    * 
    * @parameter default-value="${repositorySystemSession}" 
    * @readonly 
    */ 
    private RepositorySystemSession repoSession; 

    /** 
    * The project's remote repositories to use for the resolution of plugins and their dependencies. 
    * 
    * @parameter default-value="${project.remotePluginRepositories}" 
    * @readonly 
    */ 
    private List<RemoteRepository> remoteRepos; 


    public void execute() throws MojoExecutionException 
    { 
     Artifact projectArtifact = getProjectArtifact(); 
     List<Dependency> projectDependencies = getArtifactsDependencies(projectArtifact); 

     for (Dependency d : projectDependencies) 
     { 
      if (d.getArtifact() != null && "war".equals(d.getArtifact().getExtension())) 
      { 
       List<Dependency> warDependencies = getArtifactsDependencies(d.getArtifact()); 
       // I now have all of the WAR's dependencies!! Hooray! 

       // ... 
      } 
     } 

     // ... 
    } 


    private List<Dependency> getArtifactsDependencies(Artifact a) 
    { 
     List<Dependency> ret = new ArrayList<Dependency>(); 

     // Note: I get the POM artifact, not the WAR or whatever. 
     DefaultArtifact pomArtifact = new DefaultArtifact(a.getGroupId(), a.getArtifactId(), "pom", a.getVersion()); 
     CollectRequest collectRequest = new CollectRequest(); 
     collectRequest.setRoot(new Dependency(pomArtifact, "compile")); 
     collectRequest.setRepositories(remoteRepos); 

     try 
     { 
      DependencyNode node = repoSystem.collectDependencies(repoSession, collectRequest).getRoot(); 
      DependencyRequest projectDependencyRequest = new DependencyRequest(node, null); 

      repoSystem.resolveDependencies(repoSession, projectDependencyRequest); 

      PreorderNodeListGenerator nlg = new PreorderNodeListGenerator(); 
      node.accept(nlg); 

      ret.addAll(nlg.getDependencies(true)); 
     } 
     catch (Exception e) 
     { 
      e.printStackTrace(); 
     } 

     return ret; 
    } 


    private Artifact getProjectArtifact() 
    { 
     // Todo: There must be a better way! 
     return new DefaultArtifact(project.getArtifact().toString()); 
    } 


    // ... 
} 

我的POM定义了如下依赖关系：

 <dependency> 
      <groupId>org.apache.maven.plugins</groupId> 
      <artifactId>maven-dependency-plugin</artifactId> 
      <version>2.4</version> 
     </dependency> 

     <dependency> 
      <groupId>org.apache.maven</groupId> 
      <artifactId>maven-plugin-api</artifactId> 
      <version>3.0.4</version> 
     </dependency> 
     <dependency> 
      <groupId>org.apache.maven</groupId> 
      <artifactId>maven-model</artifactId> 
      <version>3.0.4</version> 
     </dependency> 
     <dependency> 
      <groupId>org.apache.maven</groupId> 
      <artifactId>maven-core</artifactId> 
      <version>3.0.4</version> 
     </dependency> 
     <dependency> 
      <groupId>org.apache.maven</groupId> 
      <artifactId>maven-artifact</artifactId> 
      <version>3.0.4</version> 
     </dependency>