skip to content

Execution Environment & Performance

2 roadmaps19 questions

Bootstrapping and accelerating Maven: pinning the version with the wrapper, scaffolding from archetypes, parallel and daemon execution, and gluing extra steps into the lifecycle. Interviewers reach for this area as soon as the subject turns to slow CI.

on this pageshow

explore

questions

19

What is a Maven archetype, and how do you use archetype:generate to scaffold a new project?

level: juniorimportance: must knowfreq 55%

answer

  1. project template = artifact (g/a/v)
  2. mvn archetype:generate
  3. asks groupId/artifactId/version/package
  4. quickstart vs webapp
  5. -DinteractiveMode=false for CI

basics

~10 s

An archetype is a project template. You run mvn archetype:generate, pick a template, and answer prompts for groupId, artifactId and version; Maven creates a ready-to-build project skeleton from that template.

solid answer

~40 s

A Maven archetype is a reusable project template packaged as its own artifact (groupId/artifactId/version). The `maven-archetype-plugin` consumes it: `mvn archetype:generate` runs an interactive wizard where you choose an archetype from a catalog and supply the new project's coordinates (groupId, artifactId, version, package). The plugin then materializes a fresh directory tree — pom.xml, source folders, sample classes/resources — substituting your values into the template's placeholders. You can skip the wizard by passing `-DarchetypeGroupId`, `-DarchetypeArtifactId`, `-DarchetypeVersion` plus `-DgroupId`, `-DartifactId` and `-DinteractiveMode=false` for CI or scripted use. Common archetypes include `maven-archetype-quickstart` (a basic JAR app with JUnit) and `maven-archetype-webapp`. It standardizes layout and conventions across teams, so every new module starts the same way.

code

bash · 8 lines
bash
mvn archetype:generate \
  -DarchetypeGroupId=org.apache.maven.archetypes \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DarchetypeVersion=1.4 \
  -DgroupId=com.example \
  -DartifactId=my-app \
  -Dversion=1.0.0-SNAPSHOT \
  -DinteractiveMode=false

go deeper

for a junior

Knows archetype = template and can run archetype:generate interactively to scaffold a project.

for a middle

Can drive it non-interactively with full coordinates and knows quickstart/webapp.

for a senior

Uses archetypes to standardize team layout; weighs them against alternatives like a shared parent POM or copier/cookiecutter.

for a principal

Defines org-wide scaffolding strategy, governs archetype versioning and catalog hosting, and decides when archetypes vs other tooling are the right standardization mechanism.

## What an archetype is A **Maven archetype** is a *project template*. Instead of hand-creating `pom.xml`, the `src/main/java` and `src/test/java` folders, and boilerplate files for every new project, you generate them from a template. An archetype is itself a normal Maven artifact identified by coordinates: a **groupId** (organization namespace), an **artifactId** (the template's name), and a **version**. ## The plugin and the generate goal The `maven-archetype-plugin` provides the machinery. The headline goal is `archetype:generate`: - It shows (or you preselect) an archetype from a **catalog** — a list of available templates. - It asks for the *new* project's coordinates: `groupId`, `artifactId`, `version`, and `package` (the base Java package). - It copies the template's files into a new folder named after your `artifactId`, replacing placeholders with your values. ## Interactive vs batch mode By default the wizard is interactive. For automation you pass everything on the command line and disable prompts with `-DinteractiveMode=false` (sometimes written `-B`/`--batch-mode`). You must then specify both the archetype's coordinates and the new project's coordinates. ## Common built-in archetypes - `maven-archetype-quickstart` — minimal JAR project with an `App` class and a JUnit test. - `maven-archetype-webapp` — WAR project with `web.xml`. - Many frameworks (Spring Boot historically, Scala, etc.) ship their own. ## Why teams use them Archetypes enforce **consistency**: identical directory layout, parent POM, plugin versions, and conventions for every new module. That reduces onboarding friction and copy-paste drift. ```bash # Interactive wizard mvn archetype:generate # Fully scripted (no prompts) mvn archetype:generate \ -DarchetypeGroupId=org.apache.maven.archetypes \ -DarchetypeArtifactId=maven-archetype-quickstart \ -DarchetypeVersion=1.4 \ -DgroupId=com.example \ -DartifactId=my-app \ -Dversion=1.0.0-SNAPSHOT \ -Dpackage=com.example.myapp \ -DinteractiveMode=false ```

  • How do you run archetype:generate non-interactively in a CI pipeline?
    Pass all archetype coordinates (-DarchetypeGroupId/ArtifactId/Version) and the new project coordinates (-DgroupId/-DartifactId/-Dversion), and add -DinteractiveMode=false (or -B) so no prompts appear.
  • What is the difference between maven-archetype-quickstart and maven-archetype-webapp?
    quickstart produces a plain JAR project with a sample App class and JUnit test; webapp produces a WAR-packaged project with a web.xml and webapp directory layout for servlet/JSP apps.

Like a 'New Project from template' file menu, but the templates are versioned artifacts you can publish and share.

saying these in an interview costs you the question

  • Thinking an archetype is a Maven plugin you write code in — it is a template artifact consumed by the archetype plugin.
  • Believing archetypes are required to create a Maven project (you can write pom.xml by hand).

context

resolving links…

open as a page

What is the Maven Wrapper, and why would a project commit mvnw/mvnw.cmd into its repository?

level: juniorimportance: must knowfreq 70%

basics

~20 s

The Maven Wrapper is a small script (mvnw on Unix, mvnw.cmd on Windows) checked into the repo. Running ./mvnw downloads and uses a fixed Maven version automatically, so everyone builds with the same Maven without installing it.

open as a page

How do you run a multi-module Maven build in parallel, and what does the -T option actually control?

level: middleimportance: must knowfreq 65%

basics

~10 s

Use the -T flag, e.g. mvn -T 4 install for 4 threads or mvn -T 1C install for one thread per CPU core. Maven builds independent modules of the reactor concurrently.

open as a page

Walk me through the contents of .mvn/wrapper/maven-wrapper.properties — what do distributionUrl and wrapperUrl control?

level: middleimportance: must knowfreq 55%

basics

~10 s

distributionUrl is the URL of the exact Maven version zip the wrapper downloads and runs. wrapperUrl is where the wrapper's own bootstrap jar is fetched from. Changing distributionUrl pins a different Maven version.

open as a page

What is the build-helper-maven-plugin, and what kinds of problems does it solve in a Maven build?

level: juniorimportance: should knowfreq 45%

basics

~10 s

It's a utility plugin that adds small 'glue' goals Maven core lacks: registering extra source/test folders, attaching extra build outputs as artifacts, parsing versions, extracting a property by regex, and reserving free network ports.

open as a page

Explain the -o (offline) option and the difference between --fail-fast and --fail-at-end in a reactor build.

level: juniorimportance: should knowfreq 45%

basics

~20 s

-o builds offline using only the local repository, with no network access (faster, deterministic, but fails if something is missing). --fail-fast (default) stops at the first failed module; --fail-at-end keeps building independent modules and reports all failures at the end.

open as a page

What is an archetype catalog (archetype-catalog.xml) and how does Maven decide which archetypes are offered during generation?

level: middleimportance: should knowfreq 35%

basics

~10 s

A catalog is an XML file listing available archetypes by coordinates. archetype:generate reads catalogs (local, internal, remote, or a custom URL) and shows you that list to pick from.

open as a page

How does build-helper:attach-artifact work, and when would you use it instead of producing a separate Maven module?

level: middleimportance: should knowfreq 35%

basics

~10 s

attach-artifact registers an extra file (built by some earlier step) as a secondary artifact with a classifier and type, so mvn install and deploy publish it alongside the main JAR under the same groupId/artifactId/version.

open as a page

Walk through using build-helper:reserve-network-port to make integration tests safe to run in parallel. Why is it needed?

level: middleimportance: should knowfreq 25%

basics

~20 s

reserve-network-port finds free TCP ports and stores them in Maven properties. You bind it before your test server starts, then point the server and tests at those properties instead of a hardcoded port, so concurrent builds don't clash.

open as a page

How would you profile a slow Maven build to find where the time goes, especially in dependency downloads?

level: middleimportance: should knowfreq 30%

basics

~10 s

Use a profiling extension like maven-profiler or -Dmaven.profiler style timing, and check -X (debug) logs to see per-plugin/goal durations. For downloads, watch resolution logs, point at a fast mirror/Nexus, and pre-cache with dependency:go-offline.

open as a page

How do you create or upgrade the Maven Wrapper in a project, and what does the wrapper:wrapper goal do?

level: middleimportance: should knowfreq 45%

basics

~10 s

Run mvn wrapper:wrapper. It generates mvnw, mvnw.cmd, and .mvn/wrapper files. Add -Dmaven=<version> to pin a specific Maven version. Re-running it with a new version upgrades the wrapper.

open as a page

How do you author a custom archetype, and what is the role of archetype-metadata.xml?

level: seniorimportance: should knowfreq 30%

basics

~10 s

Create an archetype project whose template files live under src/main/resources/archetype-resources, and describe them — required properties, file sets, packaged folders — in src/main/resources/META-INF/maven/archetype-metadata.xml. Build and install it like any artifact.

open as a page

Compare exec-maven-plugin and maven-antrun-plugin for binding a custom step to a phase. When would you choose each, and what are the trade-offs?

level: seniorimportance: should knowfreq 40%

basics

~20 s

exec-maven-plugin runs an external program (exec:exec) or a Java main on the project classpath (exec:java). maven-antrun-plugin runs inline Ant tasks (copy, mkdir, echo, etc.). Use exec for one external command/Java, antrun for small file/scripting glue.

open as a page

What is mvnd (the Maven Daemon) and why can it be faster than plain mvn?

level: seniorimportance: should knowfreq 35%

basics

~10 s

mvnd runs Maven inside a long-lived background daemon (JVM) that stays warm between builds. It avoids repeated JVM startup and lets the JIT-compiled, class-loaded state be reused, so repeated builds start faster.

open as a page

How does using the Maven Wrapper improve reproducibility in CI, and how would you set up CI to use it well?

level: seniorimportance: should knowfreq 40%

basics

~20 s

CI calls ./mvnw instead of mvn, so it builds with the exact Maven version pinned in the repo — matching developer machines. Cache ~/.m2 (deps) and ~/.m2/wrapper (the Maven distro) so it isn't re-downloaded each run.

open as a page

What are the security and governance considerations of shipping the Maven Wrapper, especially the committed jar and the distributionUrl?

level: principalimportance: should knowfreq 25%

basics

~20 s

The wrapper executes code from a committed jar/script and downloads Maven from distributionUrl, so both are a supply-chain surface. Mitigate with sha256 checksums, an internal mirror URL, the only-script type to avoid a committed binary, and reviewed upgrades.

open as a page

How do build-helper:parse-version and build-helper:regex-property work, and what are realistic uses for the properties they produce?

level: middleimportance: nice to knowfreq 18%

basics

~10 s

parse-version splits the project version (e.g. 2.4.1-SNAPSHOT) into properties like parsedVersion.majorVersion/minorVersion/incrementalVersion/qualifier. regex-property creates a property by applying a regex find/replace to a value. Both feed naming, filtering, and conditional config.

open as a page

What does the maven-build-cache-extension do, and how does it decide whether to skip rebuilding a module?

level: seniorimportance: nice to knowfreq 20%

basics

~20 s

It caches the outputs of each module keyed by a hash of that module's inputs (source files, POM, dependencies, plugin config). If the hash matches a prior build, Maven restores the cached output (e.g. the jar) instead of recompiling and re-running goals.

open as a page

When would you standardize project creation with archetypes versus other approaches, and how do you keep them maintainable across an organization?

level: principalimportance: nice to knowfreq 18%

basics

~10 s

Use archetypes when you want Maven-native, versioned, catalog-discoverable scaffolding. Keep them maintainable by versioning, integration-testing generation, and pairing them with a shared parent POM so ongoing config drifts less.

open as a page