如何以编程方式调用 Maven 依赖插件

Question

我正在尝试以编程方式调用 maven-dependency-plugin 。我正在使用 Maven 3 版本。问题是，当我通过pluginManager.executeMojo(session,execution)调用它时，我收到以下错误消息：

[ERROR] **The parameters 'project', 'local', 'remoteRepos',
'reactorProjects' for goal
org.apache.maven.plugins:maven-dependency-plugin:2.1:unpack are
missing or invalid**
**org.apache.maven.plugin.PluginParameterException: The parameters 'project',
'local', 'remoteRepos', 'reactorProjects' for goal
org.apache.maven.plugins:maven-dependency-plugin:2.1:unpack are missing or
invalid**
        at org.apache.maven.plugin.internal.DefaultMavenPluginManager
        .populatePluginFields(DefaultMavenPluginManager.java:518)
        at org.apache.maven.plugin.internal.DefaultMavenPluginManager
        .getConfiguredMojo(DefaultMavenPluginManager.java:471)
        at org.apache.maven.plugin.DefaultBuildPluginManager
        .executeMojo(DefaultBuildPluginManager.java:99)
        at com.sap.ldi.qi.osgi.OSGiManifesrMfHandlerMojo
        .invokeMavenDependencyPlugin(OSGiManifesrMfHandlerMojo.java:139)
        at com.sap.ldi.qi.osgi.OSGiManifesrMfHandlerMojo
        .execute(OSGiManifesrMfHandlerMojo.java:100)
        at org.apache.maven.plugin.DefaultBuildPluginManager
        .executeMojo(DefaultBuildPluginManager.java:110)
        at org.apache.maven.lifecycle.internal.MojoExecutor
        .execute(MojoExecutor.java:144)
        at org.apache.maven.lifecycle.internal.MojoExecutor
        .execute(MojoExecutor.java:87)
        at org.apache.maven.lifecycle.internal.MojoExecutor
        .execute(MojoExecutor.java:79)
-- many lines stripped from stack trace --
[INFO] ----------------------------------------------------------------------
[INFO] BUILD FAILURE
[INFO] ----------------------------------------------------------------------
[INFO] Total time: 17.938s
[INFO] Finished at: Mon Nov 22 10:27:42 EET 2010
[INFO] Final Memory: 12M/23M
[INFO] ----------------------------------------------------------------------
[ERROR] Failed to execute goal
com.sap.ldi.qi:osgi-manifest-handler-plugin:0.0.1-SNAPSHOT:handle
(osgi-manifest-handler plugin) on project com.sap.ldi.demo.calc
.cmd.tests: The parameters 'project', 'local', 'remoteRepos',
'reactorProjects' for goal
org.apache.maven.plugins:maven-dependency-plugin:2.1:unpack are missing
or invalid -> [Help 1]
-- stripped rest --

据我所知，maven依赖插件的解包目标唯一需要的参数是artifactItems。我使用 PluginExecution.setConfiguration() 方法设置插件配置。看来这个插件配置没有正确设置。 您知道为什么会引发此异常吗？

这是我正在使用的配置：

<configuration>
  <artifactItems>
    <artifactItem>
      <groupId>com.sap.ldi.demo.calc</groupId>
      <artifactId>com.sap.ldi.demo.calc.cmd</artifactId>
      <version>0.1.2-SNAPSHOT</version>
      <type>jar</type>
      <overWrite>true</overWrite>
      <outputDirectory>target/demo-calc-stuff</outputDirectory>
      <includes>**/*.*</includes>
    </artifactItem>
  </artifactItems>
</configuration>

谢谢

---

我这边的一个更正。使用的Maven版本不是Maven 3.0，而是Maven 3.0-beta-1。我看到 3.0-beta-1 版本中的 BuildPluginManager.loadPlugin() 有两个参数，3.0 版本中的相同方法有三个。 我想知道，是否有人尝试使用 maven 3.0 或 maven 3.0-beta-1 以编程方式调用 maven 插件。我仍在尝试使用 maven 3.0-beta-1 调用它，但它仍然返回与上面粘贴的相同的异常。

Answer 1

这是为 Maven 3 设计的 Mojo Executor 的更新版本：

package com.googlecode.boostmavenproject;

import java.util.Collections;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.model.Plugin;
import org.apache.maven.plugin.MojoExecution;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.descriptor.PluginDescriptor;
import org.apache.maven.project.MavenProject;
import org.codehaus.plexus.util.xml.Xpp3Dom;
import org.apache.maven.plugin.BuildPluginManager;
import org.apache.maven.plugin.descriptor.MojoDescriptor;
import org.codehaus.plexus.configuration.PlexusConfiguration;
import org.codehaus.plexus.util.xml.Xpp3DomUtils;
import org.sonatype.aether.repository.RemoteRepository;

/**
 * Executes an arbitrary mojo using a fluent interface.  This is meant to be executed within the context of a Maven 2
 * mojo.
 *
 * Here is an execution that invokes the dependency plugin:
 * <pre>
 * executeMojo(
 *              plugin(
 *                      groupId("org.apache.maven.plugins"),
 *                      artifactId("maven-dependency-plugin"),
 *                      version("2.0")
 *              ),
 *              goal("copy-dependencies"),
 *              configuration(
 *                      element(name("outputDirectory"), "${project.build.directory}/foo")
 *              ),
 *              executionEnvironment(
 *                      project,
 *                      session,
 *                      pluginManager
 *              )
 *          );
 * </pre>
 * @see http://code.google.com/p/mojo-executor/
 */
public class MojoExecutor
{
    /**
     * Entry point for executing a mojo
     *
     * @param plugin The plugin to execute
     * @param goal The goal to execute
     * @param configuration The execution configuration
     * @param env The execution environment
     * @throws MojoExecutionException If there are any exceptions locating or executing the mojo
     */
    public static void executeMojo(Plugin plugin, String goal, Xpp3Dom configuration,
                                                                 ExecutionEnvironment env) throws MojoExecutionException
    {
        if (configuration == null)
            throw new NullPointerException("configuration may not be null");
        try
        {
            MavenSession session = env.getMavenSession();

            PluginDescriptor pluginDescriptor = env.getPluginManager().loadPlugin(plugin,
                Collections.<RemoteRepository>emptyList(), session.getRepositorySession());
            MojoDescriptor mojo = pluginDescriptor.getMojo(goal);
            if (mojo == null)
            {
                throw new MojoExecutionException("Could not find goal '" + goal + "' in plugin "
                                                                                 + plugin.getGroupId() + ":"
                                                                                 + plugin.getArtifactId() + ":"
                                                                                 + plugin.getVersion());
            }
            configuration = Xpp3DomUtils.mergeXpp3Dom(configuration,
                toXpp3Dom(mojo.getMojoConfiguration()));
            MojoExecution exec = new MojoExecution(mojo, configuration);
            env.getPluginManager().executeMojo(session, exec);
        }
        catch (Exception e)
        {
            throw new MojoExecutionException("Unable to execute mojo", e);
        }
    }

    /**
     * Converts PlexusConfiguration to a Xpp3Dom.
     *
     * @param config the PlexusConfiguration
     * @return the Xpp3Dom representation of the PlexusConfiguration
     */
    private static Xpp3Dom toXpp3Dom(PlexusConfiguration config)
    {
        Xpp3Dom result = new Xpp3Dom(config.getName());
        result.setValue(config.getValue(null));
        for (String name: config.getAttributeNames())
            result.setAttribute(name, config.getAttribute(name));
        for (PlexusConfiguration child: config.getChildren())
            result.addChild(toXpp3Dom(child));
        return result;
    }

    /**
     * Constructs the {@link ExecutionEnvironment} instance fluently
     * @param mavenProject The current Maven project
     * @param mavenSession The current Maven session
     * @param pluginManager The Build plugin manager
     * @return The execution environment
     * @throws NullPointerException if mavenProject, mavenSession or pluginManager
     *   are null
     */
    public static ExecutionEnvironment executionEnvironment(MavenProject mavenProject,
                                                                                                                    MavenSession mavenSession,
                                                                                                                    BuildPluginManager pluginManager)
    {
        return new ExecutionEnvironment(mavenProject, mavenSession, pluginManager);
    }

    /**
     * Builds the configuration for the goal using Elements
     * @param elements A list of elements for the configuration section
     * @return The elements transformed into the Maven-native XML format
     */
    public static Xpp3Dom configuration(Element... elements)
    {
        Xpp3Dom dom = new Xpp3Dom("configuration");
        for (Element e: elements)
            dom.addChild(e.toDom());
        return dom;
    }

    /**
     * Defines the plugin without its version
     * @param groupId The group id
     * @param artifactId The artifact id
     * @return The plugin instance
     */
    public static Plugin plugin(String groupId, String artifactId)
    {
        return plugin(groupId, artifactId, null);
    }

    /**
     * Defines a plugin
     * @param groupId The group id
     * @param artifactId The artifact id
     * @param version The plugin version
     * @return The plugin instance
     */
    public static Plugin plugin(String groupId, String artifactId, String version)
    {
        Plugin plugin = new Plugin();
        plugin.setArtifactId(artifactId);
        plugin.setGroupId(groupId);
        plugin.setVersion(version);
        return plugin;
    }

    /**
     * Wraps the group id string in a more readable format
     * @param groupId The value
     * @return The value
     */
    public static String groupId(String groupId)
    {
        return groupId;
    }

    /**
     * Wraps the artifact id string in a more readable format
     * @param artifactId The value
     * @return The value
     */
    public static String artifactId(String artifactId)
    {
        return artifactId;
    }

    /**
     * Wraps the version string in a more readable format
     * @param version The value
     * @return The value
     */
    public static String version(String version)
    {
        return version;
    }

    /**
     * Wraps the goal string in a more readable format
     * @param goal The value
     * @return The value
     */
    public static String goal(String goal)
    {
        return goal;
    }

    /**
     * Wraps the element name string in a more readable format
     * @param name The value
     * @return The value
     */
    public static String name(String name)
    {
        return name;
    }

    /**
     * Constructs the element with a textual body
     * @param name The element name
     * @param value The element text value
     * @return The element object
     */
    public static Element element(String name, String value)
    {
        return new Element(name, value);
    }

    /**
     * Constructs the element containg child elements
     * @param name The element name
     * @param elements The child elements
     * @return The Element object
     */
    public static Element element(String name, Element... elements)
    {
        return new Element(name, elements);
    }

    /**
     * Element wrapper class for configuration elements
     */
    public static class Element
    {
        private final Element[] children;
        private final String name;
        private final String text;

        public Element(String name, Element... children)
        {
            this(name, null, children);
        }

        public Element(String name, String text, Element... children)
        {
            this.name = name;
            this.text = text;
            this.children = children;
        }

        public Xpp3Dom toDom()
        {
            Xpp3Dom dom = new Xpp3Dom(name);
            if (text != null)
            {
                dom.setValue(text);
            }
            for (Element e: children)
            {
                dom.addChild(e.toDom());
            }
            return dom;
        }
    }

    /**
     * Collects Maven execution information
     */
    public static class ExecutionEnvironment
    {
        private final MavenProject mavenProject;
        private final MavenSession mavenSession;
        private final BuildPluginManager pluginManager;

        public ExecutionEnvironment(MavenProject mavenProject, MavenSession mavenSession,
                                                                BuildPluginManager pluginManager)
        {
            if (mavenProject == null)
                throw new NullPointerException("mavenProject may not be null");
            if (mavenSession == null)
                throw new NullPointerException("mavenSession may not be null");
            if (pluginManager == null)
                throw new NullPointerException("pluginManager may not be null");
            this.mavenProject = mavenProject;
            this.mavenSession = mavenSession;
            this.pluginManager = pluginManager;
        }

        public MavenProject getMavenProject()
        {
            return mavenProject;
        }

        public MavenSession getMavenSession()
        {
            return mavenSession;
        }

        public BuildPluginManager getPluginManager()
        {
            return pluginManager;
        }
    }
}

我将尝试将我的更改贡献回官方 Mojo Executor 插件。

Answer 2

伙计们，我想我明白了。
问题不在于我使用的 Maven 版本。它位于我用于调用 maven-dependency-plugin 的配置中。 maven-dependency-plugin 的解包目标需要以下参数：artifactItems、local、project、reactorProjects 和远程存储库。以下是用于调用插件的正确配置版本：

<configuration>
    <artifactItems>
    <artifactItem>
      <groupId>com.sap.ldi.demo.calc</groupId>
      <artifactId>com.sap.ldi.demo.calc.cmd</artifactId>
      <version>0.1.3-SNAPSHOT</version>
      <type>jar</type>
      <overWrite>true</overWrite>
      <outputDirectory>target/demo-calc-stuff</outputDirectory>
      <includes>**/*.*</includes>
    </artifactItem>
  </artifactItems>
  <local>${localRepository}</local>
  <project>${project}</project>
  <reactorProjects>${reactorProjects}</reactorProjects>
  <remoteRepos>${project.remoteArtifactRepositories}</remoteRepos>
</configuration>`

Answer 3

Maven 插件并不意味着以编程方式调用。

它们依赖于底层 plexus 容器注入的值。

因此，要么您必须找出如何注入这些值，要么必须依赖默认机制。

您可以使用的一件事是 Maven Invoker。这样，您就可以以编程方式启动 Maven 生命周期，但它们将在单独的虚拟机中执行。因此，如果您需要预先动态更改模型，则需要将模型序列化为临时 pom.xml 并将其与 Maven 调用程序一起使用。这是一件很繁重的事情，但我大约两年前就成功地完成了。