A Brief Introduction to Maven

NovelVista

Last updated 23/07/2021

---

       

What is Maven?

Maven is a popular open-source build tool developed by the Apache Group to build, publish, and deploy several projects at once for better project management. The tool provides allows developers to build and document the lifecycle framework. 

Maven is written in Java and is used to build projects written in C#, Scala, Ruby, etc. Based on the Project Object Model (POM), this tool has made the lives of Java developers easier while developing reports, checks build, and testing automation setups. 

Maven focuses on the simplification and standardization of the building process, taking care of the following:

• Builds
• Documentation
• Dependencies
• Reports 
• SCMs
• Distribution
• Releases
• Mailing list

Build Tools

Build tools are the tools or programs that help create an executable application from the source code. As the name suggests, it’s essential for building or scripting a wide variety of tasks.

The build tool is needed for the following processes:

• Generating source code
• Generating documentation from the source code
• Compiling source code
• Packaging the compiled codes into JAR files
• Installing the packaged code in the local repository, server, or central repository

Project Object Model (POM)

Maven is so useful thanks to the Project Object Model (POM), which is an XML file that has all the information regarding the project and configuration details. The POM has the description of the project, details regarding the versioning, and configuration management of the project. 

The XML file is located in the project home directory. When you execute a task, Maven searches for the POM in the current directory.

Using Maven is extremely easy, once you learn POM (Project Object Model), which is just an XML file containing details of the project. Some of these details might include the project name, version, package type, dependencies, Maven plugins, etc.

A (very) simple pom.xml file might look something like this:

The Need for Maven

Maven is chiefly used for Java-based projects, helping to download dependencies, which refers to the libraries or JAR files. The tool helps get the right JAR files for each project as there may be different versions of separate packages. 

After Maven, downloading dependencies doesn’t require visiting the official websites of different software. You can visit mvnrepository to find libraries in different languages. The tool also helps to create the right project structure in struts, servlets, etc., which is essential for execution. 

Maven’s Objectives

Maven’s primary goal is to allow a developer to comprehend the complete state of a development effort in the shortest period of time. In order to attain this goal, Maven deals with several areas of concern:

• Making the build process easy
• Providing a uniform build system
• Providing quality project information
• Encouraging better development practices

Making the build process easy

While using Maven doesn’t eliminate the need to know about the underlying mechanisms, Maven does shield developers from many details.

Providing a uniform build system

Maven builds a project using its project object model (POM) and a set of plugins. Once you familiarize yourself with one Maven project, you know how all Maven projects build. This saves time when navigating many projects.

Providing quality project information

Maven provides useful project information that is in part taken from your POM and in part generated from your project’s sources. For example, Maven can provide:

• Change log created directly from source control
• Cross-referenced sources
• Mailing lists managed by the project
• Dependencies used by the project
• Unit test reports including coverage

Third-party code analysis products also provide Maven plugins that add their reports to the standard information given by Maven.

Providing guidelines for best practices development

Maven aims to gather current principles for best practices development and make it easy to guide a project in that direction.

For example, specification, execution, and reporting of unit tests are part of the normal build cycle using Maven. Current unit testing best practices were used as guidelines:

• Keeping test source code in a separate, but parallel source tree
• Using test case naming conventions to locate and execute tests
• Having test cases set up their environment instead of customizing the build for test preparation

Maven also assists in project workflows such as release and issue management.

Maven also suggests some guidelines on how to lay out your project’s directory structure. Once you learn the layout, you can easily navigate other projects that use Maven.

While takes an opinionated approach to project layout, some projects may not fit with this structure for historical reasons. While Maven is designed to be flexible to the needs of different projects, it cannot cater to every situation without compromising its objectives.

If your project has an unusual build structure that cannot be reorganized, you may have to forgo some features or the use of Maven altogether.

Advantages of Maven

• Simple project setup that follows best practices - get a new project or module started in seconds
• Consistent usage across all projects - means no ramp-up time for new developers coming onto a project
• Superior dependency management including automatic updating, dependency closures (also known as transitive dependencies)
• Able to easily work with multiple projects at the same time
• A large and growing repository of libraries and metadata to use out of the box, and arrangements in place with the largest Open Source projects for real-time availability of their latest releases
• Extensible, with the ability to easily write plugins in Java or scripting languages
• Instant access to new features with little or no extra configuration
• Ant tasks for dependency management and deployment outside of Maven
• Model-based builds: Maven is able to build any number of projects into predefined output types such as a JAR, WAR, or distribution based on metadata about the project, without the need to do any scripting in most cases.
• Coherent site of project information: Using the same metadata as for the build process, Maven is able to generate a web site or PDF including any documentation you care to add, and adds to that standard reports about the state of development of the project. Examples of this information can be seen at the bottom of the left-hand navigation of this site under the "Project Information" and "Project Reports" submenus.
• Release management and distribution publication: Without much additional configuration, Maven will integrate with your source control system (such as Subversion or Git) and manage the release of a project based on a certain tag. It can also publish this to a distribution location for use by other projects. Maven is able to publish individual outputs such as a JAR, an archive including other dependencies and documentation, or as a source distribution.
• Dependency management: Maven encourages the use of a central repository of JARs and other dependencies. Maven comes with a mechanism that your project's clients can use to download any JARs required for building your project from a central JAR repository much like Perl's CPAN. This allows users of Maven to reuse JARs across projects and encourages communication between projects to ensure that backward compatibility issues are dealt with.

Companies Using Maven 

There are over 2,000 companies using Maven today, most of which are located in the United States and in the Computer Science industry. Maven is also used in industries other than computer science, like information technology, financial services, banking, hospital and care, and much more. 

Some of the largest corporations that use Maven include:

• Accenture
• JPMorgan Chase & Co
• Via Varejo 
• craft base
• Red Hat 
• Mitratech Holdings, Inc.
• KRG TECHNOLOGIES
• Radio - Canada

Running Apache Maven

The syntax for running Maven is as follows:

       1. mvn [options] [<goal(s)>] [<phase(s)>]

All available options are documented in the built-in help that you can access with

       1. mvn -h

The typical invocation for building a Maven project uses a Maven life cycle phase. E.g.

       1. mvn package

The built-in lifecycles and their phases are in order are:

• clean - pre-clean, clean, post-clean
• default - validate, initialize, generate-sources, process-sources, generate-resources, process-resources, compile, process-classes, generate-test-sources, process-test-sources, generate-test-resources, process-test-resources, test-compile, process-test-classes, test, prepare-package, package, pre-integration-test, integration-test, post-integration-test, verify, install, deploy
• site - pre-site, site, post-site, site-deploy

A fresh build of a project generating all packaged outputs and the documentation site and deploying it to a repository manager could be done with

     1.mvn clean deploy site-deploy

Just creating the package and installing it in the local repository for re-use from other projects can be done with

     1. mvn verify

This is the most common build invocation for a Maven project.

When not working with a project, and in some other use cases, you might want to invoke a specific task implemented by a part of Maven - this is called a goal of a plugin. E.g.:

     1.mvn archetype:generate

or

     1.mvn checkstyle:check

There are many different plugins available and they all implement different goals.

Conclusion:

Without build tools like Maven or Gradle, developing and maintaining projects would be a painful process. Maven is a great tool that helps not only with building the application but also manages all the dependencies. Gradle is taking a large part of the Java build tool market and largely focuses on the same functional goal – to manage the build process. The difference is in the way how both tools work. The successful predecessor, Apache Ant, is still there with us but its market share is now really low.

DevOps Trends in 2024: The Continued Rise of GitOps, Data Observability, and Security

Building a High-Performing SRE Team: Key Strategies and Best Practices

Securing the Pipeline: Integrating Security into Your SRE Practices