Aller au contenu

Compilation et archive .jar

Il y a deux méthodes pour distribuer un programme en Java : compiler les classes ou créer une archive .jar.

Compilation

Pour compiler un programme en Java, on doit utiliser la commande javac et appeler la classe principale pour compiler les fichier .java en fichiers .class.

Par la suite, on pourra lancer le programme en utilisant la commande java Main (sans extension) pour lancer le programme.

Créer une archive .jar

Pour distribuer notre programme plus facilement, il pourrait être judicieux de créer une archive .jar. Cette archive est comparable à un exécutable .exe avec Windows. Quelques étapes sont nécessaires.

Attention

Votre projet doit être créé en utilisant maven pour pouvoir créer cette archive selon cette méthode.

1. Ajouer les plugins maven

Ouvrir le fichier pom.xml et ajouter la section build suivant, sous </properties>, en vous assurant de ne rien modifier au dessus. Votre fichier devrait alors ressembler à ceci.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
<?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>org.example</groupId>
    <artifactId>demoCompiler</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.11.0</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.5.0</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <manifestEntries>
                                        <Main-Class>Main</Main-Class>    <!-- (1) -->
                                    </manifestEntries>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

  1. Il faut changer pour la classe principale du programme.

2. Synchroniser maven

Dans le panneau de gauche de IntelliJ IDEA, ouvrir maven et cliquer sur recharger le projet. Ceci permettra à maven de télécharger les plugins nécessaires à l'archivage de votre projet. Lorsque maven aura terminé, une nouveau plugin sera disponible sous Plugins.

3. Créer l'archive à l'aide de IntelliJ IDEA

Pour créer une archive distribuable, double-cliquer sur package situé dans le panneau maven sous le dossier Lifecycle. Une fois l'archivage créé, les archives seront créées dans le dossier target du projet.

4. Exécuter le programme à l'aide de l'archive

Pour exécuter un programme Java à partir d'un fichier .jar, on doit utiliser la commande suivante : 

java -jar <le_fichier.jar>

Plusieurs archives .jar

Pour avoir plusieurs archives .jar en même temps, il suffit d'avoir plusieurs blocs <execution>, un pour chaque binaire à compiler. Il faudra également spécifier un <id> et un <finalName>.

Cet exemple va générer deux fichiers : Serveur.jar et Client.jar.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<executions>
    <execution>
        <id>Serveur</id> <!-- (1) -->
        <phase>package</phase>
        <goals>
            <goal>shade</goal>
        </goals>
        <configuration>
            <finalName>Serveur</finalName> <!-- (2) -->
            <transformers>
                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                    <manifestEntries>
                        <Main-Class>Serveur</Main-Class>
                    </manifestEntries>
                </transformer>
            </transformers>
        </configuration>
    </execution>
    <execution>
        <id>Client</id>
        <phase>package</phase>
        <goals>
            <goal>shade</goal>
        </goals>
        <configuration>
            <finalName>Client</finalName>
            <transformers>
                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                    <manifestEntries>
                        <Main-Class>Client</Main-Class>
                    </manifestEntries>
                </transformer>
            </transformers>
        </configuration>
    </execution>
</executions>

  1. Le ID doit être unique
  2. Va générer le fichier Serveur.jar