This workshop will be retired on May 1, 2025.
Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Preview
Start a free Courses trial
to watch this video
The commands that can be used with Maven to trigger compiling, building, and testing, among other tasks, are based on the idea of a build lifecycle. In this video, we explore how Maven is composed of lifecycles, phases, and goals.
Maven Phases
See the Maven docs for a list of all phases included in each of the three built-in lifecycles:
- clean
- default
- site
Creating an Executable Java App with Maven
To create an executable JAR with Maven, you can use the shade plugin. Configuring this plugin involves altering pom.xml to include configuration of the plugin, which consists of indicating the main class that should be run when this JAR is executed. After adding this configuration to your POM, you can run the following in your terminal:
mvn shade
Then, you can run the app just like any other executable JAR:
java -jar your-archive-1.0.0-SNAPSHOT.jar
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
Maven is based on the idea of a build
lifecycle which refers to the process of
0:00
assembling and
distributing an artifact like a JAR file.
0:04
Maven ships with three lifecycles and
0:07
you can think of them in terms
of distributing an application.
0:09
The first is the clean lifecycle
during which all compiled and
0:12
packaged resources and
artifacts are removed from the project,
0:16
in other words the target
directory is deleted.
0:19
If you remember, this is the directory
that will hold all the .class files and
0:22
the generated JAR file.
0:26
Next is the default lifecycle wherein your
application code is compiled, tested,
0:27
packaged, iand deployed,
0:32
much of the heavy lifting is done
here in the default lifecycle.
0:33
Finally, there is the site lifecycle.
0:38
This allows you to generate some
HTML documentation of the project.
0:40
Now within lifecycle, there are phases.
0:44
For examples, some of the phases that
make up the default build lifecycle
0:46
are the compile, test,
package, and install phases.
0:49
So, switching back to the terminal,
if we want to compile our application,
0:54
we can invoke the compile phase from
the command line like this, mvn compile.
0:59
Now, this will download all the listed
dependencies as well as the dependencies
1:07
listed by the ones we included.
1:11
The dependencies of our dependencies
are called transitive dependencies and
1:12
Maven will find those for us.
1:16
So this message here that says build
success, let's me know that, indeed,
1:19
the build succeeded,
that is compilation was successful.
1:23
So, if we use the tree
command in the command line,
1:27
we'll see this new target directory
that contains our compiled source code,
1:31
that is our bytecode App.class right here.
1:36
Next, let's create this
project's artifact.
1:39
The kind of artifact that's created is
determined by the value of the packaging
1:42
element, which in our case is JAR.
1:46
Let me switch back to the IDE
to remind you of that.
1:47
If I scroll to the top of this pom,
let me hide this right here,
1:51
then I will see jar here
in the packaging element.
1:56
Now, you might notice some XML that's
in here that we didn't actually type.
2:00
But remember in a previous video where
we told our IDE to use Java 8 so
2:05
that it accommodated lambdas, well,
what that it did was it told our IDE
2:11
to stick this XML in here which
indicated both the version of
2:15
our source code as well as the version
of our compiled code that we would like
2:20
when we compile this code and
said source 1.8 target 1.8.
2:25
Therefore, we can accommodate lambdas.
2:29
Okay, so that's some additional XML that
we didn't actually manually type but
2:33
you should see in there at that point.
2:37
Of course,
if you're not working in the IDE,
2:40
you could just as easily
add this XML yourself.
2:42
All right, back to this jar.
2:46
Let's switch back to our terminal and
create that JAR file.
2:48
What we need to do is run the package
phase of maven, so mvn package.
2:52
Now upon running this, we'll get
a files by jar in the target directory
2:59
as we can see by running the tree command.
3:03
Let me show you this.
3:06
Tree, and there is the jar
file in that target directory,
3:09
file-spy-1.0-SNAPSHOT.jar.
3:14
Now remember, this file name is determined
by those elements in our pom.XML file.
3:18
This is the artifact ID and
this is the version.
3:25
And finally, this is the packaging
element which in our case was jar, so
3:30
we have our jar that was created by
running the package phase, cool.
3:34
Now, it's worth noting here that this
jar file is not runnable itself but
3:38
rather this is a jar that wraps
all the code we wrote but
3:42
it still requires our dependencies to be
included, that is our Apache Tika library.
3:46
So this jar doesn't actually
include the TIKA dependency.
3:51
So since this jar isn't runnable,
3:56
it doesn't constitute
a standalone application.
3:58
Check out the teacher's notes on how
you can create a standalone executable
4:00
application with Maven.
4:04
The purpose that this jar file does serve
is that it can now be used as a dependency
4:06
of other projects.
4:10
To use this package artifact as a Maven
dependency in your own projects,
4:12
you'll need to run the install phase
of the default build lifecycle.
4:15
What this will do is save your pom and
JAR to a local repository where Maven is
4:20
saving all the JARs of
the dependencies you've used so far.
4:24
Now usually,
this local repo is located in a directory
4:27
named .m2 under the home directory.
4:31
So let's go there now.
4:35
From here, I can use the tree command
with pattern matching to see if I can get
4:37
a files by artifact.
4:40
So I'll use tree- P 'file-spy, and
4:42
I'll just put an asterisk in there for
all the version stuff
4:46
and then I will prune the tree, so I only
get the results that match that pattern.
4:53
Cool, I get zero results.
4:59
Now, let's run a Maven
install on our project.
5:02
So I'm gonna change
directories back to my project.
5:05
And I will run an mvn install.
5:13
Okay, let's go back to
my local repository.
5:19
So that was .m2, and
let's rerun that tree command.
5:23
Cool, I get one hit here,
5:30
file-spy-1.0-SNAPSHOT.jar.
5:33
What this means is that this project can
now be used as a Maven dependency on other
5:38
projects.
5:41
So let me show you what I mean by that.
5:42
So let me change directories
back to code screencasts, and
5:44
let's generate another Maven project and
5:49
use our files-spy*jar as
a dependency to our new project.
5:52
So I will generate another archetype here.
5:57
Archetype generate, remember,
that's -B for bash mode but
6:01
specify the group ID com.teamtreehouse
again, and let's specify the artifact ID.
6:05
And I'll just say another Maven project,
and
6:14
I will let Maven generate
a new Java project for
6:20
that, and then I'll change
directories to another Maven project.
6:24
And let me open this in IntelliJ.
6:29
Okay, I'll hop back over here.
6:34
Now, what I can do is open
this project's pom file and
6:36
in here, I can add a dependency for
6:42
our JAR file that is our
file-spy project that we created.
6:45
So, I will say dependency and
I'll use command J to trigger that.
6:50
Template there.
6:55
And the group ID is com.teamtreehouse.
6:56
The artifact ID was file-spy and
7:00
the version was 1.0-SNAPSHOT,
cool, and I'll save that..
7:04
Now what I'll do here is
I'll use the code from
7:13
app in my file-spy within this project.
7:16
So I'll pop open this project, and
I'm just going to rename my app file here,
7:19
since it's named the same
thing as my other project and
7:23
I didn't actually give it
a more specific package name.
7:27
So I'll rename this another app.
7:30
We'll do that re-factor.
7:39
Let me open another app.
7:41
Let's fix some code formatting in here.
7:44
All right, so here, what I can do is
I can import com.teamtreehouse.app.
7:52
Whoops.
8:00
There we go, and we should be able to
find that if I refresh this right here.
8:03
All right, looks like it found app so
I can run App.main from my other project.
8:10
I'll just pass at the args.
8:18
So this is just calling App.main.
8:19
Now, App.main in my other
project throws an exception so
8:22
I'd have to use a try catch here but
in any case you see
8:26
that we can run the code from our
other project now in this new project.
8:28
So that's how we can use the artifacts
that we create from Maven.
8:33
We can build our own libraries and
8:37
essentially our own dependency
library with Maven.
8:39
Pretty cool stuff.
8:43
I'm going to go ahead and
8:45
close this project because
we are done with this part.
8:45
Here is our original project.
8:49
Now, there are lots of other
phases that you can call directly
8:52
from the command line and
that are provided by Maven out of the box.
8:55
Beyond the functionality of
Maven I've already shown you,
8:58
there is great extensibility provided
by Maven's plugin architecture.
9:00
In fact, all the commands I've shown
you so far such as mvn compile,
9:04
mvn install, mvn package,
they all come from plugins.
9:10
And even if you didn't have to explicitly
add a plugin to your pom file, a Maven
9:15
plugin provides developers a way to attach
their own tasks called goals to phases.
9:20
So we have lifecycles, phases, and
9:25
goals putting it all together,
here's how they're related.
9:27
Each Maven builds lifecycle such as
the default lifecycle has specific phases
9:30
associated with it.
9:34
Think of these phases as categories
of tasks that need to be performed.
9:35
We've talked about some of these already
such as compile, test, and package.
9:39
Now at these phases are like categories
of tasks, the actual tasks in Maven
9:43
are called goals,
these goals are provided by plugins.
9:48
In other words,
plugins bind goals to phases.
9:51
These specific plugins
are shipped with Maven but
9:55
you can also use third party plugins and
even develop your own.
9:58
Speaking of plugins and
10:02
goals, let's run a goal from
the exact plugin short for execute.
10:03
And as you may have guessed,
we're gonna finally execute our code.
10:07
Here's how we can do that.
10:10
So first, I'm going to change
directories to file-spy.
10:11
And I'm gonna use the Maven command,
run a goal from the execute plugin,
10:18
and that is exec, and
that goal name is going to be Java.
10:23
And I'm going to pass the system
property exact.mainClass.
10:26
This will tell the exact plugin,
10:31
the fully qualified name of my
main class that I want to run.
10:33
Com.teamtree.house.app.
10:37
Now, this will start our application with
everything it needs in the class path.
10:43
Let me clear my command line there.
10:47
Cool.
Now I'm going to jump over to a finder
10:50
window, and
I've got some sample files here.
10:53
Now remember in our code,
we coded our application so
10:55
that it will only tell us when
a CSV file has been added.
11:00
So let's add all three of these and
11:04
make sure that our code only tells us
about the CSV file that was added.
11:05
I'm going to drag that into temp and I'm
going to switch back over to my terminal
11:09
and see if I see a message that says
the data file that CSV was added.
11:13
There it is, right there,
file found data.CSV.
11:18
Excellent.
11:21
Now there are many plugins out
there to help accelerate and
11:23
streamline your development process.
11:25
The exec is a nice plugin that helps
you run a maven application in place.
11:27
Check the teachers notes for
how to find more plugins for you to use.
11:33
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up