Guide to Developing Java Maven/Mojo Plugins

Guide to Developing Java Maven/Mojo Plugins. How to develop Java plugines? As a Java developer, you might have heard about Maven plugins. But do you know what a maven plugin is, the advantages of using maven, and how to create one?

To help you understand, we will cover everything about developing Java Maven plugins.

So, without further ado, let’s dive into it!

What is Maven?

Maven, previously known as Jakarta, is a powerful build tool hosted by the Apache Foundation. It assists developers to manage their projects in a standardized manner. Maven helps with source code compilation, dependency management, running tests, and deployable code production.

Read: How to Build a Web Application Using Java

Put simply, Maven is used as a management and build tool primarily for projects based on Java, but it can also be used for Ruby, C#, and other languages. It is based on Project Object Model or POM - an XML file containing information about the configuration and project used to build the project. Maven is the core framework for Maven plugins.

Maven Plugin and its Types

With a better understanding of Maven, let’s learn what Maven Plugins are and how they work. In simple terms, Maven plugins are Maven’s fundamental feature allowing developers to reuse a set of common build logic into different projects by either creating documentation, compiling unit tests, code compilation, or building a WAR file based on the project description.

Read: Top 10 Java Libraries

Maven plugins are divided into build and reporting, where build plugins are configured in the POM file’s <build/> element and executed during the build phase. On the other hand, the reporting plugin is configured in the POM file’s <reporting/> element and executed during the process of site generation.

What is a Mojo?

This brings us to our next section - what is Mojo? Mojo or Maven Plain Old Java Object, also defined as annotated Java classes, is an executable goal in the Maven project. And any maven plugin is the distribution of related mojos. It helps in expanding Maven functionality that is not available there.

Read: How to Build Microservices in Java

Mojo APIs can also be referred to as the interface that forms the contract needed for Mojos to communicate or interact with the infrastructure of Maven.

Advantages of Using Maven

Some of the major benefits of using Maven in your project are:

• It simplifies the project-building process.

• Maven helps in managing project management processes like documentation, building, releasing, and distributing.

• It makes it easier to build a project in different environments.

• Maven can identify dependencies outside of the source code in the software.

• Automatically downloads Jar files along with other dependencies

• By writing dependency code in the POM file, Maven makes it easier to add new dependencies to the application.

Read: Structural Design Patterns in Java

How to Create a Maven Plugin?

Before getting started with developing the Maven plugin, you need to install Apache Maven in the integrated development environment (IDE) to set up the project.

Read: Java For Data Science

Typically, the plugin name will be written as <pluginname>-maven-plugin. Remember, using “maven” at the beginning as maven-<pluginname>-plugin is strongly discouraged as this naming pattern is reserved for official plugins maintained by the Apache Maven team.

Read: Using Proxies with Java Web Scraping

Also, to create a maven project, you will have to select the maven archetype (a project template) and provide artifactid, groupid, and version in the pom.xml file as below:

<project>     <modelVersion>4.0.0</modelVersion>     <groupId>decipherzone.plugin</groupId>     <artifactId>example-maven-plugin</artifactId>     <packaging>maven-plugin</packaging>     <version>1.0-SNAPSHOT</version>     <name>example-maven-plugin Maven Mojo</name>     <url>http://maven.apache.org</url>     <properties>         <maven.compiler.target>11</maven.compiler.target>         <maven.compiler.source>11</maven.compiler.source>     </properties> </project>

Now that we have created the pom.xml file, it is time to add some dependencies it will have:

<dependencies>     <dependency>         <groupId>org.apache.maven</groupId>         <artifactId>maven-plugin-api</artifactId>         <version>3.9.2</version>     </dependency>     <dependency>         <groupId>org.apache.maven.plugin-tools</groupId>         <artifactId>maven-plugin-annotations</artifactId>         <version>3.7.0</version>         <scope>provided</scope>     </dependency>     <dependency>         <groupId>org.apache.maven</groupId>         <artifactId>maven-project</artifactId>         <version>2.2.1</version>     </dependency> </dependencies>

Here the maven-plugin-api dependency includes interfaces and classes to create project mojo; maven-plugin-annotations assists in using annotations in classes; and maven-project dependency is used for accessing project information.

To execute the new plugin you have created, you will need to specify its goal on the command line by first configuring the example-maven-plugins as:

...   <build>     <pluginManagement>       <plugins>         <plugin>           <groupId>decipherzone.plugin</groupId>           <artifactId>example-maven-plugin</artifactId>           <version>1.0-SNAPSHOT</version>         </plugin>       </plugins>     </pluginManagement>   </build> ...

Now specify the plugin goal as:

mvn decipherzone.plugin:example-maven-plugin:1.0-SNAPSHOT:sayhello

To attach the Mojo to the build cycle, you need to configure the plugin as follows:

<build>     <pluginManagement>       <plugins>         <plugin>           <groupId>decipherzone.plugin</groupId>           <artifactId>example-maven-plugin</artifactId>           <version>1.0-SNAPSHOT</version>         </plugin>       </plugins>     </pluginManagement>      <plugins>       <plugin>         <groupId>decipherzone.plugin</groupId>         <artifactId>example-maven-plugin</artifactId>         <executions>           <execution>             <phase>compile</phase>             <goals>               <goal>sayhello</goal>             </goals>           </execution>         </executions>       </plugin>     </plugins>   </build>

This will help in executing the Mojo at the time of Java code compilation.

Also, you can use the Mojo archetype to create a new plugin project as given below:

mvn archetype:generate \   -DgroupId=decipherzone.plugin \   -DartifactId=example-maven-plugin \   -DarchetypeGroupId=org.apache.maven.archetypes \   -DarchetypeArtifactId=maven-archetype-plugin

A simple Mojo defines parameter as:

  @Parameter( property = "sayhello.greeting", defaultValue = "Hello There!" )
    private String greeting;

Conclusion

So that was all about developing a maven plugin for Java. We hope you find the article helpful and interesting. Needless to say, Maven can be highly useful for your projects if you are working with Java, Scala, Ruby, or C#.

And if you are someone who wants to build a Java software application for your business, then get in touch with our team of experts, share your requirements, hire developers, and get your end product delivered to you at a pocket-friendly rate.

FAQs: How To Develop Java Maven/Mojo Plugins

What is a Maven plugin?

Maven plugins are Maven’s fundamental feature allowing developers to reuse a set of common build logic into different projects by either creating documentation, compiling unit tests, code compilation, or building a WAR file based on the project description.

What is the difference between a Maven dependency and a plugin?

A dependency refers to the library needed by the software application at the time of compiling, testing, or executing while a plugin is a Maven extension used to produce artifacts like jar or war files for compiled resources or code.

What are the two types of Maven plugins?

Build and Reporting Plugins are the two types of Maven plugins that you will need to use in developing a project.