Java 使用Maven 2 API获取WAR工件的依赖项

我发现了一些关于工件检索问题的帖子，但是在我的具体案例中，答案似乎不起作用

我正在编写一个插件，它将有助于生成，我正在运行一个为我的EAR maven模块编写的插件。在插件代码中，我已经到了我希望能够获得WAR依赖项的依赖项/工件的阶段——目前，我尝试过的任何东西都无法实现这些依赖项/工件。我认为这是因为即使在我的EAR模块上运行dependency:tree也不包括它们，它们不是“可传递”的依赖项

// 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();

ArtifactRepository localRepository=project.getDistributionManagementArtifactRepository（）；
List remoteRepositories=project.getRemoteArtifactRepositories（）；
ResolutionGroup ResolutionGroup=artifactMetadataSource.retrieve（warArtifact、localRepository、remoteRepositories）；
Set artifactDependencies=resolutionGroup.getArtifacts（）；

（注意：这是利用项目的

ArtifactMetadataSource

组件对象和依赖项

maven依赖项插件：2.4

）

这是行不通的。

artifactDependencies

集为空。现在这必须是可能的，因为在模块

warArtifact

的目录中运行

mvn dependency:tree

，工作正常

---

有什么想法吗？

我终于有了答案。诚然，这并不能很好地回答我最初的问题，但这正是我的答案

它不能完全回答我原来的帖子的原因：它需要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());
    }


    // ...
}

import org.apache.maven.plugin.AbstractMojo；
导入org.apache.maven.plugin.MojoExecutionException；
导入org.apache.maven.project.MavenProject；
导入org.sonatype.ether.RepositorySystem；
导入org.sonatype.ether.RepositorySystemSession；
导入org.sonatype.ether.artifact.artifact；
导入org.sonatype.ether.collection.CollectRequest；
导入org.sonatype.ether.graph.Dependency；
导入org.sonatype.ether.graph.DependencyNode；
导入org.sonatype.ether.repository.RemoteRepository；
导入org.sonatype.ether.resolution.DependencyRequest；
导入org.sonatype.ether.util.artifact.DefaultArtifact；
导入org.sonatype.ether.util.graph.PreorderNodeListGenerator；
导入java.util.ArrayList；
导入java.util.List；
/**
*
*@goal-findShareables
*@阶段过程资源
*/
@抑制警告（“未选中”）
公共类ShareableJarsinWarsex拖拉机扩展抽象MOJO
{
// ...
/**
*MavenProject对象。
*
*@parameter expression=“${project}”
*@readonly
*/
私人马文项目；
/**
*乙醚的入口点，即完成所有工作的部件。
*
*@组件
*/
私人回购系统；
/**
*Maven的当前存储库/网络配置。
*
*@parameter default value=“${repositorySystemSession}”
*@readonly
*/
私有RepositorySystemSession reposition；
/**
*用于解析插件及其依赖项的项目远程存储库。
*
*@parameter default value=“${project.remotePluginRepositories}”
*@readonly
*/
私人回购；
public void execute（）引发MojoExecutionException异常
{
工件projectArtifact=getProjectArtifact（）；
List projectDependencies=getArtifactsDependencies（projectArtifact）；
对于（依赖项d:projectDependencies）
{
如果（d.getArtifact（）！=null&“war”.equals（d.getArtifact（）.getExtension（）））
{
List-warDependencies=getArtifactsDependencies（d.getArtifact（））；
//我现在拥有了战争的所有依赖！！万岁！
// ...
}
}
// ...
}
私有列表getArtifactsDependencies（工件a）
{
List ret=new ArrayList（）；
//注意：我得到的是POM神器，不是战争或其他东西。
DefaultArtifact-pomArtifact=新的DefaultArtifact（a.getGroupId（），a.getArtifactId（），“pom”，a.getVersion（））；
CollectRequest CollectRequest=新CollectRequest（）；
setRoot（新的依赖项（pomArtifact，“compile”）；
collectRequest.setRepositories（remoteRepos）；
尝试
{
DependencyNode节点=repoSystem.collectDependencies（repoSession，collectRequest）.getRoot（）；
DependencyRequest项目DependencyRequest=新DependencyRequest（节点，空）；
resolveDependencies（repoSession、projectDependencyRequest）；
PreorderNodeListGenerator nlg=新的PreorderNodeListGenerator（）；
接受节点（nlg）；
ret.addAll（nlg.getDependencies（true））；
}
捕获（例外e）
{
e、 printStackTrace（）；
}
返回ret；
}
私有工件getProjectArtifact（）
{
//托多：一定有更好的办法！
返回新的DefaultArtifact（project.getArtifact（）.toString（））；
}
// ...
}

My 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>

org.apache.maven.plugins
maven依赖插件
2.4
org.apache.maven
maven插件api
3.0.4
org.apache.maven
maven模型
3.0.4
org.apache.maven
马文堆芯
3.0.4
org.apache.maven
马文伪影
3.0.4