2. Installation de l'environnement de travail

L'environnement de travail du développeur Java comprend trois éléments indépendants :

• le JDK (« Java Development Kit ») : le compilateur [javac], la machine virtuelle et la commande [java] qui exécute les programmes, les bibliothèques standard de Java SE, et des outils comme [jshell] ou [jar] ;
• un outil de construction des projets, ici Maven : il télécharge les bibliothèques dont un projet a besoin, le compile, exécute ses tests et le met en paquet ;
• un éditeur ou un IDE (environnement de développement intégré) : [IntelliJ IDEA], [VS Code] avec les extensions Java, ou [Eclipse]. L'IDE s'appuie sur le JDK et sait lire les projets Maven.

Ce document utilise les commandes [java], [javac] et [mvn] pour toutes les opérations : elles fonctionnent de la même façon sous Windows, Linux et macOS, et quel que soit l'éditeur choisi.

2.1. Le JDK 25

2.1.1. Installation

Il existe plusieurs distributions du JDK, toutes construites à partir du code d'OpenJDK et équivalentes pour notre usage. Nous conseillons Eclipse Temurin, distribution libre et gratuite de la fondation Eclipse, qui se télécharge à l'adresse https://adoptium.net : on y choisit la version 25 - LTS, le système d'exploitation et le type de paquet (sous Windows, un installateur [.msi]). Sous Windows, on peut aussi l'installer depuis un terminal (PowerShell ou invite de commandes) avec le gestionnaire de paquets [winget] :

winget install EclipseAdoptium.Temurin.25.JDK

Il faut choisir le JDK (qui contient tout) et non le JRE seul (qui ne permet que d'exécuter des programmes déjà compilés). Lors de l'installation sous Windows, on coche les options qui ajoutent le JDK au [PATH] et qui définissent la variable d'environnement [JAVA_HOME] : Maven et les IDE s'en servent pour trouver le JDK. Sous Linux, le JDK est disponible dans les dépôts des principales distributions (par exemple [sudo apt install openjdk-25-jdk] sous Ubuntu).

Après l'installation, on vérifie dans un nouveau terminal que les commandes [java] et [javac] sont disponibles et donnent la version du JDK :

> java --version
openjdk 25.0.4.1 2026-08-18
OpenJDK Runtime Environment (build 25.0.4.1+1-1-24.04.4-Ubuntu)
OpenJDK 64-Bit Server VM (build 25.0.4.1+1-1-24.04.4-Ubuntu, mixed mode, sharing)
> javac --version
javac 25.0.4.1

Ces résultats ont été obtenus avec le JDK d'Ubuntu. Avec Temurin, les lignes 2 et 3 mentionnent [Temurin-25], et la version exacte dépend de la date de l'installation : les mises à jour correctives paraissent chaque trimestre. Tous les JDK 25.0.x conviennent pour ce document. Plusieurs JDK peuvent cohabiter sur un même poste : c'est le premier trouvé dans le [PATH] qui répond à la commande [java].

2.1.2. Les commandes du JDK

Le JDK fournit de nombreuses commandes. Voici celles que nous utiliserons :

Commande	Rôle
[java Fichier.java]	compile en mémoire et exécute un programme écrit dans un fichier source (Java 11 ; plusieurs fichiers depuis Java 22)
[javac -d classes Fichier.java]	compile un ou plusieurs fichiers source et range les fichiers [.class] produits dans le dossier [classes]
[java -cp classes Classe]	exécute la méthode [main] d'une classe compilée, cherchée dans le chemin de classes ([-cp], « class path »)
[java -cp "lib/*" Fichier.java]	exécute un fichier source qui utilise les bibliothèques (fichiers [.jar]) du dossier [lib]
[jshell]	interpréteur interactif : on tape des instructions Java et on voit aussitôt leur résultat
[jar]	crée ou lit une archive [.jar] (un fichier zip de classes compilées)

L'interpréteur [jshell] (Java 9) est pratique pour essayer une méthode ou une expression sans écrire de programme :

> jshell
|  Welcome to JShell -- Version 25.0.4.1
|  For an introduction type: /help intro

jshell> 1 + 2
$1 ==> 3

jshell> var s = "Java " + 25
s ==> "Java 25"

jshell> s.length()
$3 ==> 7

jshell> /exit
|  Goodbye

2.2. Maven

2.2.1. Installation

Une application Java réelle utilise des bibliothèques qui ne font pas partie du JDK : un pilote de base de données, un cadriciel de tests, Hibernate, Spring… Elles sont distribuées sous forme d'archives [.jar] par un dépôt public, Maven Central (https://central.sonatype.com). Un outil de construction comme Maven lit dans le fichier [pom.xml] d'un projet les bibliothèques dont il a besoin, les télécharge (avec les bibliothèques dont elles dépendent elles-mêmes), puis compile, teste et met en paquet le projet. L'autre outil très utilisé, Gradle, joue le même rôle ; ce document utilise Maven.

Maven se télécharge à l'adresse https://maven.apache.org/download.cgi sous la forme d'une archive zip ([apache-maven-3.9.x-bin.zip]). On la décompresse dans un dossier, par exemple [C:\Program Files\apache-maven-3.9.11], et on ajoute son sous-dossier [bin] au [PATH] (Windows : « Modifier les variables d'environnement système »). Sous Linux, Maven est dans les dépôts des distributions ([sudo apt install maven]). On vérifie l'installation dans un nouveau terminal :

> mvn -v
Apache Maven 3.9.11 (3e54c93a704957b63ee3494413a2b544fd3d825b)
Maven home: /opt/maven
Java version: 25.0.4.1, vendor: Ubuntu, runtime: /usr/lib/jvm/java-25-openjdk-amd64
Default locale: en_US, platform encoding: UTF-8
OS name: "linux", version: "6.18.44-fc-v64", arch: "amd64", family: "unix"

La ligne 4 est importante : elle donne le JDK utilisé par Maven, celui que désigne la variable [JAVA_HOME]. Ce doit être un JDK 25. Les IDE IntelliJ IDEA et VS Code embarquent leur propre Maven : on peut s'en contenter si l'on n'utilise pas Maven en ligne de commande.

Les bibliothèques téléchargées par Maven sont conservées sur le poste, dans le dépôt local [%USERPROFILE%\.m2\repository] (Linux, macOS : [~/.m2/repository]). Elles ne sont téléchargées qu'une fois et servent ensuite à tous les projets. Il faut donc un accès à Internet lors de la première construction d'un projet.

2.2.2. Les commandes Maven

La commande [mvn] est suivie d'une ou plusieurs phases du cycle de construction, ou d'un but d'un greffon (« plugin ») ; on la tape dans le dossier qui contient le fichier [pom.xml] :

Commande	Rôle
[mvn compile]	compile les sources de [src/main/java] ; les classes sont rangées dans [target/classes]
[mvn test]	compile, puis exécute les tests unitaires de [src/test/java] (chapitre 6)
[mvn package]	compile, teste et crée l'archive [.jar] du projet dans [target]
[mvn install]	comme [package], puis copie l'archive dans le dépôt local, où d'autres projets peuvent l'utiliser (chapitre 6)
[mvn clean]	supprime le dossier [target]
[mvn compile exec:java]	compile, puis exécute la classe principale du projet (greffon [exec-maven-plugin])
[mvn spring-boot:run]	exécute une application Spring Boot (chapitre 13)

Les phases s'enchaînent : demander [package], c'est demander aussi [compile] et [test]. L'option [-q] (« quiet ») supprime les messages de Maven et ne laisse que ceux du programme exécuté ; l'option [-Dexec.args="a b"] passe des arguments au programme lancé par [exec:java].

2.3. L'éditeur

2.3.1. IntelliJ IDEA

IntelliJ IDEA, de la société JetBrains, est l'IDE Java le plus utilisé. Ses fonctions de base, qui suffisent largement pour ce document, sont gratuites. Il reconnaît les projets Maven : « File / Open », puis on choisit le dossier qui contient le fichier [pom.xml] ; IntelliJ télécharge les bibliothèques, compile le projet et permet d'exécuter une classe par le triangle vert placé dans la marge à côté de sa méthode [main] ([Ctrl-Maj-F10]), ou un test par le même triangle à côté de la méthode de test. On indique le JDK à utiliser dans « File / Project Structure / SDK ».

On peut ouvrir d'un coup tout le dossier [java-oct-2026] des exemples (« File / Open ») : IntelliJ y découvre tous les projets Maven et les affiche dans son panneau « Maven ». Une précaution s'impose alors. Les projets des chapitres 10 à 13 (versions 6 à 9 de l'application [Impots]) utilisent les modules [impots-dao], [impots-metier] et [impots-ui] de la version 5, écrite au chapitre 6. Ce ne sont pas des bibliothèques publiques : Maven ne les trouve dans le dépôt local que si on les y a installés. Il faut donc commencer par installer la version 5 : dans le panneau « Maven », déplier [impots-v5] / « Lifecycle » et double-cliquer sur [install] (ou taper [mvn install] dans le dossier [06-architectures/ImpotsV5]), puis cliquer sur le bouton « Sync All Maven Projects » du panneau. Le chapitre 6 explique ce que fait cette commande, et ce qu'il faut faire si IntelliJ signale malgré tout des dépendances non résolues.

2.3.2. VS Code

VS Code est un éditeur gratuit et multiplateforme. Pour programmer en Java, on lui ajoute l'extension Extension Pack for Java de Microsoft (menu « Extensions », rechercher « Extension Pack for Java »), qui regroupe la prise en charge du langage, le débogueur, l'exécution des tests et la prise en charge de Maven. On obtient :

• la coloration syntaxique, la complétion du code et l'aide en survol ;
• la détection des erreurs pendant la frappe ;
• la navigation dans le code (F12 : atteindre la définition) ;
• l'exécution et le débogage (liens « Run » et « Debug » au-dessus de chaque méthode [main], ou F5) ;
• l'exécution des tests unitaires (vue « Testing ») et une vue « Maven » des projets.

On ouvre dans VS Code le dossier contenant les programmes (« File / Open Folder »), par exemple le dossier [java-oct-2026] des exemples du document. Le terminal intégré (« Terminal / New Terminal ») permet de taper les commandes [java] et [mvn] sans quitter l'éditeur.

2.3.3. Eclipse

Un troisième choix est l'IDE libre Eclipse (https://eclipseide.org), historiquement le premier grand IDE Java, qui importe lui aussi les projets Maven (« File / Import / Maven / Existing Maven Projects »).

Dans la suite du document, les opérations sont décrites avec les commandes [java], [javac] et [mvn], qui donnent les mêmes résultats quel que soit l'éditeur.

2.4. Un premier programme : un fichier source compact

2.4.1. Le programme

Depuis Java 25, un programme Java peut être un simple fichier contenant une méthode [main], sans déclaration de classe. On l'appelle un fichier source compact (« compact source file »). Créons le fichier [Hello.java] suivant :

// premier programme Java : un fichier source compact
void main() {
    IO.println("1er essai avec Java 25");
}

et exécutons-le :

> java Hello.java
1er essai avec Java 25

Commentaires :

• ligne 1 : un commentaire. Tout ce qui suit [//] jusqu'à la fin de la ligne est ignoré par le compilateur ;
• ligne 2 : la méthode [main], point d'entrée du programme. Dans un fichier source compact, elle n'a pas besoin d'être déclarée dans une classe, ni d'être [public] et [static], ni de recevoir les arguments du programme ; nous verrons au chapitre 3 que le compilateur l'enveloppe lui-même dans une classe ;
• ligne 3 : la seule instruction du programme : elle écrit une ligne de texte à l'écran. La classe [IO] (Java 25) offre des méthodes simples d'écriture ([print], [println]) et de lecture ([readln]) au clavier ;
• la commande [java Hello.java] compile le programme en mémoire, sans créer de fichier [.class], puis l'exécute. Cette possibilité de lancer directement un fichier source date de Java 11.

Le nom du fichier doit être un identifiant Java valide : [Hello.java] ou [Bases01.java] conviennent, mais [bases-01.java] est refusé par le compilateur ([bad file name]) car le nom du fichier devient le nom de la classe générée. Par convention, les noms de classes, donc de fichiers, commencent par une majuscule.

On peut aussi compiler le programme avec [javac], qui produit un fichier [.class], puis exécuter ce fichier compilé :

> javac -d classes Hello.java
> dir classes (liste des fichiers)
Hello.class
> java -cp classes Hello
1er essai avec Java 25

Le fichier [Hello.class] contient le bytecode de la classe [Hello] générée par le compilateur. La commande [java -cp classes Hello] demande à la machine virtuelle d'exécuter la méthode [main] de la classe [Hello], cherchée dans le dossier [classes].

Les fichiers source compacts conviennent aux petits programmes, et nous les utiliserons pour la plupart des exemples. Quand un programme a besoin d'une bibliothèque extérieure, on peut encore le lancer par la commande [java -cp "lib/*" Programme.java] si l'on a copié les archives [.jar] de la bibliothèque (et de celles dont elle dépend) dans un dossier [lib]. Mais rassembler ces archives à la main devient vite fastidieux : on écrit alors un projet Maven.

Sous Windows, les caractères accentués écrits par [IO.println] ou [System.out.println] s'affichent correctement dans le terminal : Java convertit le texte dans l'encodage du terminal. Les fichiers source doivent être enregistrés en UTF-8, l'encodage par défaut de VS Code et d'IntelliJ IDEA, et celui que le compilateur suppose depuis Java 18.

2.5. Un projet Maven

2.5.1. Structure du projet

Un projet Maven est un dossier contenant un fichier [pom.xml] (« Project Object Model ») et des fichiers source rangés selon une arborescence standard. Le projet [PremierProgramme] du dossier [02-installation] est le suivant :

PremierProgramme/
├── pom.xml
└── src/
    └── main/
        └── java/
            └── premier/
                └── Main.java

• [src/main/java] contient les fichiers source du programme ; [src/main/resources] contiendrait les fichiers de données ou de configuration à placer à côté des classes compilées ; [src/test/java] contiendrait les tests (chapitre 6) ;
• sous [src/main/java], l'arborescence des dossiers suit celle des paquetages (chapitre 4) : la classe [premier.Main] est dans le dossier [premier].

On peut créer cette arborescence à la main, ou laisser l'IDE la créer (IntelliJ : « File / New / Project », choisir « Maven » comme système de construction). Le fichier [pom.xml] est le suivant :

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- les coordonnées du projet -->
    <groupId>exemples.installation</groupId>
    <artifactId>premier-programme</artifactId>
    <version>1.0</version>

    <properties>
        <!-- version de Java visée et encodage des fichiers source -->
        <maven.compiler.release>25</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <build>
        <plugins>
            <!-- le compilateur, avec tous les avertissements -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.15.0</version>
                <configuration>
                    <compilerArgs>
                        <arg>-Xlint:all</arg>
                    </compilerArgs>
                </configuration>
            </plugin>
            <!-- mvn exec:java exécute la classe principale -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <mainClass>premier.Main</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

• lignes 8-10 : les coordonnées du projet, qui l'identifient de façon unique : le groupe ([groupId], souvent un nom de domaine inversé comme [org.hibernate]), le nom du projet ([artifactId]) et sa version. Ce sont aussi les coordonnées par lesquelles un autre projet désignera celui-ci s'il en a besoin, comme on désigne une bibliothèque de Maven Central (chapitre 6) ;
• ligne 14 : le code est compilé pour Java 25 ;
• ligne 15 : les fichiers source sont codés en UTF-8 ;
• lignes 21-30 : le greffon de compilation, avec l'option [-Xlint:all] qui active tous les avertissements du compilateur ;
• lignes 32-39 : le greffon [exec-maven-plugin], qui permet d'exécuter la classe principale du projet, désignée ligne 37, par la commande [mvn exec:java].

Ce projet n'utilise aucune bibliothèque. Un projet qui en utilise une la déclare dans une section [<dependencies>] par ses coordonnées, comme nous le ferons à partir du chapitre 5 :

<dependencies>
    <dependency>
        <groupId>tools.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>3.1.5</version>
    </dependency>
</dependencies>

Le fichier [Main.java] contient le programme sous sa forme classique, avec une classe [public] et une méthode [public static void main(String[] args)] :

package premier;

// le programme principal du projet [PremierProgramme]
public class Main {

    public static void main(String[] args) {
        System.out.println("1er essai avec un projet Maven / Java 25");
    }
}

• ligne 1 : la classe appartient au paquetage [premier] : son nom complet est [premier.Main] ;
• lignes 4-9 : la classe [Main]. Un fichier source contient au plus une classe publique, qui porte le nom du fichier ;
• lignes 6-8 : la méthode [main], sous la forme qu'elle a depuis la première version de Java. Nous comparerons les deux formes au chapitre 3.

2.5.2. Compilation et exécution

La commande [mvn compile], tapée dans le dossier du projet, compile le projet : Maven télécharge si nécessaire les greffons dont il a besoin, puis compile les fichiers de [src/main/java] et range les classes produites dans le dossier [target/classes], en respectant l'arborescence des paquetages ([target/classes/premier/Main.class]). La commande [mvn compile exec:java] compile le projet puis l'exécute ; avec l'option [-q], on ne voit plus que l'affichage du programme :

> mvn -q compile exec:java
1er essai avec un projet Maven / Java 25

Une fois le projet compilé, on peut aussi exécuter la classe directement avec la commande [java], en lui indiquant où se trouvent les classes :

> java -cp target/classes premier.Main
1er essai avec un projet Maven / Java 25

Le dossier [target] peut être supprimé sans risque ([mvn clean]) : il est recréé par la compilation suivante. La commande [mvn package] produit en plus l'archive [target/premier-programme-1.0.jar], que l'on peut exécuter par [java -cp target/premier-programme-1.0.jar premier.Main] : c'est sous cette forme qu'un programme Java est livré.

2.6. Un projet de plusieurs modules

2.6.1. Le projet agrégateur

Un projet Maven peut en regrouper plusieurs autres, appelés ses modules. Le dossier [02-installation] contient un fichier [pom.xml] qui regroupe ses deux projets :

<?xml version="1.0" encoding="UTF-8"?>
<!-- un projet « agrégateur » : il regroupe les projets du dossier pour les construire ensemble -->
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>exemples.installation</groupId>
    <artifactId>installation</artifactId>
    <version>1.0</version>
    <packaging>pom</packaging>

    <modules>
        <module>PremierProgramme</module>
        <module>DeuxMains</module>
    </modules>
</project>

• ligne 11 : ce projet ne produit pas d'archive [.jar] : il ne sert qu'à regrouper d'autres projets ([pom]) ;
• lignes 13-16 : les modules, désignés par le nom de leur dossier.

Dans le dossier [02-installation], la commande [mvn compile] compile les deux projets ; un IDE qui ouvre ce dossier y voit les deux projets à la fois. Au chapitre 6, nous verrons qu'un projet parent peut aussi transmettre à ses modules une configuration commune (versions des bibliothèques, options du compilateur).

2.6.2. Un projet avec plusieurs méthodes main

Un projet peut contenir plusieurs classes ayant chacune une méthode [main] : chacune est un point d'entrée possible, et c'est au moment de l'exécution que l'on choisit la classe à exécuter. Le projet [DeuxMains] contient deux classes. La classe [P1] :

package deuxmains;

public class P1 {

    public static void main(String[] args) {
        System.out.println("main de la classe P1");
    }
}

et la classe [P2], identique à son nom près. La commande [java] exécute la classe qu'on lui désigne :

> java -cp target/classes deuxmains.P1
main de la classe P1
> java -cp target/classes deuxmains.P2
main de la classe P2

Pour la commande [mvn exec:java], c'est le fichier [pom.xml] du projet qui désigne la classe à exécuter :

            <!-- la classe dont la méthode main est exécutée par mvn exec:java -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <mainClass>deuxmains.P2</mainClass>
                </configuration>
            </plugin>

• ligne 7 : la méthode [main] exécutée est celle de la classe [deuxmains.P2] (le nom complet de la classe, paquetage compris).

Résultats :

> mvn -q compile exec:java
main de la classe P2

On peut choisir une autre classe sans modifier le fichier [pom.xml] : [mvn -q exec:java -Dexec.mainClass=deuxmains.P1].

2.7. Les exemples du document

Pour exécuter les exemples du document :

• on récupère le dossier [java-oct-2026] (lien en début de document) ;
• on l'ouvre dans VS Code (« File / Open Folder »), ou, pour un projet Maven donné, on ouvre son dossier dans IntelliJ IDEA ;
• dans un terminal placé dans le dossier d'un chapitre, on exécute un fichier source compact par [java Nom.java], ou un projet Maven par [mvn -q compile exec:java] dans le dossier du projet (le texte de chaque chapitre donne la commande exacte).

Les chapitres 10 et 11 utilisent une base de données MySQL ; l'installation de MySQL avec [Laragon] est décrite en annexe.