Utilisez Maven pour gérer vos dépendances Java

En tant que passionné de l’open source, j’ai utilisé des dizaines (des centaines ?) de bibliothèques qui dépassent largement mes compétences ou mes intérêts en tant que programmeur. Pour beaucoup de gens, moi y compris, les bibliothèques disponibles sont l’une des choses qui font qu’un langage de programmation particulier vaut la peine d’être utilisé.

Une bibliothèque open source représente des heures et des jours où vous n’avez pas à travailler sur un problème qui n’est pas au cœur de votre projet ou, à l’inverse, alors central que votre projet serait autrement hors de portée. Mieux encore, c’est du code que vous n’avez pas à maintenir, à moins qu’il ne soit si important pour vous que vous décidiez d’y contribuer.

Étant donné que les bibliothèques open source sont un élément essentiel de la programmation open source, la plupart des langages de programmation disposent d’un moyen pratique de s’assurer qu’elles sont faciles à inclure dans votre base de code.

Il existe plusieurs façons de gérer les bibliothèques en Java, mais celle que j’utilise est Maven.

Maven est un cadre de gestion de code qui vous aide à suivre les dépendances, à créer des cibles, à créer des rapports et à documenter, le tout à partir d’un emplacement central. Cet emplacement central est un fichier POM (Project Object Model), qui est écrit en XML pour décrire les exigences et les attentes de votre projet.

Lorsque vous décidez de mettre à jour une bibliothèque, vous pouvez mettre à jour uniquement votre pom.xml fichier.

Si vous ajoutez une version de débogage à votre projet, ajoutez-la en tant que cible dans pom.xml.

Lorsque vous mettez à niveau vers une nouvelle machine virtuelle Java (JVM), faites-le dans pom.xml.

Si cela semble facile, vous serez heureux de savoir qu’il est tout aussi facile de commencer.

Installer Maven

Maven est disponible sur la plupart des distributions Linux depuis votre gestionnaire de packages.

Sur Fedora, Mageia et distributions similaires :

$ sudo dnf install maven

Sur Elementary, Mint et d’autres distributions basées sur Debian :

$ sudo apt install maven

Sur macOS, utilisez MacPorts ou Homebrew.

Sous Windows, utilisez Chocolatey.

Configuration

Sur la plupart des systèmes, Maven est déjà configuré après l’installation.

Toutefois, si vous avez une configuration Java complexe, avec différentes versions installées pour différents projets, vous devrez peut-être définir votre JAVA_HOME variables d’environnement.

Si vous ne savez pas ce que c’est, lisez mon article sur la recherche et la configuration de votre JAVA_HOME.

Tout d’abord, vérifiez que Maven est installé et utilise la version de Java souhaitée :

$ mvn -version
Apache Maven x.y.z
Maven home: /usr/share/maven
Java version: X.Y.Z, vendor: Red Hat, Inc.,
runtime: /usr/lib/jvm/java-XX-openjdk-XX

Votre premier fichier POM

Maven base tout ce qu’il fait sur le fichier POM d’un projet. Vous pouvez penser à pom.xml comme l’équivalent Maven du fichier Makefile d’Autotool ou du fichier CMakeLists.txt de CMake. Vous mettez des instructions significatives pour Maven dans pom.xmlet il exécute ces instructions lorsque vous y êtes invité.

Un bon IDE, comme Eclipse ou NetBeans, pourrait fournir un passe-partout pom.xml lors de la création d’un projet Maven.

En fonction de votre maîtrise du XML, ce processus peut sembler plus complexe qu’il ne l’est en réalité. Il y a un net avantage à utiliser XML ici, alors jetez-y un coup d’œil même si vous n’êtes pas familier avec le langage.

<?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.example</groupId>
    <artifactId>example4Maven</artifactId>
    <version>1.0</version>
    <packaging>jar</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
</project>

Les premiers éléments (<?xml?> et <project>) contiennent des informations sur le fichier lui-même, identifiant le document comme XML écrit conformément au schéma Maven POM. Le groupe d’éléments suivant correspond au schéma Maven utilisé et aux paramètres du projet que j’ai fournis à NetBeans.

le <packaging> L’élément spécifie que ce projet est destiné à être empaqueté en tant que fichier JAR.

le <properties> element informe Maven du code source (encore inexistant) de mon projet. Il est écrit en encodage UTF-8 pour OpenJDK version 11.

Tout cela a été généré automatiquement par NetBeans pour moi lorsque j’ai créé un exemple de projet.

Si vous n’utilisez pas d’IDE qui s’intègre à Maven, ou si vous préférez simplement écrire le vôtre à partir de zéro, vous pouvez trouver le squelette d’un fichier POM sur maven.apache.org/pom.html#Quick_Overview. Il est clairement commenté et les déclarations XML sont déjà remplies.

Ajouter une dépendance à votre POM

Il y a longtemps, lorsque vous écriviez une application Java et décidiez d’utiliser une bibliothèque externe, vous pouviez télécharger un fichier JAR de la bibliothèque, l’enregistrer dans votre base de code, puis utiliser un import pour le référencer dans votre code Java. C’était un système manuel, et même s’il fonctionnait aussi bien qu’en utilisant, disons, une bibliothèque C ou C++, cela pouvait représenter beaucoup de travail à entretenir.

Maven utilise des référentiels, tout comme Linux utilise des référentiels pour l’installation de logiciels, et Python utilise pip. Le référentiel par défaut est celui de Sonatype Dépôt centralà partir duquel vous pouvez effectuer une recherche search.maven.org. À partir de Central, vous pouvez trouver des bibliothèques et les métadonnées appropriées dont vous avez besoin pour remplir les champs de dépendance requis pour Maven. En pratique, cependant, la plupart des bibliothèques Java fournissent ces informations dans leurs fichiers README ou leur documentation.

Supposons que vous ayez un script Java simple qui répertorie les fichiers dans un répertoire, mais que vous décidiez de ne répertorier que les fichiers se terminant par jpg ou png. L’apache fileUtils La bibliothèque propose un filtre de nom de fichier pour ce type d’opération, mais il n’est pas inclus dans la distribution Java.

package com.example.example4maven;
import java.io.File;
import java.util.Iterator;
import java.util.List;
// external libs
import org.apache.commons.io.FileUtils;
public class Main {
    private static final File myDir = new File("/home/tux/img");
    private static final String[] ext = new String[] { "jpg","png" };
    public static void main(String[] args) {
        List<File> images = (List<File>) FileUtils.listFiles(myDir, ext, false);
        for (Iterator<File> i = images.iterator(); i.hasNext();) {
            System.out.println(i.next().getName());
            }
    }
}

Vous pouvez rechercher Central pour la bibliothèque, ou vous pouvez visiter le projet site Internet et obtenir les informations de dépendance là-bas.

Les informations de dépendance ressemblent à ceci :

<dependency>
  <groupId>commons-io</groupId>
  <artifactId>commons-io</artifactId>
  <version>2.11.0</version>
</dependency>

Entrez cela entre <dependencies> et </dependencies> balises dans votre pom.xml fichier, et vous avez ajouté le fichier Apache commons.io bibliothèque à votre projet.

<?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.example</groupId>
    <artifactId>example4Maven</artifactId>
    <version>1.0</version>
    <packaging>jar</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.11.0</version>
            <type>jar</type>
        </dependency>
    </dependencies>
</project>

Désormais, lorsque vous créez votre projet, Maven peut télécharger automatiquement toutes les bibliothèques que vous n’avez pas dans votre base de code locale.

Créer un JAR avec Maven

Vous pouvez créer des fichiers JAR avec des outils comme fastjar ou gjar, mais Maven a des plugins qui lui permettent d’effectuer des tâches de construction courantes, y compris l’empaquetage. Pour un package JAR standard, qui contient votre code source, vous pouvez utiliser maven-jar-plugin.

Pour que Maven crée un “Uber JAR” pour vous, qui contient votre code ainsi que toutes les bibliothèques dépendantes dont votre code a besoin, vous pouvez utiliser maven-assembly-plugin. Les deux plugins sont similaires en termes d’objectif et de configuration, et ce sont tous les deux des plugins de construction, ils sont donc entrés dans un <build> rubrique de votre pom.xml.

Comme pour les bibliothèques, les métadonnées Maven pour les plugins sont disponibles sur la page d’accueil du plugin. Vous incluez maven-assembly-plugin en répertoriant ses groupId, artifactIdet version compris entre <plugin> Mots clés.

Il existe des options de configuration supplémentaires, notamment :

• un ensemble de comportements prédéfinis
• la possibilité de changer le nom de la sortie en fonction du nom du projet plutôt que du nom de code de votre projet
• la possibilité d’ajouter vos propres entrées dans MANIFEST.MF.

Ceci est utile lorsque votre classe principale n’est pas appelée Main.class.

Pour indiquer au plugin quand il doit être invoqué, vous devez également définir quel mot-clé dans votre build Maven le déclenche.

Pour maven-assembly-pluginvous voulez probablement qu’il s’active lorsque vous utilisez mvn package.

    <build>
   <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-assembly-plugin</artifactId>
           <version>3.3.0</version>
           <configuration>
             <descriptorRefs>
                   <descriptorRef>jar-with-dependencies</descriptorRef>
             </descriptorRefs>
             <finalName>Lister-${project.version}</finalName>
             <appendAssemblyId>false</appendAssemblyId>
               <archive>
                   <manifestFile>src/main/resources/META-INF/MANIFEST.MF \ 
</manifestFile>
               </archive>
           </configuration>
           <executions>
               <execution>
                   <id>make-assembly</id>
                   <phase>package</phase>
                   <goals>
                       <goal>single</goal>
                   </goals>
               </execution>
           </executions>
   </plugin>
   </plugins>
</build>

Testez votre version :

$ mvn clean package

Une fois votre projet construit, vous pouvez trouver votre Uber JAR dans le fichier généré automatiquement. targets annuaire:

$ java -jar targets/Lister-1.0.jar
foo.png
foo.jpg
bar.jpg
bar.png

Cela fonctionne comme prévu.

Construire avec Maven

Maven rend la gestion de votre projet Java simple et résiliente. Avec Maven, les contributeurs peuvent démarrer leur environnement rapidement, obtenir toutes les bibliothèques dont ils ont besoin et créer des versions prévisibles pour leurs utilisateurs. Sa configuration XML garde une syntaxe simple et lisible, et facilite l’ajout de nouvelles options.

Essayez Maven avec votre prochain projet Java et voyez ce que vous en pensez.