Add maven-build-classpath to plugin execution classpath

Roman picture Roman · Apr 17, 2010 · Viewed 15.6k times · Source

I am writing some code-gen maven-plugin.

I need my project classpath be injected in to my plugin execution classpath.

I found this article. The solution there works but is quite long. Maybe someone of you know an out of the box solution.

Answer

Roman picture Roman · Apr 17, 2010

Found the answer!

OK , Pascal is right , here it is for the foundation!!

So here is the cleanest way ( as far as i know ) to add the compile classpath to the execution of you plugin.

Here are some code samples from my code-gen plugin, that is actually generating some template code based on the code compiled. So I needed first the code compiled, then analyzed, generate some code, and then compiled again.

  1. Use @configurator in the Mojo class:

    /**
     * @goal generate
     * @phase process-classes
     * @configurator include-project-dependencies
     * @requiresDependencyResolution compile+runtime
     */
    public class CodeGenMojo
            extends AbstractMojo
    {
        public void execute()
                throws MojoExecutionException
        {
             // do work....   
        }
    }
    

    Please pay attention to the @configurator line in the javadoc header, it is essetial for the plexus IOC container and is not just another comment line.

  2. The implementation of the include-project-dependencies configurator. There is this very nice class that I took from some Brian Jackson, add it to the source of your plugin.

    /**
     * A custom ComponentConfigurator which adds the project's runtime classpath elements
     * to the
     *
     * @author Brian Jackson
     * @since Aug 1, 2008 3:04:17 PM
     *
     * @plexus.component role="org.codehaus.plexus.component.configurator.ComponentConfigurator"
     *                   role-hint="include-project-dependencies"
     * @plexus.requirement role="org.codehaus.plexus.component.configurator.converters.lookup.ConverterLookup"
     *                   role-hint="default"
     */
    public class IncludeProjectDependenciesComponentConfigurator extends AbstractComponentConfigurator { 
    
        private static final Logger LOGGER = Logger.getLogger(IncludeProjectDependenciesComponentConfigurator.class);
    
        public void configureComponent( Object component, PlexusConfiguration configuration,
                                        ExpressionEvaluator expressionEvaluator, ClassRealm containerRealm,
                                        ConfigurationListener listener )
            throws ComponentConfigurationException {
    
            addProjectDependenciesToClassRealm(expressionEvaluator, containerRealm);
    
            converterLookup.registerConverter( new ClassRealmConverter( containerRealm ) );
    
            ObjectWithFieldsConverter converter = new ObjectWithFieldsConverter();
    
            converter.processConfiguration( converterLookup, component, containerRealm.getClassLoader(), configuration,
                                            expressionEvaluator, listener );
        }
    
        private void addProjectDependenciesToClassRealm(ExpressionEvaluator expressionEvaluator, ClassRealm containerRealm) throws ComponentConfigurationException {
            List<String> runtimeClasspathElements;
            try {
                //noinspection unchecked
                runtimeClasspathElements = (List<String>) expressionEvaluator.evaluate("${project.runtimeClasspathElements}");
            } catch (ExpressionEvaluationException e) {
                throw new ComponentConfigurationException("There was a problem evaluating: ${project.runtimeClasspathElements}", e);
            }
    
            // Add the project dependencies to the ClassRealm
            final URL[] urls = buildURLs(runtimeClasspathElements);
            for (URL url : urls) {
                containerRealm.addConstituent(url);
            }
        }
    
        private URL[] buildURLs(List<String> runtimeClasspathElements) throws ComponentConfigurationException {
            // Add the projects classes and dependencies
            List<URL> urls = new ArrayList<URL>(runtimeClasspathElements.size());
            for (String element : runtimeClasspathElements) {
                try {
                    final URL url = new File(element).toURI().toURL();
                    urls.add(url);
                    if (LOGGER.isDebugEnabled()) {
                        LOGGER.debug("Added to project class loader: " + url);
                    }
                } catch (MalformedURLException e) {
                    throw new ComponentConfigurationException("Unable to access project dependency: " + element, e);
                }
            }
    
            // Add the plugin's dependencies (so Trove stuff works if Trove isn't on
            return urls.toArray(new URL[urls.size()]);
        }
    
    }
    
  3. Here is the build part of my plugin that you will have to add.

    <modelVersion>4.0.0</modelVersion>
    <groupId>com.delver</groupId>
    <artifactId>reference-gen-plugin</artifactId>
    <name>Reference Code Genration Maven Plugin</name>
    
    <packaging>maven-plugin</packaging>
    <version>1.2</version>
    
    <url>http://maven.apache.org</url>
    
    <properties>
        <maven.version>2.2.1</maven.version>
    </properties>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.codehaus.plexus</groupId>
                <artifactId>plexus-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>descriptor</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
    <dependencies>
    
        <dependency>
            <groupId>org.apache.maven</groupId>
            <artifactId>maven-artifact</artifactId>
            <version>${maven.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.maven</groupId>
            <artifactId>maven-plugin-api</artifactId>
            <version>${maven.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.maven</groupId>
            <artifactId>maven-project</artifactId>
            <version>${maven.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.maven</groupId>
            <artifactId>maven-model</artifactId>
            <version>${maven.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.maven</groupId>
            <artifactId>maven-core</artifactId>
            <version>2.0.9</version>
        </dependency>
    
    </dependencies>
    

    Here is the pom.xml of the plugin for these who need it. Should compile wihtout a problem now. ( something wrong with the header, so ignore it )