créer, exporter dans un exécutable pour une application JavaFX

J’ai commencé récemment à créer des application Java avec des interfaces graphiques. Pour cela, j’utilise la bibliothèque JavaFX. Dans cette documentation, je vais indiquer comment créer, exporter en jar et créer un exécutable d’une application JavaFX.

Prérequis

J’utilise actuellement la version JDK (Java Devlopment Kit) 21, donc la version de JavaFX utilisés en dépend donc. Je travaille sur Visual Studio Code, une application fantastique pour gérer ses projet Java,

Télécharger VSCode

Projet Java

Ce lien permet de télécharger sous forme d’archive le projet JavaFX créé par mes soins. C’est une base solide utilisable pour des application grâce à sa séparation entre la vue et le worker.

Télécharger le template JavaFX

Je vais expliquer un peu plus en détail le fonctionnement de ce projet.

App.java

Cette classe contient le code qui va démarrer l’application, c’est depuis ici que le contrôleur de vue va être démarré.

package app;

import app.presentation.MainCtrl;

public class App {

  public static void main(String[] args) {
    new MainCtrl().start();
  }
}

MainCtrl.java

Cette classe va initialiser l’interface graphique et instancier un Worker. Elle contient 3 méthodes importantes:

1. start() appelée par la classe App.java pour démarrer l’interface graphique
2. initialize() appelée durant l’initialisation de l’interface graphique
3. quitter() appelée lorsque l’on désire fermer proprement l’interface graphique

package app.presentation;

import app.workers.Worker;

import java.io.IOException;
import java.net.URL;
import java.util.ResourceBundle;
import javafx.application.Platform;
import javafx.fxml.FXMLLoader;
import javafx.fxml.Initializable;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.scene.image.Image;
import javafx.stage.Stage;
import app.workers.WorkerItf;

/**
 * Contrôleur de la vue principale.
 * 
 * @author ...
 */
public class MainCtrl implements Initializable {
  private WorkerItf wrk;

  public void start() {
    Platform.startup(() -> {
      try {
        Stage mainStage = new Stage();
        mainStage.setMinHeight(600);
        mainStage.setMinWidth(1024);
        mainStage.getIcons().add(new Image("resources/images/icon.png"));
        FXMLLoader fxmlLoader = new FXMLLoader(getClass().getResource("MainView.fxml"));
        fxmlLoader.setControllerFactory(type -> {
          return this;
        });
        Parent root = (Parent) fxmlLoader.load();
        Scene principalScene = new Scene(root);
        mainStage.setScene(principalScene);
        mainStage.setTitle("Application JAVAFX 21");
        mainStage.show();
      } catch (IOException ex) {
        ex.printStackTrace();
        Platform.exit();
      }
    });
  }

  @Override
  public void initialize(URL url, ResourceBundle rb) {
    wrk = new Worker();

  }

  public void quitter() {
    // faire qq chose avant de quitter
    // wrk.fermerBD();
    // System.out.println("Je vous quitte !");

    // obligatoire pour bien terminer une application JavaFX
    Platform.exit();
  }

}

Worker.java et WorkerItf.java

C’est la partie métier. Cette classe se chargera de toute la logique du code (qui ne se situera pas dans le contrôleur !!). Une interface est utilisée.

package app.workers;

public class Worker implements WorkerItf {

    //Constructeur
    public Worker(){
        
    }
}

Exporter son application

L’exportation d’une application JavaFX peut être complexe pour la première fois. Je vais vous expliquer les différentes étapes pour arriver à une magnifique application .exe fonctionnelle.

Créer le fichier Jar

Le fichier Jar est exécutable par un environnement Java compatible. C’est lui qui sera la fondation de notre .exe. Pour exporter son application, je vais cliquer sur cette icône dans VSCode:

VSCode va me demander si je désire inclure la classe main et qu’est-ce que je désire exporter avec, je sélectionne tout:

Ensuite, le fichier Jar va se créer à la racine du répertoire du projet:

Créer le fichier .exe

Maintenant que mon .jar est prêt, je vais pouvoir créer mon fichier .exe pour en faire une application exécutable comme n’importe quelle application du marché.

Premièrement, je vais devoir préparer 2 choses:

1. Un environnement JRE 21 pour exécuter le programme
2. Le fichier de librairies JavaFX .dll

Pour cela, je vais créer un répertoire dist comme Distribution à la racine de mon projet.

Télécharger et copier le JRE

Le choix du JRE est n’a pas une seule solution, je propose d’utiliser Eclipse Temurin.
Site officiel de téléchargement
Télécharger le JRE 21 LTS utilisée

Je peux maintenant décompresser le contenu du zip téléchargé dans un répertoire dans dist nommé jre. attention à bien copier la racine de JRE dans le répertoire jre.

Copier les bin (.dll)

Maintenant, je vais copier le répertoire contenant les fichiers bin de JavaFX (requis pour démarrer l’application en évitant des erreurs fatales). Dans le projet fournit, il faut copier le contenu de lib/bin dans le répertoire dist/bin

Créer le fichier .exe

Maintenant arrive la partie importante. Je vais utilise l’application launch4j pour créer un fichier .exe de mon jar. Pour commencer, je vais ouvrir l’application et renseigner les premières valeurs importantes:

Ensuite, je renseigne le ClassPath, c’est le chemin d’accès de ma classe App.java puis la location des libraries .dll:

Puis, dans le JRE, je vais renseigner le nom de mon répertoire créé précédemment dans lequel on retrouve mon environnement JRE:

Je renseigne ensuite à la JVM qui sera exécutée les arguments désirés. Ces 2 arguments permettent de forcer l’exécution du JRE et de renseigner le répertoire des fichiers .dll:

Les onglets Splash et Version Infos peuvent être intéressant pour renseigner plus d’informations dans son .exe mais je ne vais pas rentrer dans les détails ici. Une fois que tout est prêt, je vais cliquer sur le rouage pour lancer la création de mon .exe. Le fichier a été créé et je peux l’exécuter:

Conclusion

Merci d’avoir suivi cette doc ! J’espère que cela vous a aidé. Ce qu’il faut en retenir est que lors de l’exportation en .exe, il faut inclure tous les fichier .dll présents dans bin ainsi que un environnement d’exécution Java (JRE).