Apache Maven Cookbook

Chapter 1. Getting Started

In this chapter, we will cover the basic tasks related to getting started with Apache Maven:

Installing Maven on Microsoft Windows
Installing Maven on Mac OS X
Installing Maven on Linux
Changing the JDK used by Maven
Creating a simple project with Maven
Building a simple project with Maven
Changing the location of the Maven repository
Running Maven behind an HTTP proxy server
Understanding the standard directory layout

Introduction

Apache Maven is a popular tool for build automation, primarily Java projects. Maven addresses two aspects of building software. First, it describes how a software is built and, second, it describes its dependencies. It uses conventions for the build procedure. An XML file describes the software project being built, its dependencies on other external modules and components, the build order, directories, and required plugins. It comes with predefined targets to perform certain well-defined tasks, such as code compilation and its packaging. Maven dynamically downloads Java libraries and Maven plugins from one or more repositories, such as the Maven Central Repository, and stores them locally.

Ever since Maven 1.0 was released in 2004, it has gained popularity and is today the build tool for a large number of open source and commercial projects.

If you are reading this book, then you are not here to understand why Maven is required. You are here to explore Maven and unleash the potential that it offers. The objective of this book is to make the reader aware of Maven's various features, which include installation, configuration, and simple to complex usage by means of examples, illustrations, and working projects.

A brief comparison with other build automation tools

Let's briefly discuss some build automation tools:

Make: If you are from the C programming world, chances are you have used Make. Makefiles are not platform-independent. They are not natively compatible with Windows. Thus, they are unsuited to build Java projects.
Ant: This is modeled after Make and has targets and dependencies. Each target has a set of tasks. Ant doesn't have any conventions. It is procedural and does not have the concept of a build lifecycle. Maven has conventions, is declarative, and has a lifecycle.

In this chapter, we will cover the basics of Maven—installing the software, verifying the installation, and creating, implementing, and building a simple Java project. We will also cover a few advanced items, such as changing the location of the repository or running Maven behind an HTTP proxy server as it could be relevant to those who have issues with the way Maven works by default.

Let us start by setting up Maven. We will cover how to do this on the three popular operating systems, namely Microsoft Windows, Mac OS X, and Linux.

Installing Maven on Microsoft Windows

At the time of writing this book, Microsoft Windows 8.1 is the latest version of Microsoft Windows. While the screenshots and output will be for Microsoft Windows 8.1, the steps are similar for earlier (and possibly later) versions as well.

Getting ready

As Maven requires a Java platform, first ensure that you have installed the Java environment on your system, Java Development Kit (JDK) specifically; Java Runtime Environment (JRE) is not sufficient.

You can verify whether Java is installed on your system by opening Add or Remove Programs. If you see something similar to the following screenshot, JDK is installed on your system:

You can also verify the program folder structure from Microsoft Windows Explorer:

How to do it...

Let's start installing Java and Maven by performing the following steps:

Set the variable JAVA_HOME to point to the Java installation that you want Maven to use; for example, you can do this by setting JAVA_HOME variable in the following way:
```
C:\projects\apache_maven_cookbook>set JAVA_HOME=C:\Program Files\Java\jdk1.8.0_20
```
Note
Note that this setting will not be persisted once the command prompt is closed. To persist this, set Environment Variables... using the Control Panel option, as described later for the M2_HOME variable.
If JDK is not installed on your system, now is the time to download and install it from the Oracle Java SE download page at http://www.oracle.com/technetwork/java/javase/downloads/index.html.
Once it is installed, ensure JAVA_HOME is set as described earlier.
Now that we have set up Java, let us download and set up Maven.
Go to http://maven.apache.org/ and click on the Download link.
The links to the latest stable versions of Maven are displayed.
The binaries are available in both, .zip and .tar.gz formats. Choose one of them.
Extract the downloaded binary to a folder you want Maven to reside in. In this case I have chosen C:\software.
Tip
It is best to avoid folders with spaces as some features of Maven or its plugins might not work.
Ensure the contents are similar to the following screenshot:

The preceding screenshot displays a list of directories contained in Maven.

Now let's briefly discuss what these directories contain:

The bin folder contains the batch files and shell scripts to run Maven on various platforms.
The boot folder contains the jars required for Maven to start.
The conf folder contains the default settings.xml file used by Maven.
The lib folder contains the libraries used by Maven. It also contains an ext folder in which third-party extensions, which can extend or override the default Maven implementation, can be placed.

Now let us make sure we can run Maven from the command prompt by carrying out the following steps:

Open Control Panel:
Choose Advanced system settings:
Click on Environment Variables.... Add the M2_HOME variable and set it to the folder where Maven was extracted.
Edit the PATH variable to include Maven's bin folder:

How it works...

A Maven installation is essentially a set of JAR files, configuration files, and a Microsoft Windows batch file, mvn.bat.

The mvn command essentially runs this batch file. It first checks for JAVA_HOME. This file is present in the bin folder of the Maven installation and, hence, it needs to be in PATH.

If the batch file does not find JAVA_HOME, it looks for Java in its PATH. This can lead to unexpected results, as typically the Java in PATH is usually the JRE and not the JDK.

The batch file then looks for M2_HOME, which is the location of the Maven installation. It does this so that it can load the libraries that are present.

Additionally, it also reads values specified in MAVEN_OPTS. This variable allows you to run Maven with an additional heap size and other Java parameters.

Using the values for JAVA_HOME, M2_HOME, and Maven_OPTS, the batch file runs its main class org.codehaus.plexus.classworlds.launcher.Launcher.

There's more...

Verify your Maven installation using the following steps:

Open a command prompt in Microsoft Windows and run the following command:
```
C:\software\apache-maven-cookbook>mvn -version
```

The following output should be displayed:

Apache Maven 3.2.5 (12a6b3acb947671f09b81f49094c53f426d8cea1; 2014-12-14T22:59:23+05:30)
Maven home: C:\software\apache-maven-3.2.5
Java version: 1.7.0_67, vendor: Oracle Corporation
Java home: C:\Program Files\Java\jdk1.7.0_67\jre
Default locale: en_IN, platform encoding: Cp1252
OS name: "windows 8.1", version: "6.3", arch: "amd64", family: "windows"

Installing Maven on Mac OS X

Let us look at the steps to install Maven on Mac OS X. This applies to the latest version of Mac OS X, namely Yosemite.

Earlier, Apple provided Java for Mac, but stopped doing so from Java 7 onwards. Apple Java is not available on recent versions of Mac OS X.

Getting ready

Let us check if the Java environment is available on your Mac:

Open the terminal and run the following command:
```
/usr/libexec/java_home -v 1.7
```

See if you get an output similar to the following:

/Library/Java/JavaVirtualMachines/jdk1.7.0_71.jdk/Contents/Home

Run the following command to check if you have Java 8:
```
/usr/libexec/java_home -v 1.8
```
This should give the following output if Java exists:
```
/Library/Java/JavaVirtualMachines/jdk1.8.0_25.jdk/Contents/Home
```
As you can see, my system has both Java 1.7 and 1.8.
Set JAVA_HOME to the desired JDK. This can be done in two ways, depending on what you desire:
If this is for the duration of the session, run the following command:
```
export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.8.0_25.jdk/Contents/Home
```
If this is permanent, add the preceding line in .bash_profile in your HOME folder

Tip

Ensure you have the JDK installation and not JRE.

If Java is not present, download and install Java from the Oracle Java download page at http://www.oracle.com/technetwork/java/javase/downloads/index.html.

Once installed, verify the Java installation by following the preceding steps.

Now, let us set up Maven on Mac OS X.

How to do it...

Let's download Maven from its official website by performing the following steps:

Go to http://maven.apache.org/ and click on the Download link. Links to the latest stable versions of Maven will be displayed.
The binaries are available in both .zip and .tar.gz formats. Choose one of them.
Extract the downloaded binary to the folder you want Maven to reside in. The typical location for the Mac is /usr/local folder.
You will need a super user (su) or administrator access to place the contents in the /usr/local folder. If you do not have access, you can place the contents in a subfolder of your HOME folder.

Ensure the contents are similar to the following output by executing the following command:

/usr/local/apache-maven-3.2.5$ ls -l

The output is shown as:

total 27
-rw-r--r--    1 root    wheel    17464 Aug 12 02:29 LICENSE
-rw-r--r--    1 root    wheel      182 Aug 12 02:29 NOTICE
-rw-r--r--    1 root    wheel     2508 Aug 12 02:26 README.txt
drwxr-xr-x    8 root    wheel     4096 Aug 19 13:41 bin
drwxr-xr-x    3 root    wheel        0 Aug 19 13:41 boot
drwxr-xr-x    4 root    wheel        0 Oct 14 17:39 conf
drwxr-xr-x   67 root    wheel    28672 Aug 19 13:41 lib

Set the M2_HOME variable as follows:

export M2_HOME=/usr/local/apache-maven-3.2.5

Update the PATH to include Maven's bin folder:
```
export PATH=$PATH:$M2_HOME/bin
```

Tip

Like JAVA_HOME, the preceding settings can be persisted by updating .bash_profile with the preceding lines.

In the preceding steps, we discussed the steps to download Maven from its official website. We will now discuss installing Maven using brew. Brew is a popular application on Mac OS X to install open source software. If you have brew installed on your Mac OS X, run the following command to install Maven:

brew install maven

The output for the preceding command will be displayed as shown in the following screenshot:

How it works...

The Maven installation is essentially a set of JAR files, configuration files, and a Mac OS X shell script, namely mvn.

The mvn command essentially runs this script. It first checks for JAVA_HOME. This file is present in the bin folder of the Maven installation and, hence, it needs to be in PATH.

If the shell script does not find JAVA_HOME, it looks for Java in its PATH. This can lead to unexpected results, as typically the Java in PATH is usually the JRE installation and not JDK.

The shell script then looks for M2_HOME, which is the location for the Maven installation. It does this so that it can load the libraries that are present.

Additionally, it also reads values specified in MAVEN_OPTS. This variable allows you to run Maven with an additional heap size and other Java parameters.

Using the values for JAVA_HOME, M2_HOME, and MAVEN_OPTS, the shell script runs its main class org.codehaus.plexus.classworlds.launcher.Launcher.

There's more...

Verify your Maven installation using the following steps:

Open a command prompt and run the following command:
```
mvn –version
```
The output for the preceding command should be displayed as shown in the following screenshot:

Installing Maven on Linux

Let us look at the steps to install Maven on Linux.

While there are many flavors of Linux (Ubuntu, Fedora, RHEL, SUSE, CentOS, and so on), the steps to set up Maven are similar.

Getting ready

Maven needs Java, specifically the Java Development Kit (JDK). Using the following steps, let us check if it is installed in your Linux system, which is a bit tricky:

Open a terminal and run the following command:
```
java -version
```
See if you get an output similar to the following:
```
java version "1.7.0_65"
OpenJDK Runtime Environment (rhel-2.5.1.2.el6_5-x86_64 u65-b17)
```
The preceding output will still not tell you where your Java is installed, which is required to set JAVA_HOME. You can get this information by performing the next set of steps.
Check if javac works; it does only if JDK is installed, not JRE:
```
$ javac -version
```
The output for the preceding command is shown as:
```
javac 1.7.0_65
```
Find the location of the javac command:
```
$ which javac
```
The output for the preceding command is shown as:
```
/usr/bin/javac
```
In the preceding output, javac is a symbolic link to the actual location of the file. Try to determine this location in the following way:
```
$ readlink /usr/bin/javac
```
The output for the preceding command is shown as:
```
/etc/alternatives/javac
```
By executing the preceding command, we again got the symbolic link. To get the path to the location of javac, we execute the following command again:
```
$ readlink /etc/alternatives/javac
```
The output for the preceding command is shown as:
```
/usr/lib/jvm/java-1.7.0-openjdk.x86_64/bin/javac
```
We have now located the folder where JDK is installed:
```
/usr/lib/jvm/java-1.7.0-openjdk.x86_64/
```
Set JAVA_HOME to the preceding folder. This can be done in two ways, depending on what you desire:
If it is for the duration of the session, run the following command:
```
export JAVA_HOME=/usr/lib/jvm/java-1.7.0-openjdk.x86_64/
```
If this is permanent, add the preceding line in .bash_profile in your HOME folder.

If Java is not present, download and install Java from the Oracle Java download page at http://www.oracle.com/technetwork/java/javase/downloads/index.html.

If you have an rpm-based Linux distribution, you can download and install rpm. Otherwise, you can download the .tar.gz format of the distribution and extract it to a folder of your choice.

In the earlier case, you know exactly where Java is installed and can set JAVA_HOME correspondingly. Once installed, verify the Java installation by following the preceding steps.

Now, let us set up Maven on Linux.

How to do it...

To set up Maven on Linux, perform the following steps:

Go to http://maven.apache.org/ and click on the Download link. The links to latest stable versions of Maven will be displayed.
The binaries are available in both .zip and .tar.gz formats. For Mac OS X and Linux, the preferred download format is .tar.gz.
Extract the downloaded binary to a folder you want Maven to reside in. The typical location in Linux is the /usr/local folder.
Tip
You will need a super user (su) or administrator access to place contents in the /usr/local folder. If you do not have access, you can place this in a subfolder of your HOME folder.

Execute the following command, and ensure the contents of the apache-maven-3.2.5 folder are similar to the following output:

/usr/local/apache-maven-3.2.5$ ls -l

The output for the preceding command is shown as:

total 27
-rw-r--r--    1 root    root    17464 Aug 12 02:29 LICENSE
-rw-r--r--    1 root    root      182 Aug 12 02:29 NOTICE
-rw-r--r--    1 root    root     2508 Aug 12 02:26 README.txt
drwxr-xr-x    8 root    root     4096 Aug 19 13:41 bin
drwxr-xr-x    3 root    root        0 Aug 19 13:41 boot
drwxr-xr-x    4 root    root        0 Oct 14 17:39 conf
drwxr-xr-x   67 root    root    28672 Aug 19 13:41 lib

Set the M2_HOME variable as follows:

export M2_HOME=/usr/local/apache-maven-3.2.5

Update PATH to include Maven's bin folder:
```
export PATH=$PATH:$M2_HOME/bin
```

Like JAVA_HOME, the preceding settings can be persisted by updating .bash_profile.

How it works...

The Maven installation is essentially a set of JAR files, configuration files, and a Linux shell script, namely mvn.

The mvn command essentially runs this script. It first checks for JAVA_HOME. This file is present in the bin folder of the Maven installation and hence needs to be in PATH.

If the shell script does not find JAVA_HOME, it looks for java in its PATH. This can lead to unexpected results, as typically, the Java in PATH is usually JRE and not JDK.

The shell script then looks for M2_HOME, which is the location of the Maven installation. It does this so that it can load the libraries that are present.

Additionally, it also reads values specified in MAVEN_OPTS. This variable allows you to run Maven with an additional heap size and other Java parameters.

Using the values for JAVA_HOME, M2_HOME, and MAVEN_OPTS, the shell script runs its org.codehaus.plexus.classworlds.launcher.Launcher main class.

There's more...

Using the following steps, let's confirm that Maven has been set up correctly, by running a Maven command:

Open a command prompt and run the following command:
```
mvn –version
```

The following output should be displayed:

Apache Maven 3.2.5 (12a6b3acb947671f09b81f49094c53f426d8cea1; 2014-12-14T22:59:23+05:30)
Maven home: /usr/local/maven
Java version: 1.7.0_65, vendor: Oracle Corporation
Java home: /usr/lib/jvm/java-1.7.0-openjdk-1.7.0.65.x86_64/jre
Default locale: en_US, platform encoding: ANSI_X3.4-1968
OS name: "linux", version: "2.6.32-279.22.1.el6.x86_64", arch: "amd64", family: "unix"

If you get an error, recheck the installation steps and repeat them.

Creating a simple project with Maven

Now that we have set up Maven on our favorite operating system and verified that it works fine, it is time to create a simple Java project.

Maven makes it easy to bootstrap a new project by creating a bunch of files and folders following accepted conventions.

How to do it...

Let's start creating the first simple project using Maven, by performing the following steps:

Open a command prompt and change the directory to the folder in which you want to create your first Maven project.

Run the following command:

mvn archetype:generate -DgroupId=com.packt.cookbook -DartifactId=simple-project -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

You can change the groupId and artifactId values in the preceding command as per your requirement.

You will see Maven downloading a bunch of files:

Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-clean-plugin/2.5/maven-clean-plugin-2.5.pom
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-clean-plugin/2.5/maven-clean-plugin-2.5.pom (4 KB at 1.4 KB/sec)

Then it will start generating sources:

[INFO] >>> maven-archetype-plugin:2.2:generate (default-cli) > generate-sources
@ standalone-pom >>>

When Maven has completed generating sources, it will create the project that we want:

[INFO] Using following parameters for creating project from Old (1.x) Archetype:
maven-archetype-quickstart:1.0
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: groupId, Value: com.packt.cookbook
[INFO] Parameter: packageName, Value: com.packt.cookbook
[INFO] Parameter: package, Value: com.packt.cookbook
[INFO] Parameter: artifactId, Value: simple-project
[INFO] Parameter: basedir, Value: C:\projects\apache-maven-cookbook
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: C:\projects\apache-maven-cookbook\simple-project

Tip

Downloading the example code

You can download the example code files from your account at http://www.packtpub.com for all the Packt Publishing books you have purchased. If you purchased this book elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you.

How it works...

Did you get an while error running the preceding command to create your simple project?

One possibility is that your Maven is behind an HTTP proxy server. If so, see the Running Maven behind an HTTP proxy server recipe in this chapter.

Let's look at the folder structure that is created:

You will notice the following things:

The Maven project configuration file pom.xml is created in the root of the simple-project folder. We will explore this file in detail in subsequent sections.
A bunch of folders are created:
- src\main\java: This is for Java source files
- src\test\java: This is for Java test source files
- src\main\resources: This is for resource files for the project
- src\test\resources: This is for resource files for the test
Within each of the preceding folders, a folder structure corresponding to the groupId (org.packt.cookbook) is created.

The following are essentially Maven conventions at work:

Maven expects all Java source files to reside in src\main\java
Similarly, it expects all Java test files to reside in src\test\java
It expects all project resources to reside in src\main\resources and test resources to reside in src\test\resources
It expects that source files will typically have the same package structure as the groupId parameter (though this is not mandatory)
Two sample classes, namely App.java and AppTest.java, are also created and it is not expected that they will be used beyond testing how Maven works

The mvn command that we used in the Creating a simple project with Maven recipe in this chapter, tries to invoke the generate goal of the archetype plugin with the specified command-line parameters.

The default Maven installation has minimal features. All features of Maven are available as Maven plugins. When given a plugin name, Maven knows where to download it from and then run it.

In this case, Maven downloads the archetype plugin. This plugin, in turn, can depend on another plugin. In this case, the latter plugin gets downloaded. This happens in a recursive fashion and, at the end of the process, all the relevant plugins required to run the specified command are downloaded.

These plugins are placed in your local repository, which is a location in your system. Once downloaded, these are never downloaded again unless deleted.

Building a simple project with Maven

Let us now build the project that was created in the preceding section.

How to do it...

To build the previously created simple project with Maven, perform the following steps:

Open the command prompt and run the following command, changing the directory to the folder the project was created:
```
mvn package
```

Observe the following things in the output:

Notice the following warning (we will see how to resolve this later in this book):

[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ simple-project ---
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!

Check if the sources are compiled:

[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ simple-project

Check if the tests are run:

[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ simple-project ---
[INFO] Surefire report directory: C:\projects\apache-maven-cookbook\simple-project\target\surefire-reports
-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running com.packt.cookbook.AppTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.005 sec

A JAR file is now created.

How it works...

In the mvn package command, the package parameter is a phase in the build lifecycle. Maven has a default build lifecycle that has a number of phases. Each phase will execute every phase prior to it in order along with the specified phase. In this case, the package phase executes in the following order:

Validate
Compile
Test
Package

The validate phase makes sure that the project (specifically the pom.xml file that describes the project) is in order and all the necessary information to run the project is available.

The compile phase compiles the sources.

The test phase compiles the test sources and then runs the test using a suitable test framework. In the earlier example, the JUnit framework is used to run the tests.

The package phase packages the artifacts to the format specified in the pom.xml file.

Changing the location of the Maven repository

There are three types of Maven repositories:

Local: This is the repository in your computer filesystem
Remote: This is the repository from where the required Maven files get downloaded
Mirrors: These are repository managers, such as Nexus and Artifactory, that mirror various repositories

You will have seen Maven downloading a number of files (called poms and jars). Let us see where they are located in your computer:

Go to your HOME folder (C:\Users\username) in the case of Microsoft Windows, /Users/username for Mac, and, /home/username (or a similar location) for Linux
You will notice the .m2 folder and within that, a subfolder called repository
Tip
Any folder that starts with a dot (.) is typically hidden from view. You will need to change your folder viewer settings to see it.
You will see a number of folders and files that are used by Maven

You may want to change this location for the following reasons:

You may want to conserve space in the C drive and store these folders and files in the D drive on Microsoft Windows.
You may want to take a back up of the contents. Backup software usually backs up contents in specific folders of the filesystem.
Your organization may have a policy for all users to store a local repository in the same folder.

How to do it...

To change the location of the Maven repository, perform the following steps:

Create a file called settings.xml in the .m2 folder.

Add the following contents to the settings.xml file that you just created:

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0
                      http://maven.apache.org/xsd/settings-1.0.0.xsd">
    <localRepository>C:/software/maven</localRepository>
</settings>

Notice the highlighted part of the preceding code. We have changed the location of the repository contents to C:\software\maven. You can change it to any valid folder name.

Delete the repository subfolder and run the mvn package command again.
You will now notice that the repository folder is not created in the .m2 folder. Instead, it is created in C:\software\maven.

How it works...

Maven determines the location of the local repository in the following way:

If settings.xml exists in the user's .m2 folder, which contains the <localRepository> tag, then Maven uses its contents to determine the location
If not, Maven will check if localRepository is explicitly defined in the default settings.xml, present in the conf folder of the Maven installation
If it is not present there, Maven will use the default value for the local repository, which is the user's .m2 folder

Jackie Oct 31, 2017

Great book for those new or experienced to Maven. I wish I had a book like this 5 years ago when I started using Maven. Although I did skim though most of the beginning I did get a lot of good example of best practices and plugin implementations. I highly recommend the book to anybody from developers to configuration management, and would go so far to call the Maven Bible for all practitioners.

Amazon Verified review

Phani Krishna May 20, 2015

When I got the opportunity to review this book, I thought the book would mostly be focused for beginners. Surprised the book has in it for everyone unlike the books released in market earlier. It begins at the very start, with the basics including installation screenshots, explains the concepts of everything you learn. It has got various scenarios of usage, and includes the code in the book. The book provides with best examples and explains how the object oriented approach of maven is used for re usability and flexibility.The book explains about the implementation of different plugins for java code with code and examples viz FindBugs(static analysis tool to bug tracking),PMD(source code analyzer),CheckStyle(Coding standard),Cobertura(Code Coverage),Sonar(Code Quality). All the examples are thoroughly tested and they work the way described in the book.Best of luck !! Go on buy it now :)

Ludek Jun 04, 2015

This book covers all aspects of development using Maven on major OS platforms and IDEs. In great details explains how to start using Maven in any Enterprise environment, including Enterprise networks with the proxy servers. I believe this is great book for beginners’ as well as senior developers.

J. West Jun 12, 2017

This book is a good start, but for me, it left several unanswered questions. The strengths are chapter 3 (Maven Lifecycle), chapter 4 (Essential Maven Plugins) and chapter 5 (Dependency Management). After that, several chapters were devoted to broad-brush descriptions of many Maven Plugins. These chapters weren't really useful. They took space, but didn't provide enough detail. This could have been compressed into a single chapter along the lines of "Maven Plugins you might want to understand/use".The book lacks coverage of profiles and how you pull code from one repo to a push to a local repo (which I believe is vital information that most people will want to cover).

JamesK Jan 06, 2016

Average book in my opinion. Too many topics brought up without a good explanation. Not sure how this bookreceived 5 stars overall. I must have missed something.

Apache Maven Cookbook: Over 90 hands-on recipes to successfully build and automate development life cycle tasks following Maven conventions and best practices

What do you get with Print?

Contact Details

Shipping Address

Billing Address

A brief comparison with other build automation tools

Note

Tip

Tip

Tip

Description

Who is this book for?

What you will learn

Product Details

What do you get with Print?

Contact Details

Shipping Address

Billing Address

Product Details

Packt Subscriptions

Frequently bought together

Table of Contents

Recommendations for you

Customer reviews

People who bought this also bought

About the author

FAQs