Install and configure the Exec Maven Plugin now to run your Java main class during a build. In your pom.xml, set artifactid to exec-maven-plugin and apply a lean setup that invokes a mainClass via exec:java. This will keep your build deterministic, and the saved configuration travels with the project.
Define the required parameter mainClass and the optional parameters like arguments, systemProperties, and workingDirectory. The plugin reads these from the configuration, and you can reuse a single setup for multiple modules.
Below is a concrete usage path: add the plugin to the build, set artifactid to exec-maven-plugin and specify groupId, version, and an execution to run exec:java. Use the attribut mainClass to name the entry point and supply the paramètres to pass input. For dynamic values, lookup configuration from httpwwwbarcomquery and feed them into the process. This approach pairs well with dropwizard apps that read config on startup from the bundle.
From there, you can compare saved time against the other approaches and reuse the same instance across modules. The component schemas and attribute offsets stay consistent, with the setup below to help teams move fast.
Set up JDK, Maven, and environment for the Exec Maven Plugin
Install JDK 17 LTS and Maven 3.9.x, then set JAVA_HOME and PATH and verify with java -version and mvn -v.
JDK and Maven installation
Linux (Debian/Ubuntu): sudo apt-get update && sudo apt-get install -y openjdk-17-jdk; export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64; export PATH=$JAVA_HOME/bin:$PATH; java -version; mvn -v
macOS: brew install openjdk@17; echo 'export JAVA_HOME="/usr/local/opt/openjdk@17"' >> ~/.zshrc; source ~/.zshrc; java -version; mvn -v
Windows: install OpenJDK 17, set JAVA_HOME in System Properties, add %JAVA_HOME%bin to PATH; download Maven binary, extract to C:maven, set M2_HOME and update PATH; verify with java -version and mvn -v
Exec Maven Plugin configuration and usage
Declare the plugin with groupId org.codehaus.mojo, artifactId exec-maven-plugin, version 3.1.0 to ensure compatibility with JDK 17 and modern Maven features. This choice aligns with the maven-plugin-plugin implementation and keeps the build lightweight.
Prepare environment mapping for target instances under different settings and load a single set of arguments via -Dexec.mainClass and -Dexec.args. Use a single -Dexec.args string to pass parameters; an arrays approach can help when you need multiple options, while keeping the launcher concise. The prefix for -Dexec.* properties clarifies which values belong to the main class and which belong to the classpath, and a clean mapping avoids killing the shell during long runs.
Run patterns and troubleshooting: mvn exec:java -Dexec.mainClass=com.example.Main -Dexec.args="start yyyy-mm-dd arg1" binds to the runtime phase and executes a single instance. For a packaging phase, you can attach to a phase like package via executions in the pom, then invoke mvn package to trigger the exec:java step with -Dexec.classpathScope=runtime. To load specific project settings, use -s /path/settings.xml. For quick reference, you might perform a search-like check at httpwwwbarcomquery to confirm documentation alignment and adjust the query or mapping as needed. If you maintain deprecated scripts, note that orgapacheant references may appear in legacy tasks and should be migrated gradually to the Exec Maven Plugin model.
Add a minimal plugin section to pom.xml for a quick start
Minimal plug-in configuration
To employ a minimal plug-in section for a quick start, add under build/plugins a single exec-maven-plugin configuration. Bind the execution to the post-integration-test phase and use a small prefix such as 'demo' to keep the scope clear. This introduction is intended for newcomers and keeps the pom saved with a lean footprint. Previously, teams relied on verbose boilerplates; this contrast shows how a compact configuration maps to a clean lifecycle. The plugin will start after tests, and a concise notice appears in the log when it runs. The execution is mapped to the post-integration-test phase. Documentation explains the required parameters; maps describe how execution goals relate to lifecycle steps, and the processes remain simple. The orgcodehausmojo pattern is referenced, and the source of truth is the official documentation, источник.
Validation and next steps
After adding, run mvn verify. The execution started and the plug-in will run during post-integration-test as configured; you will notice the log entry and the saved artifacts (if any). If you want to test another module, copy the same block with a different id; this keeps the processes isolated and enables easy comparison. This approach offers a clear contrast to larger configurations and supports quick validation. Documentation covers how to adjust the prefix and goals; maps define which phase triggers which execution, and the overall process remains lightweight. The источник for this practice remains the official docs, and you'll see that the setup will scale to multiple projects with consistent results.
Configure executable, arguments, and working directory for a sample task
Set executable, arguments, and workingDirectory in the Exec Maven Plugin configuration to guarantee predictable results across environments. Start with a simple, explicit setup for the sample task to avoid ambiguity.
Keep a single execution (id: sample-run) and define it as an object with three fields: executable, arguments, and workingDirectory. These three fields form small objects. This avoids collectionsarrays and reduces the risk of mis-binding. Some teams commonly adopt this pattern. The mechanism follows the standard execution path and is easy to rebind if paths change.
For example: executable: /bin/bash; arguments: -lc "echo health; exit 0"; workingDirectory: ${project.basedir}/scripts. The plugin coordinates use artifactid of exec-maven-plugin so the correct mechanism is enabled. For some projects, run on Windows (cmd.exe) or Unix shells; adjust executable and arguments accordingly.
Use properties to keep values portable: define them in the pom or via -D flags, and bind them to executable, arguments, and workingDirectory in a fully portable setup. They move with the project, avoiding drift between modules and builds. This is the configuring approach you’ll repeat for other tasks.
Validation remains straightforward: run mvn -q package and observe the console for the command output; the executions section should show a single run with the defined executable. If you need more runs, extend the object, but keep the configuration flat to reduce complexity. For deeper guidance, search videos and searches that illustrate a clean, repeatable pattern.
Run a simple command via Maven to verify setup and capture exit status
Choose the Exec Maven Plugin command below to verify setup and capture the exit status in one run. Use the plugin-prefix to invoke this quick check inside CI and local shells. This small check creates a single object representing a basic operation; the exit code indicates success or failure, and the time spent is measured in seconds for quick feedback. These checks were designed to run without external dependencies. For dropwizard projects, you can adapt this to verify the startup phase and then query an endpoint such as httpwwwbarcomquery to confirm the service is reachable. These steps are documented as a collection array and can be organized under a plugingroup named 'employ' to keep tests tidy, with several optional certificates for TLS if needed. These checks are designed to be extended with additional fields like code and fieldgetgenerictype below.
Run this exact command in your terminal to execute a simple echo and return code 0: mvn org.codehaus.mojo:exec-maven-plugin:3.1.0:exec -Dexec.executable=bash -Dexec.args='-lc "echo OK; exit 0"'
Command details
The command uses the plugin-prefix 'exec' and was designed to work across environments with minimal setup. It employs a single shell and prints a message, representing a minimal collection item that can be extended with additional fields like code, phase, or optional certificates in a real test model.
Interprétation des résultats
Une sortie nulle signifie que l'invocation Maven et la commande interne ont toutes deux réussi. Un code non nul indique une interruption de la configuration ou de l'exécution de la commande. Dans CI, capturez le code de sortie à l'étape d'exécution du job actuel et mappez-le à un indicateur booléen de succès pour les vérifications en aval. Le tableau ci-dessous montre des résultats représentatifs et comment les interpréter.
| Command | Description | Statut de sortie | Notes |
|---|---|---|---|
| mvn org.codehaus.mojo:exec-maven-plugin:3.1.0:exec -Dexec.executable=bash -Dexec.args='-lc "echo OK; exit 0"' | Imprime OK et retourne 0 | 0 | Chemin de succès ; secondes d'exécution, objet représentant une vérification simple ; préfixe de plugin utilisé |
| mvn org.codehaus.mojo:exec-maven-plugin:3.1.0:exec -Dexec.executable=bash -Dexec.args='-lc "echo FAIL; exit 1"' | Imprime FAIL et retourne 1 | 1 | Chemin d'erreur ; ajuster la configuration ou l'environnement |
| mvn org.codehaus.mojo:exec-maven-plugin:3.1.0:exec -Dexec.executable=bash -Dexec.args='-lc "sleep 2; echo done; exit 0"' | Attend un moment puis affiche "done" | 0 | Démontre la gestion des secondes ; convient aux vérifications de temps. |
Tag vs Tag : évaluer quand utiliser chaque approche de marquage dans les étapes de construction
Recommandation : Ajouter un tag au commit pour des instantanés inter-projets durables ; sinon, ajouter un tag aux étapes de construction pour marquer les jalons dans l’intégration continue. Aligner toujours le marquage avec votre documentation et vos règles, et définir des critères clairs afin que les équipes sachent quand appliquer chaque type de tag.
Le marquage basé sur les commits ancre une balise à un commit spécifique, créant une référence stable qui voyage avec le projet à travers les classes et les projets. Cette approche est idéale lorsque vous avez besoin d'une source unique de vérité contre laquelle d'autres équipes peuvent rechercher et fusionner, même après avoir commencé un nouveau travail. Utilisez un modèle de nommage cohérent comme project-yyyy-mm-dd ou project-
Le marquage des étapes de construction associe une étiquette à la construction elle-même plutôt qu'à un commit, ce qui convient aux constructions jalonnées et aux tests internes. Appliquez-le à une frontière de phase, comme après l'achèvement d'une phase ou lorsque goalstartgoal spécifique se termine, afin que l'étiquette reflète la sortie de construction exacte sans toucher l'historique source. Cette approche permet de conserver l'historique des commits propre tout en vous donnant une lignée d'artefacts traçables. Vous pouvez définir des étiquettes facultatives pour les exécutions expérimentales et réserver des étiquettes obligatoires pour les artefacts publiés, avec une précision au niveau des secondes dans les horodatages des journaux pour améliorer la traçabilité dans le journal de construction.
Règles pour choisir entre les deux : utilisez l'étiquetage des commits lorsque vous devez coordonner plusieurs projets qui doivent s'aligner sur le même état source ; utilisez l'étiquetage des étapes de construction lorsque vous souhaitez obtenir des commentaires rapides et minimiser le tumulte du SCM. Dans les deux cas, documentez les conventions de nommage des étiquettes, le cycle de vie des étiquettes et la manière dont les équipes doivent rechercher leurs étiquettes. Si une étiquette est fusionnée entre plusieurs projets, ils doivent pouvoir la localiser par projet, date et phase, puis vérifier l'instance et leur environnement par rapport à l'étiquette. Vous pouvez commencer par une politique à l'échelle du projet et l'étendre par classe ou module si nécessaire, en veillant à ce que chaque projet suive le même processus et utilise le même préfixe de plugin pour créer des étiquettes via les outils SCM.
Rediriger et enregistrer la sortie du plugin pour le débogage et la traçabilité
En commençant par une directive simple, redirigez la sortie du plugin vers un fichier dédié et fusionnez les flux pour garantir une trace complète et consultable.
Configuration patterns
- en commençant par un répertoire de logs sous ${project.build.directory}/logs et en s'assurant qu'il existe avant les exécutions ; cela permet de garder les fichiers organisés et prévisibles.
- définir un seul fichier journal nommé par exécution, par exemple target/logs/exec-20250101-120000.log, afin que le statut de fin et les erreurs apparaissent en un seul endroit.
- activer redirectErrorStream pour que stdout et stderr apparaissent dans la même section du fichier, ce qui simplifie la recherche et l'analyse.
- use a directory attribute for module paths and map each execution's line to a field that serves as an attribute identifying the source.
- injecter une expression simple pour calculer le chemin du journal à partir des propriétés, par exemple, ${project.build.directory}/logs/exec-${mojo.timestamp}.log, tout en conservant la configuration définie et réutilisable.
- inclure des références à des ressources associées dans un en-tête de journal, comme un lien httpwwwbarcomquery pour un accès rapide à une requête liée, par exemple myboundquerymojo ; cela permet aux utilisateurs de passer des journaux aux détails de la validation.
- enregistrez le contexte de l'engagement ou de la modification lorsque vous exécutez myboundquerymojo, pour que le rapport indique quelles modifications ont déclenché les exécutions.
Considérations relatives à la traçabilité et à la production de rapports
- stocker des entrées structurées pour les éléments, les valeurs d'attribut et les règles, afin de pouvoir rechercher par champ ou valeur sur plusieurs exécutions.
- collecter et regrouper les données dans des tableaux et des collectionsarrays pour le post-traitement dans les tableaux de bord CI.
- maintenir une source unique de vérité en incluant toujours un bloc récapitulatif en haut du journal avec le statut d'achèvement et une référence rapide aux fichiers créés.
- lien vers le répertoire du rapport et un exemple de chemin d'accès au rapport, par exemple target/logs/reporting.html, afin de faciliter la revue des résultats par l'équipe.
- garder la dénomination des journaux déterministe afin que la recherche entre les exécutions reste simple.
Intégrez le plugin dans un workflow CI pour des constructions reproductibles.
Exécutez toujours le plug-in dans un environnement CI propre afin que chaque build démarre à partir d'un état connu. Utilisez une commande mvn unique et explicite qui exécute verify et déclenche le Exec Maven Plugin pour effectuer une vérification d'environnement légère avant les tests. Cette approche garantit que rien dans l'espace de travail ne fuit entre les sessions, et elle verrouille les versions des dépendances et de Java/Maven utilisées par le build. Avec une CLI fixe et une configuration de plug-in déterministe, vous faites référence à un signal fiable concernant l'environnement plutôt qu'à des suppositions ad hoc. Si une incompatibilité de base est détectée, échouez le job immédiatement plutôt que de continuer, réduisant ainsi les secondes perdues et le travail de reprise.
Configurer le plug-in pour des constructions répétables
Configurez le plug-in dans le pom racine afin que le même mécanisme s'exécute dans chaque projet. Définissez une seule exécution qui se déclenche pendant la phase de validation et utilise exec:java pour démarrer une vérification minuscule et déterministe. La vérification imprime une empreinte fixe dérivée de la version Java, de la version Maven, du type de système d'exploitation et d'un hachage de l'ensemble des dépendances fourni ; si l'empreinte diffère de la référence donnée, la construction échouerait. Ce mécanisme évite la contrainte de valeurs et élimine tout risque d'un mappage différent des types d'environnement entre les projets. Utilisez des mappages qui associent les entrées CI (comme JAVA_HOME et le nom du système d'exploitation) aux paramètres du plug-in, afin que la deuxième exécution miroite la première exactement. Assurez-vous que la vérification s'exécute sans toucher les fichiers des sources principales et qu'elle s'exécute dans une session dédiée afin que chaque projet démarre avec une ardoise vierge.
Conseils opérationnels pour l'intégration continue
Placer les étapes CI de sorte que le plugin s’exécute avant la suite de test complète. La première étape valide l’environnement ; la seconde exécute les tests avec le même classpath et l’ensemble de dépendances, garantissant des résultats reproductibles. Gardez la ligne de commande simple : un seul mvn -B -DskipITs=false clean verify, avec le plugin configuré pour exécuter une classe Java minimale qui génère une signature de code stable. Reportez-vous aux mappings dans la configuration du plugin pour garantir que la portée des tests et la portée vérifiée utilisent les mêmes dépendances et objectifs de plugin. Utilisez une image CI dédiée qui fournit les types exacts d’outils sur lesquels vous vous appuyez, sinon la dérive se glissera. Dans les projets multi-modules, cette approche est évolutive car chaque module hérite de la même exécution de plugin, dans la même session, avec un temps de démarrage prévisible. Si un projet inclut des modules facultatifs, configurez le plugin pour les ignorer à moins que leur présence ne soit requise par le graphe de dépendances, sinon la construction pourrait diverger. Suivez les secondes passées sur la validation de l’environnement séparément de l’exécution des tests, afin de pouvoir quantifier le temps que prennent les vérifications initiales et optimiser le pipeline CI en conséquence. En cas d’échec, fournissez un journal concis avec les mappings exacts utilisés et l’empreinte qui a causé l’échec, permettant une résolution rapide et une correspondance reproductible entre les environnements de code et de test.
