Comment configurer et basculer entre plusieurs versions de Java sur Linux avec alternatives

Introduction

Dans le monde du developpement Java, il est courant de devoir jongler entre plusieurs versions du JDK. Que ce soit pour maintenir une application legacy en Java 8, developper un nouveau projet en Java 17, ou tester les dernieres fonctionnalites de Java 21, la capacite a basculer rapidement entre differentes versions de Java est une competence essentielle pour tout developpeur.

Linux offre un outil puissant pour gerer cette problematique : le systeme alternatives. Cet outil, disponible sur la plupart des distributions Linux (Red Hat, CentOS, Fedora, Debian, Ubuntu), permet de gerer de maniere elegante les liens symboliques vers differentes versions d’un meme programme.

Dans ce guide complet, nous allons explorer en detail comment :

• Installer plusieurs versions de Java en parallele
• Configurer le systeme alternatives pour gerer ces versions
• Basculer facilement entre les differentes versions
• Configurer les variables d’environnement associees (JAVA_HOME, PATH)
• Automatiser la selection de version par projet

Pourquoi gerer plusieurs versions de Java ?

Plusieurs raisons justifient la necessite de maintenir plusieurs versions de Java :

1. Compatibilite des applications : Certaines applications ne fonctionnent qu’avec des versions specifiques de Java
2. Developpement multi-projets : Differents projets peuvent necessiter differentes versions
3. Tests de compatibilite : Valider le comportement d’une application sur plusieurs JDK
4. Migration progressive : Tester une nouvelle version avant de l’adopter definitivement

Prerequis : Installation de plusieurs versions de Java

Avant de configurer alternatives, vous devez installer les versions de Java dont vous avez besoin. Voici comment proceder selon votre distribution.

Sur Ubuntu/Debian

# Mettre a jour les depots
sudo apt update

# Installer OpenJDK 8, 11, 17 et 21
sudo apt install openjdk-8-jdk
sudo apt install openjdk-11-jdk
sudo apt install openjdk-17-jdk
sudo apt install openjdk-21-jdk

# Verifier les installations
ls /usr/lib/jvm/

Sur Red Hat/CentOS/Fedora

# Installer OpenJDK via dnf ou yum
sudo dnf install java-1.8.0-openjdk-devel
sudo dnf install java-11-openjdk-devel
sudo dnf install java-17-openjdk-devel
sudo dnf install java-21-openjdk-devel

# Verifier les installations
ls /usr/lib/jvm/

Etape 1 : Identifier la version de Java actuellement utilisee

Avant de commencer a configurer alternatives, vous devez identifier quelle version de Java est actuellement active sur votre systeme.

Verifier la version active

# Afficher la version de Java utilisee
java -version

# Exemple de sortie
openjdk version "17.0.9" 2023-10-17
OpenJDK Runtime Environment (build 17.0.9+9-Ubuntu-122.04)
OpenJDK 64-Bit Server VM (build 17.0.9+9-Ubuntu-122.04, mixed mode, sharing)

Afficher la configuration alternatives

# Sur Red Hat/CentOS/Fedora
sudo alternatives --display java

# Sur Debian/Ubuntu
sudo update-alternatives --display java

Cette commande affiche des informations detaillees sur la configuration actuelle :

java - status is manual.
 link currently points to /usr/lib/jvm/java-17-openjdk-amd64/bin/java
/usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java - priority 1081
/usr/lib/jvm/java-11-openjdk-amd64/bin/java - priority 1111
/usr/lib/jvm/java-17-openjdk-amd64/bin/java - priority 1171
/usr/lib/jvm/java-21-openjdk-amd64/bin/java - priority 2111
Current 'best' version is /usr/lib/jvm/java-21-openjdk-amd64/bin/java.

Etape 2 : Configurer les versions de Java avec alternatives

Si vous avez installe Java manuellement (par exemple, en telechargant le JDK depuis le site d’Oracle ou Adoptium), vous devez enregistrer ces versions dans le systeme alternatives.

Syntaxe de la commande install

# Syntaxe generale
sudo alternatives --install <lien> <nom> <chemin> <priorite>

# Exemple concret pour Java 17
sudo alternatives --install /usr/bin/java java /opt/jdk-17/bin/java 1700

Les parametres expliques :

• lien : Le chemin du lien symbolique (/usr/bin/java)
• nom : Le nom du groupe alternatives (java)
• chemin : Le chemin vers l’executable reel
• priorite : Un nombre qui determine la version par defaut en mode automatique

Enregistrer un JDK telecharge manuellement

# Supposons que vous avez telecharge et extrait JDK 21 dans /opt
sudo alternatives --install /usr/bin/java java /opt/jdk-21/bin/java 2100
sudo alternatives --install /usr/bin/javac javac /opt/jdk-21/bin/javac 2100
sudo alternatives --install /usr/bin/jar jar /opt/jdk-21/bin/jar 2100

# Configurer aussi JAVA_HOME comme alternative (optionnel mais recommande)
sudo alternatives --install /usr/lib/jvm/java java_home /opt/jdk-21 2100

Configuration avec slaves (commandes liees)

Pour gerer plusieurs commandes Java ensemble, utilisez l’option --slave :

sudo alternatives --install /usr/bin/java java /opt/jdk-17/bin/java 1700 \
  --slave /usr/bin/javac javac /opt/jdk-17/bin/javac \
  --slave /usr/bin/jar jar /opt/jdk-17/bin/jar \
  --slave /usr/bin/javadoc javadoc /opt/jdk-17/bin/javadoc \
  --slave /usr/bin/jshell jshell /opt/jdk-17/bin/jshell

Cette approche garantit que toutes les commandes Java basculent ensemble.

Etape 3 : Basculer entre les versions de Java

Une fois les versions configurees, vous pouvez facilement basculer entre elles.

Mode interactif

# Sur Red Hat/CentOS/Fedora
sudo alternatives --config java

# Sur Debian/Ubuntu
sudo update-alternatives --config java

Exemple de sortie interactive :

There are 4 programs which provide 'java'.

  Selection    Command
-----------------------------------------------
   1           /usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java
   2           /usr/lib/jvm/java-11-openjdk-amd64/bin/java
*+ 3           /usr/lib/jvm/java-17-openjdk-amd64/bin/java
   4           /usr/lib/jvm/java-21-openjdk-amd64/bin/java

Enter to keep the current selection[+], or type selection number:

Le symbole * indique la selection actuelle, et + indique le mode automatique.

Mode non-interactif (pour scripts)

# Definir directement une version specifique
sudo alternatives --set java /usr/lib/jvm/java-11-openjdk-amd64/bin/java

# Revenir au mode automatique (priorite la plus haute)
sudo alternatives --auto java

Etape 4 : Verifier et valider la configuration

Apres avoir bascule entre les versions, il est essentiel de verifier que la configuration est correcte.

Verification complete

# Verifier la version de java
java -version

# Verifier la version du compilateur
javac -version

# Verifier le chemin de l'executable
which java
# Devrait afficher : /usr/bin/java

# Verifier le lien symbolique
readlink -f $(which java)
# Affiche le chemin reel de l'executable

Script de verification complet

#!/bin/bash
echo "=== Verification Java ==="
echo "Java version:"
java -version 2>&1 | head -1

echo -e "\nJavac version:"
javac -version 2>&1

echo -e "\nChemin java:"
readlink -f $(which java)

echo -e "\nJAVA_HOME:"
echo $JAVA_HOME

echo -e "\nAlternatives configurees:"
alternatives --display java 2>/dev/null | head -10

Configuration de JAVA_HOME

La variable d’environnement JAVA_HOME est utilisee par de nombreux outils (Maven, Gradle, IDE). Il est important de la configurer correctement.

Configuration manuelle

# Ajouter dans ~/.bashrc ou ~/.zshrc
export JAVA_HOME=$(dirname $(dirname $(readlink -f $(which java))))
export PATH=$JAVA_HOME/bin:$PATH

Configuration dynamique avec alternatives

# Creer un script qui detecte automatiquement JAVA_HOME
cat >> ~/.bashrc << 'EOF'
# Configuration dynamique de JAVA_HOME
if command -v java &> /dev/null; then
    export JAVA_HOME=$(dirname $(dirname $(readlink -f $(which java))))
fi
EOF

# Recharger la configuration
source ~/.bashrc

Bonnes Pratiques

Voici les bonnes pratiques essentielles pour gerer efficacement vos versions de Java.

1. Utilisez des priorites coherentes

# Convention recommandee : priorite = version * 100
# Java 8  -> priorite 800
# Java 11 -> priorite 1100
# Java 17 -> priorite 1700
# Java 21 -> priorite 2100

2. Configurez toutes les commandes liees

Ne configurez pas seulement java, mais aussi javac, jar, javadoc, etc. Utilisez les slaves pour garantir la coherence.

3. Documentez vos installations

# Creer un fichier de reference
cat > /opt/java-versions.txt << EOF
Java 8:  /usr/lib/jvm/java-8-openjdk-amd64
Java 11: /usr/lib/jvm/java-11-openjdk-amd64
Java 17: /usr/lib/jvm/java-17-openjdk-amd64
Java 21: /opt/jdk-21
EOF

4. Utilisez des outils de gestion de version par projet

Pour les projets individuels, considerez des outils comme SDKMAN! ou jenv :

# Installation de SDKMAN!
curl -s "https://get.sdkman.io" | bash

# Utilisation
sdk install java 17.0.9-tem
sdk use java 17.0.9-tem

5. Testez apres chaque changement

# Script de test rapide
java -version && javac -version && echo "Configuration OK"

Pieges Courants

Piege 1 : JAVA_HOME non mis a jour

Probleme : Vous changez la version avec alternatives, mais JAVA_HOME pointe toujours vers l’ancienne version.

Solution : Utilisez une configuration dynamique de JAVA_HOME (voir section precedente).

Piege 2 : Incoherence entre java et javac

Probleme : java -version et javac -version affichent des versions differentes.

# Verifier la coherence
java -version   # Affiche Java 17
javac -version  # Affiche Java 11 (PROBLEME!)

Solution : Configurez les alternatives avec des slaves ou configurez separement javac.

Piege 3 : Session shell non rechargee

Probleme : Les changements ne prennent pas effet immediatement.

Solution :

# Recharger le shell
source ~/.bashrc

# Ou ouvrir un nouveau terminal

Piege 4 : Permissions insuffisantes

Probleme : Erreur “Permission denied” lors de la configuration.

Solution : Utilisez toujours sudo pour les commandes alternatives.

Piege 5 : Chemin incorrect dans alternatives

Probleme : Le chemin specifie n’existe pas ou est incorrect.

# Verifier que le chemin existe
ls -la /path/to/jdk/bin/java

# Supprimer une entree incorrecte
sudo alternatives --remove java /wrong/path/to/java

Piege 6 : Oublier le mode automatique vs manuel

Probleme : Apres une mise a jour systeme, Java revient a une version non souhaitee.

Explication : En mode automatique (+), le systeme choisit la version avec la priorite la plus haute.

Solution : Utilisez le mode manuel pour fixer une version specifique :

sudo alternatives --config java
# Selectionnez votre version preferee

Conclusion

La gestion de plusieurs versions de Java sur Linux est une competence essentielle pour tout developpeur travaillant sur des projets Java. Le systeme alternatives (ou update-alternatives sur Debian/Ubuntu) offre une solution elegante et robuste pour gerer cette complexite.

Dans cet article, nous avons couvert :

1. L’installation de plusieurs versions de Java en parallele
2. La configuration du systeme alternatives avec les bonnes priorites
3. Le basculement entre versions de maniere interactive ou scriptable
4. La verification de la configuration et la coherence des outils
5. Les bonnes pratiques pour une gestion efficace
6. Les pieges courants et comment les eviter

Points cles a retenir

• Utilisez toujours des priorites coherentes (version * 100)
• Configurez les slaves pour maintenir la coherence entre java, javac, et autres outils
• Mettez a jour dynamiquement JAVA_HOME pour qu’il suive les changements
• Testez systematiquement apres chaque modification
• Considerez des outils comme SDKMAN! pour une gestion encore plus fine par projet

Prochaines etapes recommandees

1. Auditez votre systeme : Verifiez quelles versions de Java sont installees et configurees
2. Standardisez : Adoptez une convention de priorites coherente
3. Automatisez : Creez des scripts pour les taches repetitives
4. Documentez : Maintenez une reference des versions installees et leurs usages

Avec ces connaissances, vous etes maintenant capable de gerer efficacement vos environnements Java sur Linux, que ce soit pour le developpement, les tests ou la production.

Ressources supplementaires

• Documentation officielle OpenJDK
• SDKMAN! - The Software Development Kit Manager
• Adoptium (anciennement AdoptOpenJDK)
• Documentation alternatives (man page)