Skip to content

Instantly share code, notes, and snippets.

@deependhamecha

deependhamecha/maven.md

Last active July 23, 2021 08:30
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save deependhamecha/f1c02ab6563d5bcea30c3f45871486a1 to your computer and use it in GitHub Desktop.
Save deependhamecha/f1c02ab6563d5bcea30c3f45871486a1 to your computer and use it in GitHub Desktop.
Download ZIP
Maven
Raw
maven.md

What is Maven?

At first glance Maven can appear to be many things, but in a nutshell Maven is an attempt to apply patterns to a project's build infrastructure in order to promote comprehension and productivity by providing a clear path in the use of best practices. Maven is essentially a project management and comprehension tool and as such provides a way to help with managing:

  • Builds
  • Documentation
  • Reporting
  • Dependencies
  • SCMs
  • Releases
  • Distribution

Maven Build Lifecycle

The Maven build follows a specific life cycle to deploy and distribute the target project.

There are three built-in life cycles:

  • default: the main life cycle as it's responsible for project deployment
  • clean: to clean the project and remove all files generated by the previous build
  • site: to create the project's site documentation

Each life cycle consists of a sequence of phases. The default build life cycle consists of 23 phases as it's the main build lifecycle.

On the other hand, clean life cycle consists of 3 phases, while the site lifecycle is made up of 4 phases.

Maven Phase

A Maven phase represents a stage in the Maven build lifecycle. Each phase is responsible for a specific task.

Here are some of the most important phases in the default build lifecycle:

  • validate: check if all information necessary for the build is available
  • compile: compile the source code
  • test-compile: compile the test source code
  • test: run unit tests
  • package: package compiled source code into the distributable format (jar, war, …)
  • integration-test: process and deploy the package if needed to run integration tests
  • install: install the package to a local repository
  • deploy: copy the package to the remote repository For the full list of each lifecycle's phases, check out the Maven Reference.

Phases are executed in a specific order. This means that if we run a specific phase using the command:

mvn <PHASE>

This won't only execute the specified phase but all the preceding phases as well.

For example, if we run the deploy phase – which is the last phase in the default build lifecycle – that will execute all phases before the deploy phase as well, which is the entire default lifecycle:

mvn deploy

Maven Goal

Each phase is a sequence of goals, and each goal is responsible for a specific task.

When we run a phase – all goals bound to this phase are executed in order.

Here are some of the phases and default goals bound to them:

  • compiler:compile – the compile goal from the compiler plugin is bound to the compile phase
  • compiler:testCompile is bound to the test-compile phase
  • surefire:test is bound to test phase
  • install:install is bound to install phase
  • jar:jar and war:war is bound to package phase We can list all goals bound to a specific phase and their plugins using the command:
mvn help:describe -Dcmd=PHASENAME

For example, to list all goals bound to the compile phase, we can run:

mvn help:describe -Dcmd=compile

And get the sample output:

compile' is a phase corresponding to this plugin:
org.apache.maven.plugins:maven-compiler-plugin:3.1:compile

Which, as mentioned above, means the compile goal from compiler plugin is bound to the compile phase.

Maven Plugin

A Maven plugin is a group of goals. However, these goals aren't necessarily all bound to the same phase.

For example, here's a simple configuration of the Maven Failsafe plugin which is responsible for running integration tests:

<build>
    <plugins>
        <plugin>
            <artifactId>maven-failsafe-plugin</artifactId>
            <version>${maven.failsafe.version}</version>
            <executions>
                <execution>
                    <goals>
                        <goal>integration-test</goal>
                        <goal>verify</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

As we can see, the Failsafe plugin has two main goals configured here:

  • integration-test: run integration tests
  • verify: verify all integration tests passed We can use the following command to list all goals in a specific plugin:
mvn <PLUGIN>:help

For example, to list all goals in the Failsafe plugin:

mvn failsafe:help

And the output of this will be:

This plugin has 3 goals:

failsafe:help
  Display help information on maven-failsafe-plugin.
  Call mvn failsafe:help -Ddetail=true -Dgoal=<goal-name> to display parameter
  details.

failsafe:integration-test
  Run integration tests using Surefire.

failsafe:verify
  Verify integration tests ran using Surefire.

To run a specific goal, without executing its entire phase (and the preceding phases) we can use the command:

mvn <PLUGIN>:<GOAL>

For example, to run integration-test goal from Failsafe plugin, we need to run:

mvn failsafe:integration-test

Install Local JAR with Maven

CT Course Content

mvn package

by default jar

Other values war pom

Effective POM

SUPER POM + MY POM = Effective POM

help:effective-pom -Doutput=effective-pom.xml

Effective Settings

help:effective-settings This is the file which has path to local maven repository.

If you want to change output package file name then

dude

So, now, output file will be created with name dude.jar

Change verion of source and target: maven-compiler-plugin 3.1

1.8 1.8

Site Plugin creates htmls of information about the website and plugins, dependencies, developers, license, etc.

Surefire reports surefire-report:report

Creates htmls for your test cases reports.

JavaDoc javadoc:javadoc

Exclude Dependencies

Maven Tomcat org.apache.tomcat.maven tomcat7-maven-plugin 2.2 TomcatServer http://localhost:8080/manager/text / true

Skip Tests

mvn package -DskipTests

Execute Goals in Debug Mode mvn -X package

Create Maven Project from command line mvn archetype:generate

Create a Multi Module project

  1. Create Maven Project (Parent)
  • Make sure to mention pom
  • In pom.xml 
    <modules>
	<module>business</module>
	<module>data</module>
</modules>
  1. Create Maven Module (Child)
  • Packaging type jar/war

If you check child's pom.xml, you will find is added pointing to parent project artifactId and groupId

Suppose, you have different versions for same package then

Specify in parent's pom.xml

<dependencyManagement>
	<dependencies>
		<dependency>
			<artifactId>
			<groupId>
			<version>
		</dependency>
	</dependencies>
</dependencyManagement>

Specify in child's pom.xml

	<dependencies>
		<dependency>
			<artifactId>
			<groupId>
		</dependency>
	</dependencies>

Remember, without version.

Suppose, you need to use data in business project then, in your business's pom.xml

<dependency>
	<groupId>com.something</groupId>
	<artifactId>data</artifactId>
</dependency>

and in your parent's pom.xml,

<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>com.something</groupId>
			<artifactId>data</artifactId>
			<version>0.0.1-SNAPSHOT</version>
		</dependency>
	</dependencies>
</dependencyManagement>

Profiles

In child's pom.xml

<profiles>
	<profile>
		<id>dev</id>
		<activation>
			<activeByDefault>true</activeByDefault>
		</activation>
		<properties>
			<jdbc.connection.url>someurl</jdbc.connection.url>
		</properties>
	</profile>
	<profile>
		<id>prod</id>
		<properties>
			<jdbc.connection.url>someurl</jdbc.connection.url>
		</properties>
	</profile>
</profiles>

In properties file spring.datasource=${jdbc.connection.url}

Activate a Profile

While specifing a Goal with Profile,

install -Pprod

If you dont specify, it will use dev

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment