
Begin your journey to Maven mastery as beginners become gurus, guided by the Java-focused Maven build tool, an online community, and real-time support from instructors and peers.
Meet your instructor for the Apache Maven: Beginner to Guru course, a long-time Java software engineer who uses Maven daily. Join a global Slack community for questions.
Complete the course by blocking time and staying committed. Fork the GitHub repository, follow along with branches to compare code, join the Slack community, and try IntelliJ Ultimate.
Maven dominates Java build tools, enabling project setup and dependency management through convention over configuration. It established a standard directory layout and artifact repositories used in enterprise and open-source projects.
Explore whether an integrated development environment is truly free by weighing IntelliJ's productivity features, fast JetBrains support, and a subscription against free alternatives.
Learn a practical GitHub workflow for the course by forking, cloning, and using branches to track lesson states, compare changes, and work locally in IntelliJ with a Maven project.
Install and set up Maven across Windows, macOS, and Linux by installing the Java JDK and adding Maven to your system path, establishing Maven as the course cornerstone.
Learn the system requirements to run Apache Maven, including hardware (8 gb memory, 250 gb disk, broadband), Java 11 JDK baseline, and IDE options like IntelliJ, Eclipse, and NetBeans.
Verify your development setup by confirming Java 11 or higher, installing the JDK, and using Maven 3.6.0 or higher to ensure compatibility with JUnit 5.
Install Maven by downloading it, setting it on your system path with Java JDK installed, and verifying the Java compiler and Maven version. Seek help on Slack if issues arise.
Explore how Maven compiles Java from the command line and the full compile process from source to bytecode, helping Java developers understand builds beyond ide masking.
Explore how Maven builds Java applications by compiling sources with javac, producing class files run by the Java virtual machine, and packaging into jar, war, ear, or fat jar deployments.
Explore a classic hello world in Java using a text editor, javac and java, and see how Maven automates compiling and packaging.
Create and run a java jar from the command line by packaging class files with jar cf, and running with java -classpath, while Maven handles packaging behind the scenes.
Learn how to use a third‑party jar with command line java, manage the classpath, and see how maven automates dependency management for multiple libraries.
Wrap up this section by reflecting on compiling Java from the command line, contrasting with modern IDEs or build tools, and previewing hands-on Maven in the next section.
Begin using Maven with a hello world example and a minimal project, then demonstrate adding a jar dependency. Follow a step by step approach as you grow into Maven basics.
Learn to compile and package a hello world Java project with Maven using a minimal pom and coordinates, Java 11, and build a jar with mvn clean and mvn package.
Declare a dependency in the pom with groupId, artifactId and version to bring commons-lang3 StringUtils in at compile time, demonstrated on a hello world project.
Create a new Maven project in IntelliJ, set groupId, version 1-0-SNAPSHOT, use Java 11, enable auto-import, and build with mvn clean and mvn package to generate the hello-world-1.0-SNAPSHOT.jar.
Add the Apache string utils dependency to the Maven pom using the integrated development environment, refresh dependencies, and print a line in the main class to verify integration with IntelliJ.
Add the commons-lang3 dependency to the pom, enable IntelliJ auto-import, and use StringUtils.capitalize to show hello world capitalized on the string-utils branch.
Conclude the getting started with Maven section by reviewing creating a project and performing a build with Maven, and preview much more complex Maven projects in depth.
Explore Maven basics, terminology, and how Maven works through core concepts. Review downloadable pdfs, establish a terminology baseline, and preview Maven internals and the broader ecosystem.
Identify artifacts with Maven coordinates by groupId, artifactId, and version for repository placement. Learn how snapshot and major, minor, incremental versions guide updates from local to remote repositories.
Explore how maven repositories store artifacts, including local .m2, central, and remote repositories, and how snapshots differ from releases in dependency caching via coordinates, jars, and poms.
Explore Maven Wagon, a unified transport API for moving artifacts to and from Maven repositories with providers like HTTP, file, FTP, SSH, WebDAV, and SCM.
Explore the Maven POM (pom.xml), an XML document that describes a build project, enforces the XML schema, and shows how inheritance from parent POMs yields the effective POM.
Explore Maven dependencies, including transitive and cyclic dependencies, dependency management, mediation, and scopes (compile, provided, runtime, test, system), plus practical tips with dependency:tree.
Discover the Maven standard directory layout, including src/main and src/test with Java and resources, enabling consistent build paths and integration testing across Java projects.
Explore Maven build lifecycles, phases, and plugin goals, including clean, default, and site lifecycles, and see how plugins bind to phases to execute builds.
Learn how the maven wrapper turns a project into a portable build by bundling a script around mvn, enabling version control, cross-platform execution, and easy version overrides.
Explore Maven archetypes as ready-made project templates, generate a new project with mvn archetype:generate from the command line or IntelliJ, and customize using standard, third-party, or custom archetypes.
Reinforce the core Maven basics, terminology, and features to solidify the foundation. Prepare learners to explore Maven plugins in the next module, using PDFs as study references.
Explore the core Maven plugins and how Maven acts as a plugin framework; gain hands-on experience with standard plugins, their common use cases, and how to configure them for scenarios.
Explore the Maven lifecycle plugins, including clean, compiler, resources, Surefire, jar, deploy, and site, plus Wagon, run, stage, and effective site concepts for building and deploying Java projects.
Explore the maven clean plugin and its effect on the target directory during packaging. Learn to hook clean into the default build lifecycle with mvn clean package.
Learn to use the Maven compiler plugin in IntelliJ, run compile and help goals, and adjust language levels from Java 11 to Java 6 to observe build behavior.
Explore the Maven resources plugin, learning how to copy and manage non-class files from src/main/resources (and test/resources), including filtering, encoding, and multiple resource directories for web assets.
Explore Maven Surefire plugin and how it runs tests from the test directory with JUnit, TestNG, Cucumber, and POJO tests. See how it generates reports and works with Maven goals.
Explore how to configure the Apache Maven Jar Plugin to create executable jars with a manifest, specify a main class, and manage classpath dependencies.
Explore the Apache Maven deploy plugin, publishing built artifacts to a remote Maven repository via distributionManagement, with settings for authentication and the deploy phase coordinating the full build lifecycle.
Learn how the maven site plugin generates a project website from content in markdown, apt, fml, or xhtml, and how to fix version conflicts by upgrading to site plugin 3.7.1.
Learn how to manage Maven projects with source control by configuring a robust .gitignore, excluding the target directory, and including the Maven wrapper, pom, and scripts for cross-platform builds.
Explore other Maven plugins bundled with Maven 3.6.0, including site plugin versions and lifecycle bindings, and distinguish bundled plugins from third-party plugins like Spring Boot.
Explore common Maven commands using a practical cheat sheet, including mvn clean, mvn validate, mvn test, mvn install, and dependency:tree, with notes on effective pom and multi-module projects.
Wrap up the discussion of common Maven plugins, establish the baseline, and preview hands-on, interactive Maven work with generated sources, while pointing to PDF resources as study guides.
Explore how Maven can generate Java source code during the build lifecycle, and practice with hands-on assignments to compile code into bytecode.
Generate Java classes from an XML schema with JAXB and Maven. Configure the jaxb2 plugin, run xjc, and produce generated sources like Product and CreateProductRequest in a Java 11 project.
Configure Maven to run the clean goal during the initialize phase for a JAXB project created from XML Schema, and practice a simple hands-on assignment with a live coding exercise.
Implement the Maven clean plugin to run automatically by configuring the pom with the maven-clean-plugin, phase initialize, and the clean goal; specify version 3.1.0 to ensure correct behavior.
Learn to generate pojos from a json schema using the jsonSchema2pojo Maven plugin: configure src/main/resources/schema, set the target package guru.springframework.model, and manage transitive dependencies with Jackson Databind and commons-lang3.
Tackle a Maven project by adding Lombok and a User class with three properties, using Data, NoArgs, AllArgsConstructor, and Builder to auto-generate getters, setters, equals, toString, and hashCode.
Set up a simple Maven project with Java 11, add Lombok as a dependency, enable annotation processing, and generate a Lombok-enhanced User class with @Data, NoArgs, AllArgs, and Builder.
Create a MapStruct Maven project to map between User and UserCommand with annotation processing. Implement bidirectional mappings for form binding and persistence.
Set up a maven project with java 11, integrate MapStruct to generate mapper implementations for converting user and user command objects, by configuring the maven compiler plugin and annotation processor.
Conclude the Maven course by outlining practical tools for generating source code within Maven, including Project Lombok and MapStruct, and comparing XML schemas with JSON approaches using XSDs.
Discover how the JVM runs Groovy, Kotlin, and Scala and interoperates with Java. Learn to set up Maven for each language and integrate them into projects.
Explore how Maven builds alternate JVM languages, Groovy, Kotlin, and Scala, by compiling to Java bytecode, managing plugins during the compile phase, and ensuring interoperability in a single jar.
Learn how to configure Maven to compile Groovy with the Groovy Eclipse plugin, add the groovy-eclipse-batch dependency, and point Maven to the Groovy plugin repository for current releases.
Configure Maven to compile Kotlin by adding the Kotlin version and dependency, and set up the kotlin-maven-plugin. Place Kotlin sources in src/main/kotlin and Java in src/main/java, then build.
Review Scala configuration with IntelliJ and Maven, including how the Scala Maven plugin replaces the default compiler for Java 8, while noting that Java 11 is not yet supported.
Conclude the module on alternate JVM languages by highlighting the three options and a Groovy plugin. This course serves as a recipe book to implement these languages in Maven projects.
Learn to set up and execute unit and integration tests in Maven using the Surefire and Failsafe plugins, with out-of-the-box support for JUnit 3, 4, and 5, TestNG, and Spock.
Explore testing with Maven by configuring Surefire and Failsafe for unit and integration tests using POJOs, JUnit 4/5, TestNG, and test-reporting and code coverage tooling.
Run pojo unit tests with the maven surefire plugin using the JavaHelloWorld class to verify the hello world output, and understand surefire's test naming and discovery rules.
Learn to configure Maven to run JUnit 4 tests with Surefire, add JUnit 4.12 dependency and test scope, and run tests in IntelliJ.
Learn how to set up JUnit 5 with Apache Maven, including adding JUnit 5 dependencies, externalizing the version with a property, and configuring the maven-surefire-plugin 2.22.0+ to enable JUnit 5 tests.
Learn to run JUnit 4 and JUnit 5 tests side by side in Maven by configuring Surefire with JUnit Jupiter API and engine, adding the Vintage Engine, and upgrading the Surefire plugin.
Add groovy support and a JUnit 4 dependency to a Maven project, then branch off master to prep for a forthcoming Spock integration video.
Review the assignment by integrating groovy support and JUnit 4 into a baseline Maven project, configure the maven-compiler-plugin with groovy-eclipse-compiler, add groovy-all and JUnit dependencies, and create a JUnit test.
Set up Groovy-based Spock tests in a Maven project by adding Groovy and JUnit support, adding Spock as a dependency, and configuring the Surefire plugin for reliable test runs.
Enable JUnit 5 in a Maven project alongside Spock by branching to a Spock with JUnit 5 and adding the JUnit 5 Jupiter vintage engine to enable JUnit 4 support.
Configure a Spock project to run on JUnit 5 by adding junit-jupiter-api, junit-jupiter-engine, and the vintage engine, ensuring Groovy-based Spock yields JUnit 4 bytecode.
Learn how to configure Maven Surefire for TestNG unit tests by adding the TestNG dependency, using the test scope, and running tests in IntelliJ with the SureFire report plugin.
Install and configure the maven-surefire-report-plugin to generate surefire reports within the site build lifecycle, override the maven-site-plugin to 3.7.1, and review tests in CI.
Learn how to configure and run integration tests with the maven-failsafe-plugin alongside Surefire, hook into the verify phase, and use integration test naming conventions.
Explore how the JaCoCo Maven plugin generates unit and integration test coverage reports, configures Surefire and Failsafe, and builds a history of your test coverage.
Enable the SpotBugs Maven plugin to generate code quality reports from your project, configure it in the POM, run site and verify lifecycles, and review SpotBugs findings alongside integration tests.
open Maven properties in IntelliJ and set a Maven home directory to use a custom version, such as apache-maven-3.6.0, instead of the bundled one, and verify with the Dmaven.home path.
Fork a broken maven project, fix the pom and dependencies, and submit a pull request. Learn how maven builds with xml pom, mvn clean install site, and open-source workflow.
Fork the repository, clone it, and import as a Maven project in IntelliJ; fix pom, update junit version and plugins, run mvn clean install site, and push a pull request.
Learn how to skip unit and integration tests in maven using IntelliJ toggles and -DskipTests/-DskipITs, with Surefire and Failsafe behaviors.
Conclude the Maven testing module by highlighting that tests must pass to complete the build, and that Maven provides built-in test support with separate unit and integration tests.
Master multi-module projects in Maven by learning how a Maven POM can contain submodules, with practical caveats and scalable structure for enterprise projects.
Explore multi module maven projects with a parent pom and child modules that inherit properties. The reactor builds modules sequentially, managing dependencies and flagging module overuse as a code smell.
Establish a multi-module Maven project by creating a top-level parent pom in IntelliJ, set packaging to pom, align the artifactId with the repository id, and copy the gitignore.
Create a multi-module maven project with a parent pom and a jpa-entities module. Define a User entity with @Entity, @Data, and @Builder using hibernate-core and Lombok, then install.
Learn to add a new Maven module in IntelliJ, configure the POM and packaging as jar, and understand the reactor build order during a clean and verify cycle.
Create an API module using XML to generate a UserCommand object with first name, last name, and email, packaged as a jar in web-api within a multi-module Maven project.
Create a new Maven module named web-api in the IntelliJ project, configure a child POM with JAXB dependencies and plugin, and generate a UserCommand class from an XSD.
Demonstrates adding a web-app module with dependencies on api and entities, explains transitive dependencies, local repository installation, and how Maven's reactor build order determines compile order.
Implement MapStruct converters to transform between User and UserCommand objects, and create a new converters module with dependencies on jpa-entities and web-api for the web-app in a multi-module Maven project.
Add a converters module, configure MapStruct in the child module, generate a UserMapper, and wire the generated mapper into the web-app with explicit dependencies.
Externalise the version to a Maven revision property to propagate it across parent and child POMs and dependencies, enabling command-line overrides with -D revision.
Use the maven flatten plugin to substitute version and revision properties in a flattened pom, enabling correct artifact versioning when publishing.
enforce java 11 and maven 3.5+ using the maven enforcer plugin, configure environment rules, and fail builds that don't meet version requirements for consistent ci and local environments.
Repair a broken multi-module Maven project by fixing errors from a GitHub repository, then run mvn clean install from the project root to install to the local Maven repository.
Fix a broken multi-module maven project by repairing missing modules and restoring dependencies. Run mvn clean install to verify the build and resolve schema and code-generation issues across modules.
Explore how the Maven bill of materials standardizes dependencies via dependencyManagement in the POM, where listed artifacts do not become transitive and versions are inherited across modules.
Refactor a multi-module Maven project to use a BOM in the parent POM, manage MapStruct and other dependencies via dependencyManagement, and externalize versions for easier maintenance.
Explore the versatility and power of Maven multi module projects, and use them responsibly to prevent build slowdowns from unnecessary interface implementation splits.
Apache Maven is the most popular Java build tool. Companies and Open Source communities around the world, consider Apache Maven the 'go-to' build tool for their Java projects.
In this course, you will learn to master Apache Maven. You will become a 'guru' using Apache Maven.
No previous experience with Apache Maven is required.
In just a few lessons, you will be building your first Apache Maven project!
In this course, you will:
Learn about the Maven Build Lifecycles
Use Maven to build and package Java projects
See how to use Maven with popular alternative JVM languages, including Groovy, Kotlin, and Scala
Configure Maven to run your unit and integration tests written in JUnit 3, JUnit 4, JUnit 5, TestNG, and Spock
Generate source code from XML and JSON Schemas
Leverage annotation processing at compile time for Project Lombok and Mapstruct
Learn in depth about the Apache Maven plugin system and see how plugins are used in the build lifecycle
Build Spring Boot applications with Apache Maven
Improve your code quality with code coverage and spot bugs reports
Unlock valuable capabilities of the Spring Boot Maven plugin!
Deploy project artifacts to Maven repositories
Develop multi-module Maven projects
Learn how to use Maven Build Profiles
Perform Releases using the Maven Release Plugin
How to use Maven for Enterprise Dependency management by using BOMs
And much more!
This is course is for the modern Java developer.
The entire course has been developed using Java 11.
Course Extras
All Source Code in GitHub - Get access to over a dozen GitHub repositories with valuable examples!
Slack Community - Join the instructor, teacher's assistants, and over 1,100 other students in a Slack Community exclusive to this course!
Free 120 Day IntelliJ Ultimate Trial - Students enrolling in the course can request a free 120 day trial for IntelliJ Ultimate (the most popular Java IDE!)
Closed Captioning / Subtitles - Closed captioning in english is available for all course videos!
PDF Downloads - All keynote presentations are available for you to download as PDFs.
Lifetime Access - When you purchase this course, you will receive lifetime access! You can login anytime from anywhere to access the course content.
Apache Maven is used by over 70% of Java organizations. Employers are seeking people with strong Maven skills.
Completing this course, you will be able to answer interview questions about Maven with confidence!
Even if you're already a Java developer using Apache Maven, this course will improve your Maven skills and show you new valuable best practices for your Java projects.
Enroll today!