This document discusses Apache Maven, an open source tool for building and managing Java-based projects. It provides an overview of Maven's history and goals, including providing a standard way to build projects, share dependencies, and publish project information. Key aspects of Maven covered include its conventions over configuration approach, the project object model (POM), dependency management, repositories, lifecycles and phases, multi-module projects, and plugins. Maven aims to simplify the build process and provide uniformity for Java projects.

1. Java Build Tooling
Apache Maven
Olivier Lamy | @olamy
VP Apache Maven, ASF Member

2. Agenda
● Who am I: Introduction
● What is the Apache Software Foundation
● Java build tools evolution
● Apache Maven
● Extend Apache Maven
● Complementary Tooling

3. /me
● Olivier Lamy (@olamy ) (twitter.com/olamy)
● https://www.slideshare.net/olamy / http://olamy.blogspot.fr
● Apache Software Foundation
– Member
– VP, Maven
– PMCs: Maven, Archiva, Tomcat, Sqoop, DirectMemory,
Kalumet
– Commiter: Commons
● Jenkins etc.. (add bugs in various opensource projects)
● Also a OpenSource Architect at Talend

4. What is The ASF
● Membership-based corporation; Non-profit US
501(c)3 Charity
● Directors, officers all unpaid volunteers
● Paid contractors: sysadmins, press officer
● Broad-based Membership of individuals
ensures independence
➔ Collection of Apache project communities

5. Apache Org Chart
Nominate, elect
Members
Directors annually Organizational
~400 Oversight
Technical
Board of Oversight
Nominate, elect 9 Directors
new members
Create &
update upon
Appoint officers PMC request
Report monthly Report quarterly
PMCs
Officers 100++
~10
Define organizational &
legal policies Committers Nominate, elect Vote for
new committers project releases
~3,000
Write project code

6. Apache Mission: What
● Provide open source software to the public free
of charge
– “Apache aims to provide a pragmatic, non-technical
framework to its projects.”
- Justin Erenkrantz
● Let coders code; Foundation exists to do rest
● Community over code

7. Apache License
● Apache projects use the Apache License 2.0
● Pragmatic and permissive
– Maximum freedom for users
● Includes patent grant
● Easily and frequently used by other groups

8. Apache Projects
● Over 100 code-producing community driven
projects
– 50+ Podlings in Incubation
● “Apache Projects include millions of lines of code overseen
by an all-volunteer community across six continents.
Apache technologies power more than half the Internet,
petabytes of data, teraflops of operations, billions of
objects, and enhance the lives of countless users and
developers.”

9. Apache Projects
● Industry standards:
– Apache HTTP Server (original project from the
foundation)
– Apache Tomcat (Servlet container)
– Apache Hadoop
– Apache Commons *
– Apache Subversion
– Etc http://projects.apache.org/indexes/alpha.html

10. Java Build Tools Evolution

11. Javac
Basic command line tool
Too many parameters to set for classpath, sourcepath,
annotations processors etc..
Use it for hello world only

12. Java Build Evolution
● We don't only build one or two classes.
● Use of external dependencies
● Complex packaging (not only jars)
● Running tests (complex tests)
● Interaction with external tools (issues trackers, scm, ci
servers)

13. Build Evolution : Ant
“Apache Ant is a Java-based build tool. In theory,
it is kind of like Make, but without Make's wrinkles”
-Apache Ant Website

14. Build Evolution : Ant
Why create another tool when make, gnumake
already exist?
They all have some limitations
They are more Shell Based
Limits you to one kind of OS

15. Build Evolution : Ant
Ant has Java Class like extensions
Use of XML instead of Shell Scripts
Each task is taken care of by creating its object
Standardized
Platform Independent

16. Build Evolution : Ant
Build.xml:
● Similar to makefile but an XML file
● It's the default file where ant will look for what to
build, how to build
● Has projects, targets, tasks

17. Build Evolution : Ant
Simple build file
<project name=”sample” default=”hello>
<target name=”hello”>
<echo message=”Hello from ant”/>
</target>
</project>

18. Build Evolution : Ant
Download from http://ant.apache.org/bindownload.cgi
Sample project: https://github.com/olamy/hello-world
git clone https://github.com/olamy/hello-world.git
or
https://github.com/olamy/hello-
world/archive/master.zip

19. Build Evolution : Ant
ant -p: list all targets
● ant compile
● ant run-tests
● ant package

20. Build Evolution : Ant
So you have to define everything
include jars in your source tree/scm
each ant build is a rewrite of an other one

21. Build Evolution: Maven
Download from
http://maven.apache.org/download.html
M2_HOME= path to maven home install
PATH=$M2_HOME/bin:$PATH

22. Build Evolution: Maven
pom.xml is small
Same project: mvn test, mvn package

23. Build Evolution : Ant
● Ant doesn't have formal conventions like a common
project directory structure, you have to tell Ant
exactly where to find the source and where to put
the output. Informal conventions have emerged
over time, but they haven't been codified into the
product.
● Ant is procedural, you have to tell Ant exactly what to
do and when to do it. You had to tell it to compile,
then copy, then compress.
● Ant doesn't have a lifecycle, you had to define goals
and goal dependencies. You had to attach a sequence
of tasks to each goal manually.

24. Build Evolution: Maven
Maven has conventions, it already knew where your
source code was because you followed the convention. It
put the bytecode in target/classes, and it produced a JAR
file in target.
Maven is declarative. All you had to do was create a
pom.xml file and put your source in the default directory.
Maven took care of the rest.
Maven has a lifecycle, which you invoked when you
executed mvn install. This command told Maven to
execute a series of sequence steps until it reached the
lifecycle. Maven executed a number of default plugin
goals which did things like compile and create a JAR.

25. Apache Maven: History
Maven, a Yiddish word meaning accumulator of
knowledge, was originally started as an attempt
to simplify the build processes in the Jakarta
projects.
There were several projects each with their own
Ant build files that were all slightly different and
JARs were checked into CVS. We wanted a
standard way to build the projects, a clear
definition of what the project consisted of, an easy
way to publish project information and a way to
share JARs across several projects.

26. Apache Maven: History
Maven 1.0
Introduced dependency mechanism and remote
repositories
Plugin mechanism
Limited to a wrapper on the top of Ant using ant
and jelly scriplet

27. Apache Maven: History
Maven 2.0
Full rewrite using plain Java and IoC container
Plexus (fork of dead Apache Avalon)
New Pom syntax: migration from maven 1.0 need
rewrite.

28. Apache Maven: History
Maven 3.0
Move to Guice IoC (with a layer to mimic Plexus
api).
More extensible
~99% backward compatible.

29. Apache Maven
Goals:
●
Making the build process easy
●
Providing a uniform build system
●
Providing quality project information
●
Providing guidelines for best practice
development
●
Allowing transparent migration to new features

30. Apache Maven Definition
● Apache Maven is a software project management and
comprehension tool.
● Based on the concept of a project object model
(POM), Maven can manage a project's build, binaries,
reporting and documentation from a central piece of
information.
● Apache Maven is a command line tool with some IDE
integrations.

31. Apache Maven Definition
Convention over Configuration !!

32. Apache Maven Conventions
● 1 project = 1 artifact (jar,war,ear, etc …)
Standardized :
● directories layout
● project descriptor (POM)
● build lifecycle

33. Apache Maven POM
● POM: Project Object Model
– Project Coordinates
– Dependencies
– Build settings
– Description
– Distribution mode

34. Apache Maven Coordinate
groupId:artifactId:version
<groupId>org.olamy.maven.course</groupId>
<artifactId>hello-world</artifactId>
<version>1.0-SNAPSHOT</version>

35. Apache Maven Dependencies
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<!--optionnals -->
<scope>test</scope>
<classifier>sources</sources>
</dependency>

36. Apache Maven Dependencies
Scope
Compile (by default) : Required to build and run the
application
Runtime : not required to build the application but needed at
runtime (Ex : taglibs)
Provided : required to build the application but not needed at
runtime (provided by the container) (Ex : Servlet API, Driver
SGBD, …)
Test : required to build and launch tests but not needed by the
application itself to build and run (Ex : Junit,) TestNG, DbUnit,
…
System : local library with absolute path

37. Apache Maven Dependencies
Transitiviy
● Project A needs project B
● Project B needs project C
So Maven detect project A needs project C

38. Apache Maven Dependencies
Transitiviy: exclude
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-bundle-jaxrs</artifactId>
<exclusions>
<exclusion>
<groupId>org.eclipse.jetty</groupId>
<artifactId>jetty-server</artifactId>
</exclusion>
</exclusions>
</dependency>

39. Apache Maven Dependencies
Nearest version approach
● Project A needs project B
● Project B needs project C 1.1
● Project A needs project C 1.0
Maven detect project A needs project C 1.0

40. Apache Maven Dependencies
Artifact repository
● Download by default from:
http://repo.maven.apache.org/maven2/
● Cached locally to ${user.home}/repository
– Used by maven
– Used by your projects
– Produced by your projects

41. Apache Maven Dependencies
Remote repository
● http(s) transport
● Url format: ${groupId}/${artifactId}/${artifactId}-$
{version}(-${classifier}).${type}
groupId: dot replaced by slash

42. Apache Maven Dependencies
Remote repository
dependency: org.apache.maven.plugins:maven-
compiler-plugin:3.0
http://repo.maven.apache.org/maven2/org/apache/
maven/plugins/maven-compiler-plugin/3.0/maven-
compiler-plugin-3.0.jar

43. Apache Maven Dependencies
Central repository
contains most of the open source projects
Stats: http://search.maven.org/#stats
● Total number of artifacts indexed (GAV): 402,355
● Total number of unique artifacts indexed (GA): 48,632
● Current size of repository on disk: 650,388 MB

44. Apache Maven Version
Project and dependency versions
Two different version variants
SNAPSHOT version
● The version number ends with –SNAPSHOT
● The project is in development
● Deliveries are changing over the time and are overridden after
each build
● Artifacts are deployed with a timestamp on remote repositories
RELEASE version
● The version number doesn’t end with –SNAPSHOT
● Binaries won’t change

45. Apache Maven Version
SNAPSHOT versions
Maven allows the configuration of an update policy. The
update policy defines the recurrence of checks if there is a
new SNAPSHOT version available on the remote repository :
● always
● daily (by default)
● interval:X (a given period in minutes)
● never
Must not be used in a released project
The release can thus also be changed

46. Apache Maven Version
RANGE versions
From ... to …
Maven automatically searches for the corresponding
version (using the update policy for released
artifacts)
To use with caution
● Risk of non reproducibility of the build
● Risk of side effects on your projects and projects
depending on them.

47. Apache Maven Archetype
Easy start with archetype
More than 600 projects type template !
mvn archetype:generate
Choose one (you can apply filtering on the name)
Start to code/enhance the generated template

48. Apache Maven Archetype
Start with Tomcat Archetype
● mvn install
● Import in an IDE

49. Apache Maven Lifecycle
Lifecycle is a sequence of plugin
executions called phases
● Full reference:
http://maven.apache.org/guides/introduction/introducti
on-to-the-lifecycle.html#Lifecycle_Reference
– validate
– …
– compile
– …
– Etc...

50. Apache Maven Lifecycle
A project has a packaging type
● <packaging/> default is jar (war, ear etc..)
● With a packaging comes a lifecycle with
plugins mapping
● As long as you respect standard layout
maven will pack for you respecting
standards

51. Apache Maven Lifecycle
Add a plugin execution to your lifecycle
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<executions>
<execution>
<id>tomcat-run</id>
<goals>
<goal>run-war-only</goal>
</goals>
<phase>pre-integration-test</phase>
●

52. Multi Modules projects
Build multiple projects
SOC: Separation Of Concern
● Module with an api
● N modules with different implementation

53. Multi Modules projects
Parent packaging pom
<modules>
<module>module-api</module>
<module>module-api-tck</module>
<module>module-impl-a</module>
<module>module-impl-b</module>
</module>

54. Multi Modules projects
Inheritence
Define common values in parent pom → no
need to repeat common values
Dependency Management → dependencies
version defined in only one place

55. Multi Modules projects
Inheritence
All projects inherit from super pom which
defined some values:
● Main sources: src/main/java
● Test sources: src/test/java
● Etc....

56. Multi Modules projects
Dependency Management
parent pom
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.lamy</groupId>
<artifactId>foo</artifactId>
<version>1.0</version>
</dependency>
</dependencies>
</dependencyManagement>

57. Multi Modules projects
Dependency Management
child poms
<dependencies>
<dependency>
<groupId>org.lamy</groupId>
<artifactId>foo</artifactId>
<!-- version inherited from parent -->
</dependency>
</dependencies>

58. Multi Modules projects
Plugin Management
parent pom
<pluginManagement>
<plugins>
<plugin>
<groupId>org.lamy</groupId>
<artifactId>foo</artifactId>
<version>
</plugin>
</plugins>
</pluginManagement>

59. Multi Modules projects
Plugin Management
child poms
Nothing version, <configuration> and <executions> will be
inherited
inheritance can be overridden.
inheritance can be removed: <inherited>true</inherited> plugins
won't be executed in child projects.

60. Multi Modules projects
child poms: configuration inheritence override.
Elements under configuration have attributes to control
inheritance mode
● combine.children=”append” (default is merge)
→ appen or not child content to parent content
● combine.self=”override” (default is merge)
→ stop inheritance

61. Plugins
Each plugin execution is Java class
by default each packaging comes with plugins attached to
lifecycle phases.
For simple projects nothing to do
But you can attach new plugins and executions to lifecycle

62. Plugins
Override default
<pluginManagement> section
● All used plugins must have a version
● Default configuration override
● Inherited in child poms

63. Plugins
Configuration
<plugin>
<configuration>
<foo>bar</foo>
<directory>${project.build.directory}</directory>
</configuration>
xml configuration
command line override with -Ddirectory=path

64. Plugins
Write your own
A maven project with <packaging>maven-plugin</packaging>
class extends AbstractMojo :
● Implements method execute
● Some services getLog() to log as Maven do
● getPluginContext(): possible to share information between
plugins
● Class lifecycle: initializable method when it starts (by default it's
a singleton class across your build)

65. Plugins
How ?
Maven will read metadata available in annotations from your
class: a plugin descriptor will be generated and Maven execution
will understand that.
@Mojo( name = "foo", requiresDependencyResolution =
ResolutionScope.TEST, threadSafe = true )
● Mvn ${groupId}:${artifactId}:${version}:foo
● Dependencies to scope test will be resolved
●
ThreadSafe for multi thread build

66. Plugins
hack
Generate a mojo from archetype.
● Default with doclet
● With annotations:
mvn archetype:generate
-DarchetypeGroupId=org.apache.maven.archetypes
-DarchetypeArtifactId=maven-archetype-plugin
-DarchetypeVersion=1.2 -DarchetypeRepository=
https://repository.apache.org/content/repositories/maven-090/

67. Plugins
Parameters
users parameters
@Parameter( property = "tomcat.delegate", defaultValue =
"true" )
private boolean delegate = true;
<configuration>
<delegate>false</delegate>
</configuration>
Or
-Dtomcat.delegate=false

68. Plugins
Maven Parameters Injected
@Parameter( defaultValue = "${project.packaging}", required =
true, readonly = true )
private String packaging;
@Component
protected MavenProject project;
@Parameter( defaultValue = "${project.artifacts}", required =
true, readonly = true )
private Set<Artifact> dependencies;

69. Plugins
Component Injected
your own
@Component( role = MavenFileFilter.class, hint = "default" )
private MavenFileFilter mavenFileFilter;
from Maven core
@Component
protected ArtifactResolver resolver;

70. Plugins
Advanced
Invoke a plugin directly which need previous phases execution
tomcat7:run will start an embeded Tomcat but need classes to
be compiled first.
Fork lifecycle
@Execute( phase = LifecyclePhase.PROCESS_CLASSES )
will reach process-classes phase then execute your mojo.

71. Maven
Artifacts Distribution
<distributionManagement>
<repository>
<id>apache.releases.https</id>
<name>Apache Release Distribution Repository</name>
<url></url>
</repository>
<snapshotRepository>
<id>apache.snapshots.https</id>
<name>${distMgmtSnapshotsName}</name>
<url>${distMgmtSnapshotsUrl}</url>
</snapshotRepository>
</distributionManagement>

72. Maven Settings
Your local settings in ~/.m2/settings.xml
your credentials to deploy to a remote server
<server>
<id>apache.snapshots.https</id>
<username>uid</username>
<password>password</password>
</server>

73. Maven Settings
Your local settings in ~/.m2/settings.xml
Mirrors for corporate env:
<mirror>
<name>archiva-repository</name>
<mirrorOf>central</mirrorOf> (or * )
<id>archiva-asf-mirror</id>
<url>https://archiva-
repository.apache.org/archiva/repository/public</url>
</mirror>

74. Maven Site
mvn site:site → target/site
Build a web site with your documentations.
Formats:
● Apt (files in src/site/apt)
(http://maven.apache.org/doxia/references/apt-format.html)
● Xdoc (files in src/site/xdoc)
(http://maven.apache.org/doxia/references/xdoc-format.html)
● Markdown (files in src/site/markdown)
no real specs for that :-)

75. Maven Site
Descriptor src/site/site.xml
● menu entries
<project name="">
<body>
<menu name="Menu">
<item name="About" href="index.html"/>
<item name="TODO" href="todo.html"/>
</menu>
</project>

76. Maven Site
customize
● skin
<skin>
<groupId>org.apache.maven.skins</groupId>
<artifactId>maven-fluido-skin</artifactId>
<version>1.3.0</version>
</skin>

77. Maven Site
Add reports
● Reporting section with maven plugins
<reporting>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-project-info-reports-plugin</artifactId>
<version>2.6</version>
</plugin>
</plugins>

78. Maven Site
Instrumental reports
● Findbugs
<reporting>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>findbugs-maven-plugin</artifactId>
<version>2.5.2</version>
</plugin>
</plugins>

79. Maven Site
Deploy
● Protocols: ftp, scp, webdav, scm
<site>
<id>id for your settings.xml</id>
<url>dav:url</url>
</distributionManagement>

80. Apache Maven
Complementary tooling

81. Apache Maven Repository
Deploying to share your project
● An open source project ? So ask to deploy it to central
● Use a repository manager to share inside your
entity/compay
– Apache Archiva: http://archiva.apache.org
– Nexus: http://www.sonatype.org/nexus/
– Artifactory: http://www.jfrog.com

82. Apache Maven Repository
Install Archiva locally
● Download from
http://archiva.apache.org/download.html
● Archiva 1.4-M3 Standalone new UI
● Unzip
● cd bin
● archiva console

83. Apache Maven Repository
Proxy to external repositories
● Some organisations doesn't allow external access
● Artifacts will be cached not access to external
repositories
● Control repositories you are using
<mirror>
<mirrorOf>*</mirror>
</mirror>

84. Continuous Integration
Detect issues as soon as possible
● Code will be rebuild on any scm change
● New artifact snapshots deployed for others

85. Continuous Integration
● Bamboo from Atlassian (paying product)
● TeamCity from Jetbrains (paying product)
● Continuum from Apache
● CruiseControl
● Hudson/Jenkins
We will talk about Jenkins :-)

86. Continuous Integration
Jenkins
● http://jenkins-ci.org
● Easy to install/use: java -jar jenkins.war
● No need for external tools (database etc..)
● Configuration stored on the file system

87. Continuous Inspection
Sonar
● Dashboard with various metrics
● Aggregator of existing Maven reports (and more)
● http://sonar.codehaus.org
● Easy install
● Daily run in Jenkins
● Tests it

88. References
● http://maven.apache.org
● http://archiva.apache.org
● http://jenkins-ci.org
● http://sonar.codehaus.org
● http://fr.slideshare.net/olamy/maven-universitycourse

89. Thanks/Merci
Questions ?
olamy@apache.org