Maven Quick Start: A Fast Introduction to Maven by Example

An overview of what this section provides, an express installation for all of the tools that we will be using in this course.

A quick guide to installing and configuring all the tools for this course on our Windows system, including Git for Windows, Notepad++, Java JDK, and Maven.

A quick guide to installing and configuring all the tools for this course on our Mac OS X system, including Git from Apple, Text Mate 2, Java  JDK, and Maven.

An overview of the topics covered in this quick start section, including our first Java project, small bits of theory, getting started on GitHub, creating a project in Maven, using POMs, demoing lifecycles, and updating GitHub.

Setting up the GitHub repository to be used with the Maven project in this section.

Cloning our project down from GitHub to synchronize it, then creating our initial project folder we will be using in this section.

Finding the GitHub repository that will be used throughout this course on the instructor's GitHub page.

A quick overview of the theory of the Maven lifecycle, which mainly goes through compile, test, package, install, and deploy.

Setting up our first POM XML by using the sample basic one found on the example GitHub repository.

Updating our source control system by committing our changes that we have made so far.

Explaining the standard way in which directories are laid out in Maven, which allows Maven to find files without having to specify their location, as long as they follow this default file structure. This concept is known as convention over configuration.

Setting up the default Maven folder structure so that we can initially run projects in Maven.

Committing empty folders to Git by placing dummy files at the end of folder structures that we want to save.

Adding the Java source code to our initial project, creating the expected directory structure to make sure that the project will run smoothly.

Exploring the target of our just executed Java project within our Maven build, finishing by executing the new file.

Cleaning out our project workspace after our build has been built by using the clean phase goal.

Executing multiple goals at once in order to simplify maven by specifying both clean and package to clean out any artifacts before re-packaging our build.

Looking at the local maven repository after executing the Maven install command, which will run further than the package command we have been using.

Cleaning up our current repository by making sure we are ignoring the correct parts of our Maven repository and then pushing these changes up to our GitHub repository.

An explanation of the critical base of Maven, plugins, including an overview of what they do, how plugins depend on one another, and what plugins are considered core to Maven itself.

Looking up the documentation for plugins that we have been using in order to understand how to change the defaults within those basic plugins, such as targeting a different version of Java.

Using more modern features of java within our source code, which will require us to then change our Maven configuration file to take advantage of it by rendering with a newer version of Java.

Using a custom plugin configuration in our main POM XML in order to target a newer version of Java with the feature set that we required from the previous lesson.

Executing the application we just modified and viewing the Maven results that occur.

Cleaning up the extra files by adding and committing our changes to our local Git repository and then remote GitHub repository.

Managing dependencies within Maven through the use of the Maven Central or other repositories that are called on by the plugin's own POM XML files.

Modifying our Java application to be ready to take advantage of plugins in Maven by requiring and using the Java library "StringUtils".

Resolving the dependencies by compiling our code and viewing the errors to understand where to look for our needed dependencies. We then add those researched plugins onto the POM XML as a dependency to force Maven to download the needed resources to be able to compile our Java project.

Saving our changes in Git and then pushing them back up to GitHub to make sure that we have a detailed history of what we have done in this course.

Viewing a list of dependencies for an active project to get an idea of what Maven will be downloading and installing on your system when you run the POM XML.

A quick overview of the topics that will be covered about unit testing in this section, including the tests themselves and prepared code for those tests.

Adding code to our Maven project in order to run the unit tests within our Java project.

Modifying our POM XML to add the dependencies we will need to use for the unit tests we will be running.

Running the tests we haves set up in previous lessons, reviewing the output of the tests in order to demonstrate how the tests themselves work.

Viewing the reports that are generated by "surefire" when we ran our tests in the previous lesson. There is an XML file to be read by automated systems, and a human readable text file that summarizes our test results.

Saving our changes in Git and then pushing them back up to GitHub to make sure that we have a detailed history of what we have done in this  course.

Introducing an IDE to allow us to work graphically with our Maven projects.

A quick install guide to installing the IDE eclipse on our local Windows system.

A quick install guide to installing the IDE eclipse on our local Mac system.

Creating a new Maven project within Eclipse, viewing the "hello world" type example files that are included when creating a base project.

Using Eclipse to import the projects we have previously created by looking for their POM XML files.

Reviewing the POM XML with the visual features that are added by Eclipse.

Using Eclipse to run the Maven project we imported in a previous lesson, looking at the output within the terminal window in Eclipse, as well as modifying the goals that are run when we run the Maven project.

Using Eclipse to save changes in Git and push those changes up to GitHub using the native Git integration.

An overview of what archetypes are and why you might want to use them over starting from scratch.

A quick look at how Maven archetypes can help jump start your Maven projects. This will be done through researching how to use and then using the default archetype to generate our new project.

Exploring the new project that we created through the archetype feature in Maven, finishing off by deleting the project to start over in the next lesson.

Using a more verbose command to create a Maven archetype without stepping through the wizard that we used last time.

Reviewing the project we just generated through the Maven archetype, building our project and then reviewing the artifacts from it.

A final summary of what we have learned about Maven in this course.

A guide to the programs that will be installed in this section, including Chrome, Git for Windows, Notepad++, Java, and Maven.

Determining whether the platform you are on is 64 or 32 bit to ensure you install the correct version of software for your system.

Installation of the web browser Google Chrome on our local Windows system.

Installing the versioning software Git for Windows onto our local Windows System.

Getting help on commands we are going to be using in this course by using the "git help" command to detail how to use things.

Setting up the minimal configuration needed by Git to get our Git for Windows setup working.

Installing the text editor Notepad++ onto our local Windows system.

Integrating our text editor Notepad++ with our install of Git for Windows.

Installing the software development tool, the Java JDK, onto our local Windows System.

Configuring our local system to have a virtual link to our Java installation through the Java_home variable.

Installing the software development tool Maven onto our local Windows system.