Installer Maven
Introduction
maven est un outil pour construire des programmes ou des bibliothèques Java qui privilégie la convention plutôt que la configuration.
Le concept de convention plutôt que configuration (convention over configuration) te demande de suivre des règles prédéfinies pour la mise en place de ton projet, ce qui t'évite d'avoir à fournir de nombreuses options de configuration.
🤓 À la fin de cette quête, tu sauras :
✅ Savoir ce qu'est maven et comment il fonctionne ✅ Savoir installer maven sur ton ordinateur ✅ Savoir construire des programmes et des bibliothèques Java avec maven
Historique et alternatives
Maven n'est pas le premier outil de build (build : compilation et assemblage du projet). Les premières versions de Java utilisaient des outils de build externes comme make, habituellement utilisé avec le langage de programmation C.
Un autre outil de build est ant, qui était très populaire et écrit en Java lui-même. Le plus gros problème avec ant, c'est que tout le monde l'utilisait d'une façon différente, ce qui rendait difficile l'utilisation de programmes venant d'autres entreprises ou organisations, ou même la réutilisation de projets plus anciens aux attentes incompatibles. Les fichiers qui décrivent un projet pour l'outil de build ant sont au fond des fichiers XML.
Certains langages alternatifs pour la JVM (Java Virtual Machine, la machine virtuelle Java qui exécute le code Java) utilisent leur propre outil de build. Par exemple, le langage de programmation Scala utilise l'outil de build sbt, qui se sert de Scala pour décrire le projet. Du coup, tu n'as pas besoin d'apprendre un nouveau langage pour construire des programmes avec l'outil de build sbt.
Grade, un autre outil de build, utilise Groovy, qui est encore un autre langage pour la JVM. Groovy est un langage flexible que tu peux utiliser pour construire ton propre DSL (domain specific language, langage dédié à un domaine). Gradle, vu sous un autre angle, est un DSL pour construire des programmes ou des langages basés sur Groovy. Là encore, tu n'as pas besoin d'apprendre un autre langage pour l'outil de build.
Beaucoup d'autres outils de build sont utilisés, mais ils sont moins populaires.
Installer maven
Pour installer la dernière version (ou n'importe quelle version spécifique à un projet) de maven, tu dois télécharger la distribution binaire depuis le site Apache Maven. Les développeurs veulent en général la dernière version, ou une version plus récente que celle disponible dans le gestionnaire de paquets du système d'exploitation.
Choisis l'archive binaire tar.gz dans la section Downloads et extrais les fichiers avec
tar xvzf apache-maven-3.6.3-bin.tar.gz
Tu peux toujours déplacer le dossier maven plus tard. Ajoute le dossier bin/ de l'archive maven extraite à ton path (path : la liste des dossiers où le système cherche les programmes à exécuter), pour t'éviter de toujours donner le chemin complet vers le binaire maven.
apache-maven-3.6.3-bin.tar.gz est la version actuelle de maven au moment où ces lignes sont écrites. La version a peut-être changé pour une révision plus récente. La meilleure option pour le téléchargement est en général la dernière version stable.
Pour vérifier que ton installation a réussi, tape
mvn --version
en ligne de commande. Maven devrait afficher la version actuelle. Tu es maintenant prêt à utiliser l'outil de build maven
pom.xml
Le pom.xml est le fichier par défaut utilisé par maven pour décrire le projet. Le fichier pom.xml est basé sur XML. Un pom.xml plus ou moins minimal ressemble à ceci
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.wildcodeschool</groupId>
<artifactId>my-first-maven-project</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<!-- ... -->
</dependency>
</dependencies>
<build>
<plugins>
<!-- ... -->
</plugins>
</build>
</project>
Les premières lignes sont obligatoires pour décrire le projet. <properties>, <dependencies> et <build> sont optionnels et décrits en détail plus loin dans cette quête.
Tu devrais utiliser le domaine inversé de ton entreprise ou de ton organisation pour le <groupId>, afin d'éviter les conflits avec les programmes et bibliothèques Java d'autres entreprises ou organisations. Renseigne-toi auprès de ton organisation sur d'éventuelles exigences supplémentaires pour le <groupId>.
Tu peux choisir le nom que tu veux pour le <artifactId>. Cet id est l'identifiant unique de ton projet au sein de ton entreprise ou de ton organisation. Garde en tête que le <artifactId> doit commencer par une lettre et n'utiliser que des lettres ou des chiffres. Le tiret et le tiret bas peuvent aussi être utilisés.
La version par défaut dans maven est 1.0-SNAPSHOT, mais tu peux la changer comme tu veux. Un schéma populaire est le Semantic Versioning. Cela dépend tout de même de la politique de ton entreprise ou de ton organisation quant à la façon dont les numéros de version y sont créés.
Fichiers et dossiers
Alors que tu es libre d'organiser tes fichiers et dossiers avec Java, nous devons respecter une structure de fichiers et de dossiers précise quand nous utilisons Maven. Le dossier racine porte en général le même nom que le <artifactId>. Dans ce dossier, il y a un dossier src pour les sources et un dossier target pour les binaires (fichiers .class, applications, bibliothèques, ...) créés par maven.
+ my-first-maven-project
+ -- src
+ -- main
+ -- java
MyApplication.java
+ -- resources
MyApplication.txt
+ -- test
+ -- java
MyApplicationTest.java
+ -- resources
MyApplicationTest.txt
+ -- target
+ -- classes
MyApplication.class
my-first-maven-project.jar
pom.xml
Le dossier src contient les sources Java dans le dossier main/java et tous les autres fichiers de ressources dans le dossier resources. Ces autres ressources peuvent inclure des images utilisées pour des icônes, des fichiers texte, ou tout autre chose qui n'est pas une source Java nécessaire à la compilation du programme ou de la bibliothèque.
Le dossier test dans le dossier src est utilisé pour les tests. Les tests sont couverts dans une autre quête, donc nous n'entrerons pas dans les détails ici.
Le dossier target est utilisé par maven pour stocker les binaires créés quand ton projet est construit. Il contiendra les classes Java compilées (fichiers .class) et l'archive regroupant toutes les classes Java dans une archive Java (fichier .jar).
Tu peux changer les valeurs par défaut des fichiers et dossiers pour maven, mais ça rendrait ton projet bizarre. Ne le fais pas.
Properties
Dans le pom.xml, tu peux définir tes propres propriétés ou des propriétés utilisées pour le projet Java.
Encodage
Au fil des années, l'encodage des fichiers dans différents jeux de caractères a été à l'origine de plusieurs problèmes. Tout a changé une fois que les gens se sont mis d'accord pour utiliser l'encodage UTF-8 pour les fichiers sources.
Par défaut, Microsoft Windows utilise un jeu de caractères personnalisé qui n'est pas compatible par défaut avec d'autres systèmes d'exploitation comme Android, Linux ou Unix. Sans encodage de jeu de caractères, tes fichiers peuvent ne pas compiler comme prévu quand tu transfères un projet vers un autre système d'exploitation. ... challenge ...
Pour résoudre un éventuel problème d'encodage, pense à garder la propriété suivante dans ton fichier pom.xml maven pour indiquer que les fichiers sources sont encodés en UTF-8 :
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
Version de Java
eclipse nécessite une version récente de Java, mais ton projet peut utiliser une version de Java différente, plus ancienne ou plus récente. Pour indiquer explicitement que ton projet utilise la version 11 de Java, ton pom.xml devrait inclure les propriétés suivantes
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
L'outil de build maven utilisera le compilateur Java 11 et signalera une erreur si le compilateur Java disponible est trop ancien.
📥 Dependencies
Rassembler des bibliothèques est une tâche pénible que maven résout pour toi. Sans maven, les programmeurs devaient les trouver, les stocker en local, les organiser et les mettre à jour à la main. maven fournit tout via internet. À la place du serveur de dépôt (repository : dépôt où sont stockées les bibliothèques) maven, tu peux utiliser un serveur alternatif qui fournit des dépôts maven comme jcenter, ou même faire tourner ton propre serveur de dépôt maven.
Le partage de code est l'un des avantages qu'offre Internet. Imagine un monde où tu devrais fournir des bibliothèques en utilisant une sorte de disques, comme les développeurs devaient le faire à l'époque.
Les développeurs logiciels choisissent souvent de faire tourner leur propre serveur de dépôt maven pour s'isoler du dépôt maven et économiser de la bande passante. Ce serveur de dépôt maven local fonctionnerait aussi si la connexion internet tombait en panne.
Tu peux utiliser n'importe quel projet disponible sur le serveur de dépôt maven. Pour utiliser un projet, tu as besoin de
<groupId><artifactId><version>
Quand tu regardes l'exemple de pom.xml ci-dessus, tu reconnaîtras que ce sont exactement les mêmes valeurs que tu dois fournir pour ton propre projet. Si tu publiais ton projet sur le serveur de dépôt maven, tu pourrais réutiliser ton propre projet depuis le serveur de dépôt maven dans un autre projet.
Plugins
Maven fournit déjà tout ce dont tu as besoin pour construire un projet Java. Avec les plugins (plugin : module qui ajoute des fonctionnalités à un outil), tu peux enrichir davantage ton build. Il existe une grande quantité de plugins disponibles et les présenter tous prendrait tout simplement trop de temps. Quand tu seras plus à l'aise avec Java et Maven et que tu commenceras à utiliser plus de bibliothèques et de frameworks (framework : cadre de travail qui fournit une structure prête à l'emploi), tu ajouteras certainement un ou plusieurs plugins à ton fichier pom.xml.
Pour l'instant, nous allons présenter un seul plugin, le maven-jar-plugin. Installer un autre plugin suivrait les mêmes étapes. Tout d'abord, tous les plugins doivent être déclarés dans la section build/plugins du fichier pom.xml.
<build>
<plugins>
<!-- ... -->
</plugins>
</build>
Chaque plugin a sa propre section plugin. Les détails varient, mais certaines bases restent toujours les mêmes. Chaque plugin a un <groupId>, un <artifactId> et une <version> que tu spécifies dans la section <plugin>.
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>3.2.0</version>
<!-- ... -->
</plugin>
</plugins>
</build>
Le maven-jar-plugin est fourni par Maven. D'autres plugins sont fournis par différentes entreprises et organisations. Tu pourrais même écrire ton propre plugin, puisqu'un plugin n'est qu'un programme Java qui respecte certaines règles.
Pour le maven-jar-plugin, un cas d'usage simple serait de spécifier la classe principale (main class) à l'intérieur d'un fichier jar, celle qui doit être appelée quand java est lancé avec un fichier .jar. Un fichier .jar est une collection de classes et chacune de ces classes pourrait fournir la classe static void main(String[] args) requise. Le runtime Java (runtime : l'environnement qui exécute le programme) ne sait pas laquelle de ces méthodes est celle à exécuter.
Pour spécifier la main class, un fichier .jar inclut un fichier spécial : META-INF/MANIFEST.MF. C'est un fichier texte qui suit un certain schéma, chaque ligne ayant un mot-clé (key) suivi de deux-points et d'une valeur. Pour la main class, il y a une ligne qui dit
Main-class: com.wildcodeschool.java.Main
Où la valeur com.wildcodeschool.java.Main serait le nom canonique de la classe contenant la méthode public static void main(String[] args) à exécuter. Cette valeur sera différente pour chaque projet.
Tu dois utiliser le maven-jar-plugin (ou n'importe quel autre plugin qui fournit un service similaire) pour ajouter cette entrée au fichier manifest. Avec le maven-jar-plugin, tu devrais ajouter une section configuration dans le plugin.
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>3.2.0</version>
<configuration>
<archive>
<manifest>
<mainClass>com.wildcodeschool.java.Main</mainClass>
</manifest>
</archive>
</configuration>
</plugin>
</plugins>
</build>
Les plugins sont disponibles depuis le dépôt maven central ou n'importe quel autre serveur de dépôt que tu choisis. Quand tu regardes les entrées du plugin, tu y trouves le groupId, l'artifactId et la version, exactement comme ce que nous avons dû spécifier pour notre projet. Ces valeurs sont aussi appelées les coordonnées maven (maven coordinates).
🏗 build
Tu peux utiliser des plugins pour enrichir le processus de build avec des fonctionnalités supplémentaires.
- Renseigner des informations dans le MANIFEST.MF
- Créer un FAT jar
Construire un projet
Pour construire un projet, tu dois indiquer à maven quoi faire avec un ou plusieurs arguments supplémentaires qui disent à maven quoi faire.
mvn clean package
Ce sera probablement la ligne de commande maven que tu utiliseras le plus pour nettoyer les builds précédents et construire le projet ensuite.
clean
Avec l'argument clean, tu dis à maven de nettoyer les builds précédents. Cela supprimera les binaires existants du dossier target.
mvn clean
package
Avec l'argument package, tu dis à maven de construire le projet
mvn package
Utilise package pour créer les binaires de ton projet dans le dossier target.
install
L'argument install va construire le projet et installer l'artifact créé dans le cache du dépôt local (local repository cache).
mvn install
Le cache du dépôt local est un dossier spécial où les artifacts sont stockés.
Le cache du dépôt local
Quand ton projet dépend de bibliothèques tierces, maven peut résoudre ces dépendances et télécharger les binaires sur ton ordinateur.
Les fichiers téléchargés par maven sont stockés dans un répertoire local .m2 qui est en général caché.
Une façon rudimentaire de régler les problèmes avec maven est de supprimer le contenu du dossier .m2 local. Après ça, tous les binaires devront être retéléchargés
💪 Challenge
Crée un fichier pom.xml pour un nouveau projet Java et construis ton programme
Créer un programme Java exécutable
Ton pom.xml doit fonctionner et créer un fichier .jar avec un programme Java exécutable. Tu devras spécifier la main class dans le manifest du fichier jar et tu dois ajouter le maven-jar-plugin pour modifier et étendre le fichier manifest par défaut.
Le programme Java peut simplement afficher un message "Hello World" à l'écran, il doit juste être un programme Java exécutable.
Implementation
Ajoute des informations sur l'implementation (titre, version et éditeur) au fichier manifest du fichier .jar.
Auteur et horodatage
Ajoute des informations sur l'auteur et la date de création au fichier manifest du fichier .jar
🧐 Critères d'acceptation
-
Tu as créé un projet Java qui utilise l'outil de build maven
-
Le projet Java produit un programme Java exécutable avec
mvn clean package -
Tu as ajouté une dépendance à ton projet et tu vérifies ton cache du dépôt local pour y trouver les binaires téléchargés, lance
ls -l ...pour lister les fichiers téléchargés. -
Tu as ajouté un plugin au pom.xml pour enrichir le contenu du fichier MANIFEST.MF
-
Tout est dans un dépôt git et disponible sur GitHub
Introduction
maven is a tool to build java programs or libraries that favours convention over configuration.
The convention over configuration concept requires you to follow predefined rules for your project setup that will free you from providing numerous configuration options.
🤓 By the end of this quest, you will:
✅ Know what maven is and how it works ✅ Know how to install maven on your computer ✅ Know how to build Java programs and libraries with maven
History and alternatives
Maven is not the first build tool. Early versions of Java used foreign build tools like make, which is usually used with the C programming language.
Another build tool is ant, which was very popular and written in Java itself. The biggest problem with ant is, that everybody used it in a different way which made it hard to use programs from other companies or organizations or even reuse older projects with incompatible expectations. Files that describe a project for the ant build tool are basically XML files.
Some alternative languages for the JVM use their own build tool. For example, the Scala programming language uses the sbt build tool which uses Scala to describe the project. Therefore, you do not need to learn a new language to build programs with the sbt build tool.
Grade, another build tool, uses Groovy, which is yet another language for the JVM. Groovy is a flexible language that you can use to build your own DSL (domain specific language). Gradle, from a different perspective, is a DSL to build programs or languages based on Groovy. Again, you do not need to learn another language for the build tool.
Many other build tools are in use, but less popular.
Install maven
To install the latest (or any project specific) version of maven, you should download the binary distribution from the Apache Maven Website. Developers usually want the latest version or a version that is more recent than what is available from the operating systems package manager.
Choose the binary tar.gz archive from the Downloads section and extract the files with
tar xvzf apache-maven-3.6.3-bin.tar.gz
You can still move around the maven folder later. Add the bin/ folder from the extracted maven archive to your path to save from you always providing the full path to the maven binary.
apache-maven-3.6.3-bin.tar.gz is the current release of maven at the time of this writing. The version may have changed to a later revision. The best option for the download is usually the latest stable version.
To verify that your installation was successful, type
mvn --version
at the command line. Maven should print the current version. You are now ready to use the maven build tool
pom.xml
The pom.xml is the default file used by maven to specify the project. The pom.xml file is based on XML. A more or less minimal pom.xml is
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.wildcodeschool</groupId>
<artifactId>my-first-maven-project</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<!-- ... -->
</dependency>
</dependencies>
<build>
<plugins>
<!-- ... -->
</plugins>
</build>
</project>
The first lines are required to describe the project. <properties>, <dependencies> and <build> are optional and described in detail later in this Quest.
You should use the inverted domain of your company or organization for the <groupId> to avoid conflicts with other companies or organizations Java programs and libraries. Check with your organization about any additional requirements for the <groupId>.
You may choose any name you like for the <artifactId>. This id is the unique identifier for your project within your company or organization. Keep in mind that the <artifactId> should start with a letter and uses letters or digits. The dash and underscore characters can also be used.
The default version in maven is 1.0-SNAPSHOT, but you can change this as you like. A popular schema is the Semantic Versioning scheme. It depends on your company or organization 's policy though how version numbers are created in your company or organization.
Files and folders
While you are free to organize your files and folders with Java, we have to adhere to a specified structure of files and folders when we use Maven. The root folder usually has the same name as the <artifactId>. Within that folder, there is a src folder for the sources and a target folder for the binaries (.class files, applications, libraries, ...) created by maven.
+ my-first-maven-project
+ -- src
+ -- main
+ -- java
MyApplication.java
+ -- resources
MyApplication.txt
+ -- test
+ -- java
MyApplicationTest.java
+ -- resources
MyApplicationTest.txt
+ -- target
+ -- classes
MyApplication.class
my-first-maven-project.jar
pom.xml
The src folder contains Java sources in the main/java folder and any other resource files in the resources folder. Other resources could include images used for icons or text files or anything else that is not a Java source required to compile the program or library.
The test folder in the src folder is used for tests. Testing is covered in a different Quest so we will not go into details here.
The target folder is used by maven to store the binaries created when your project is build. It will contain the compiled Java classes (.class files) and the archive with all combined Java classes in a Java archive (.jar file).
You can change the defaults for files and folders for maven but that would make your project look odd. Don't do it.
Properties
Within the pom.xml, you can specify properties of your own or properties that are used for the Java project.
Encoding
Over years, encoding of files in various character sets have been a root cause of several problems. Everything changed once people agreed to use UTF-8 encoding for source files.
By default, Microsoft Windows uses a custom character set that is not compatible with other operating systems like Android, Linux or Unix by default. Without a character set encoding, your files may not compile as expected when you transfer a project to a different operating system. ... challenge ...
To solve a potential encoding issue, remember to keep the following property in your maven pom.xml file to specify that source files are encoded in UTF-8:
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
Java version
eclipse requires a recent Java version, but your project may use a different Java version that is either older or newer. To explicitly state that your project uses Java version 11, your pom.xml should include the following properties
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
The maven build tool with use the Java 11 compiler and report an error in the case that the available Java compiler is too old.
📥 Dependencies
Collecting libraries is a painful task that maven solves for you. Without maven, programmers had to find them, store them locally, organize and update them manually. maven provides everything over the internet. Instead of the maven repository server, you can use alternative server that provides maven repositories like jcenter or even run your own maven repository server.
Sharing code is one of the advantages that the Internet provides. Imagine a world where you would have to provide libraries using some kind of disks as developers had to in the old days.
Software developers often choose to run their own maven repository server to isolate themself from the maven repository and save some bandwith. This local maven repository server would also work in case the internet connection breaks down.
You can use any project available on the maven repository server. To use a project you need
<groupId><artifactId><version>
When you look at the pom.xml example from above, you will recognize that these are the exact same values you have to provide for your own project. If you would update your project to the maven repository server, you could reuse your own project from the maven repository server in another project.
Plugins
Maven already provides everything you need to build a Java project. With plugins, you can further enhance your build. There is a large amount of plugins available and introducing every single one of them would just take too much time. When you are more familiar with Java and Maven and you start to use more libraries and frameworks, you will certainly add one or more plugins to your pom.xml file.
For now, we will introduce a single plugin, the maven-jar-plugin. Installing another plugin would follow the same steps. First of all, all plugins have to be delared in the build/plugins section of the pom.xml file.
<build>
<plugins>
<!-- ... -->
</plugins>
</build>
Every plugin has it's own plugin section. The details will vary, but some basics will always be the same. Every plugin has a <groupId>, <artifactId> and a <version>that you specify in the <plugin> section.
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>3.2.0</version>
<!-- ... -->
</plugin>
</plugins>
</build>
The maven-jar-plugin is provided by Maven. Other plugins are provided by different companies and organizations. You could even write your own plugin since a plugin is just a Java program that adheres to some rules.
For the maven-jar-plugin, a simple use case would be to specify the main class within a jar file to be called when java is started with a .jar file. A .jar file is a collection of classes and every one of that class could provide the required static void main(String[] args) class. The Java runtime does not know which of these methods is the one to execute.
To specify the main class, a .jar file includes a special file: META-INF/MANIFEST.MF. This is a text file that follows a certain pattern with every line having a key(word) followd by a colon and a value. For the main class, there is one line that reads
Main-class: com.wildcodeschool.java.Main
Where the value com.wildcodeschool.java.Main would be the canonical name of the class with the public static void main(String[] args) method to execute. This value will be different for every project.
You have to use the maven-jar-plugin (or any other plugin that provides a similar service) to add this entry to the manifest file. With the maven-jar-plugin you would have to add a configuration section in the plugin.
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>3.2.0</version>
<configuration>
<archive>
<manifest>
<mainClass>com.wildcodeschool.java.Main</mainClass>
</manifest>
</archive>
</configuration>
</plugin>
</plugins>
</build>
Plugins are available from the central maven repository or any other repository server you choose. When you look at the entries for the plugin, you will find the groupId, artifactId and version - just as we had to specify for our project. These values are also called the maven coordinates.
🏗 build
You can use plugins to enhance the build process with additional functionality.
- Setting information in the MANIFEST.MF
- Create a FAT jar
Building a project
To build a project, you have to tell maven what to do with one or more additional arguments that tell maven what to do.
mvn clean package
This will probably be the most used maven command line you use to cleanup from previous builds and build the project after that.
clean
With the clean argument, you tell maven to cleanup from previous builds. This will remove existing binaries from the target folder.
mvn clean
package
With the package argument, you tell maven to build the project
mvn package
Use package to create the binaries for your project in the target folder.
install
The install argument will build the project and install the created artifact into the local repository cache.
mvn install
The local repository cache is a special folder when artifacts are stored.
The local repository cache
When your project depends on libaries from a 3rd party, maven can resolve these dependencies and download the binaries to your computer.
The files downloaded by maven are stored in a local directory .m2 that is usually hidden.
A poor man's way to cleanup issues with maven is to remove the content from the local .m2 folder. After that, all binaries have to be downloaded again
💪 Challenge
Create a pom.xml file for a new Java project and build your program
Create a runnable Java program
Your pom.xml should work and create a .jar file with an executable Java program. You will have to specify the main class in the manifest of the jar file and you need to add the maven-jar-plugin to modify and extend the default manifest file.
The Java program can simply print a "Hello World" message to the screen - it just has to be a runnable Java program.
Implementation
Add information about the implementation (title, version and vendor) to the manifest file of the .jar file.
Author and Timestamp
Add information about the author and date of creation to the manifest file of the .jar file
🧐 Acceptance criteria
-
You created a Java project that uses the maven build tool
-
The Java project produces a runnable Java program with
mvn clean package -
You added a dependency to your project and check your local repository cache for the downloaded binaries - run
ls -l ...to list the downloaded files. -
You added a plugin to the pom.xml to enhance the content of the MANIFEST.MF file
-
Everything is in a git repository and available on GitHub
Ressources partagées sur cette quête
- M'a guidé pour créer mon premier projet Maven. Ensuite, j'ai pu travailler sur le fichier pom.xml !https://maven.apache.org/guides/getting-started/maven-in-five-minutes.html
- Quelques éléments utiles pour ajouter du contenu au MANIFEST.MF (comme demandé dans le challenge)https://maven.apache.org/shared/maven-archiver/index.html
- Pour afficher le dossier "Referenced Libraries" qui permet d'avoir le contenu du jar et donc votre MANIFEST.MFhttps://stackoverflow.com/questions/3167353/how-to-add-a-reference-in-eclipse