Versions Compared


  • This line was added.
  • This line was removed.
  • Formatting was changed.


Be sure to read over the documentation for Building Groovy Projects. A Groovy Maven plugin is a Groovy project, so most of the information there is relevant here as well.

Groovy Mojos

Just like Java-based Mojo's at its simplest, a Groovy Mojo consists of a single class. For more complicated plugins you are free to use as many classes as needed of course, just like Java... and you can even write Java classes too if you need too.

Groovy Mojo implementations are denoted by the @goal Javadoc annotation on the class (er, just like Java). Actually, all of the Javadoc annotations which are supported by Java plugins are also supported by Groovy plugins. This is because, when building a Groovy project, the sub-generator spits out Java sources with Javadocs intact, which the Maven Plugin Plugin then parses for annotations (wink)

A Simple Groovy Mojo

Here is our simple Mojo class which has no parameters and spits out a relatively meaningless string via logging:


Lastly, this example mojo extends from org.codehaus.groovy.maven.mojo.GroovyMojo, which is recommended for most Groovy mojos. Of course you can always use org.apache.maven.plugin.AbstractMojo at the cost of some additional bits of happiness which help make your Mojo's groovier.

Building Plugins

Project Definition

Groovy plugins use the same Java plugin descriptor extractor. The Java extractor uses the generated stubs to build the descriptor, so be sure to invoke the generateStubs goal.


Once you have your pom setup then you can build the plugin in the normal way via:

No Format
mvn install

Mojo Parameters

Mojo parameters work exactly the same as they do for Java plugins. Simply define a field in your Mojo implementation and annotate the field with a @parameter Javadoc tag.


The main thing to note about Groovy Mojos and parameters, is that fields should be typed so that Maven (or well, Plexus) can inject objects of the proper type. Using the def keyword is the same as typing the field as and Object which Maven will probably still inject just fine, but it won't perform any conversion.

Putting More Groove into your Mojo

Using ant

Using ant allows your Mojo access to any Ant tasks. Groovy Mojo's which extend from GroovyMojo have access to an AntBuilder instance bound to the ant field.
This field is lazily initialized when you first reference it.



The following examples assume that your Mojo implementation has already defined a project property as in:

Code Block
 * @parameter expression="${project}"
 * @required
 * @readonly
org.apache.maven.project.MavenProject project

Touching a File

No Format
ant.touch(file: "${}/stamp")

Copying Files

No Format
def dir = "${}/backup"
ant.mkdir(dir: dir)
ant.copy(todir: dir) {
    fileset(dir: "${}") {
        include(name: '**/*')

Execute Something

No Format
def propname = 'lsout'
ant.exec(executable: '/bin/ls', outputproperty: propname)
def value =[propname]

Using fail()

Most mojos need to report back some failure status, which is normally done by throwing a MojoExecutionException. Groovy Mojos can simply invoke the fail() method, which handles the details of throwing for you.


No Format
try {
catch (Exception e) {
    fail("She's the village bicycle! Everybody's had a ride.", e)

gmaven-archetype-mojo Archetype

To help get Groovy plugins started faster, you can use the gmaven-archetype-mojo. This will create a new project with the basic POM configuration and an example Groovy-based Mojo class to get you started quickly:


No Format

gmaven-plugin Packaging




Mojo Development

Groovy Development