OpenCourser
Learn skills that shape your future
Visit OpenCourser.com
The Maven Crash Course is designed to cut academic theory to just the key concepts and focus on basics tasks in Maven in order to be productive quickly. The lessons and examples provided are delivered in a step-by-step, detailed way to ensure mastery of the skills and topics covered.
Course Outline
Introduction walks through the course goals, approach and then define Maven.
After just a little bit of Theory in Core Concepts, we step through Maven Installation on Windows and Mac OS X.
The Maven Crash Course is designed to cut academic theory to just the key concepts and focus on basics tasks in Maven in order to be productive quickly. The lessons and examples provided are delivered in a step-by-step, detailed way to ensure mastery of the skills and topics covered.
Course Outline
Introduction walks through the course goals, approach and then define Maven.
After just a little bit of Theory in Core Concepts, we step through Maven Installation on Windows and Mac OS X.
In Setup and Getting Help, we cover how to ask for help in Maven. We also download the course working files on GitHub.
After the setup and installation of Maven, we get hands-on in Getting Started as we create our first Maven project keeping it simple with a minimal demo. Maven Basics covers additional concepts. The concepts are continued in Beyond the Basics as we look into dependencies, repositories and plugins within Maven. Then we improve our project by Unit Testing where we add JUnit tests, deal with (and avoid) testing failures. Finally, the last section of the main part of this course is dedicated to running Maven within Eclipse using the M2Eclipse plugin.
During the entire course, we get into a habit of saving our changes periodically using Git source control.
Finally, the Bonus section provides some extra lessons to compliment the course and add value. These lesson are non-critical and thus don't belong in the main part of the course.
Course Features
Presentations provide audio/video training of conceptual ideas. Since few like slide-ware presentations, slide-presentations are kept to a minimum (about 20 minutes).
Over 2 hours of Screencasts provide a video of the instructor's computer system with any actions, commands, or screens displayed and narrated.
At the end of each section containing command line interaction, Command Listing lectures that serve as reference and reminder of the commands used in the previous lecture(s). Each Command Listing includes the exact listings used in the previous lectures. All commands used in this course are available through the Command Listing lectures.
The Quizzes at the end of each section reinforce the key concepts by testing your newly learned knowledge throughout the course.
Project files and examples are all available on GitHub.
This lecture provides an introduction to this course by listing the course objectives and goals.
This lecture provides a simple definition of Maven, including enumerating some key features.
This lecture describes the reasons the instructor will start with the command-line / terminal with Maven instead of using a graphical client.
An overview of the core concepts that will be covered in this course, including Maven's preference for convention over configuration, the Project Object Model (POM), dependency resolution, Maven repository, lifecycle, and Plugins.
Explaining how dependency resolution works through the chains of dependencies calling on each other, as well as an explanation of how the Maven repository is structured to host your artifacts.
An explanation of the three building blocks of Maven: goals, phases, and lifecycles. And a further explanation of how those work with plugins.
Test concepts learned in the Course Introduction and Core Concepts sections of this course.
An overview of the quick installation that will be done in this section. The required tools are the Java JDK, a decent text editor, Git, and of course Maven.
Installing the software development tool Maven onto our local Windows system.
Installing the software development tool Maven onto our local Mac OS system.
A quick look into how to get help within Maven on our terminal program.
Setting up our project files within our terminal and installing the files we need into the directory from GitHub.
Creating our first maven project from our GitHub repository example code, and running that first project by executing the package goal.
Creating a Hello World Java source code example in the main Java folder in our Maven project in order to have something to execute when running our Maven project.
Executing both the clean and package goals to get our lifecycle going in Maven, in order to review the output in our command to see how Maven builds our project.
Committing our Maven repository's changes to the Git repository we have set up on our local system, making sure to use the ".gitingore" to exclude the target directory.
Downloading an optional helper bash script from GitHub that will set up a skeleton version of a Maven repository using the script.
Creating a standard Java based maven repository by executing the bash script we downloaded in the previous lesson.
Creating the Hello world Java file in the appropriate folder within our Maven project, pasting in the basic hello world Java source code we copied from the GitHub repository.
Updating all of the default values from the Maven POM file in order to add proper Metadata to our Maven project, then re-building our POM to see any changes it created.
Using the "finalname" tag within our Maven POM to rename the final output of our Maven project.
Installing our jar file to our local Maven repository.
Adding and committing our changes from this section to our Git repository, while also adding more unwanted files to our ".gitignore" file.
Setting up our project for this section named words, copying in the contents from our GitHub example repository to replace the automatically created pom, then adding in the Java source code in the expected folder.
Troubleshooting the issues of our project not initially building due to the dependencies not being specified in our Maven POM. We will search for the libraries on Maven Central and then add them to our POM to get it to build.
Committing our changes to our Git repository now that our project has it's needed dependencies.
Reviewing the files Maven generated and placed into the target directory on our local system.
Looking at the local maven repository in the "m2" folder where our final Jar output is placed to explore all of the dependencies that our build is using.
Using Maven's main website to look at all of the Maven dependencies that we are using, then using a command to list out all the plugins we are using in in a specific project.
Compiling our Maven project while targeting a newer version of Java in order to take advantage of newer Java features.
Committing our changes from this section to our Git repository.
Adding unit testing to our "words" Maven project using junit using source code from the GitHub repository.
Running our Unit test results to see what errors come up in order to find and add all of the dependencies needed, before finally compiling our finished unit test program.
Modifying our application test file in order to force a failed build to see what happens when unit tests fail.
Skipping our unit tests in order to still allow a project to create a finalized build without passing the tests.
Disabling unit tests on a permanent basis by configuring our pom to ignore the unit tests we would otherwise run.
Getting a better more human readable version of the Unit tests results by modifying our POM xml by running the maven site phase to generate an HTML report of our unit tests.
Committing our changes from this section to the Git repository on our local system.
Quiz covering dependency management, plugins and unit testing.
A complete guide to installing the integrated development environment Eclipse to your local Windows system.
Configuring your installation of Eclipse in order to work with our installation of Maven on our system.
Adjusting our settings on Mac OS X in order to allow applications from anywhere to be installed onto our local Mac system.
A complete guide to installing the integrated development environment Eclipse to your local Mac OS system.
Creating our first new maven project within Eclipse, letting the IDE handle the busy work of creating all the needed files and folders.
Creating our first Java class within the Eclipse IDE, making a basic hello world example output before finally running that output.
Importing an existing Maven project we have already created into our Eclipse IDE, choosing which goals will be run when we run the project within Eclipse.
Using eclipse to modify the POM XML file with a graphical interface.
Using Maven archetypes to jump start a newly created Maven application.
Save
Covers essential tools like Git and Eclipse.
Clear guides for different operating systems.
Focuses on doing rather than just theory.
Designed for those new to Maven.
Builds foundational understanding.
SaveSaveSaveSaveOpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.
Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.
Find this site helpful? Tell a friend about us.
We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.
Your purchases help us maintain our catalog and keep our servers humming without ads.
Thank you for supporting OpenCourser.
