Qu'est-ce qu'un JAR lourd ?

Question

J'ai entendu des gens dire qu'ils créaient un gros JAR et le déployaient. Qu'est-ce que cela signifie en réalité ?

Answer 1

Les différents noms ne sont que des façons d'emballer les applications Java.

Maigre - Contient seulement les éléments que vous tapez littéralement dans votre éditeur de code, et rien d'autre part.

Mince - Contient tout ce qui précède plus les dépendances directes de votre application (pilotes de db, bibliothèques d'utilitaires, etc.).

Creux - L'inverse de mince. Il ne contient que les éléments nécessaires à l'exécution de votre application, mais ne contient pas no contiennent l'application elle-même. Il s'agit en fait d'un "serveur d'application" prépackagé sur lequel vous pouvez ensuite déployer votre application, dans le même style que les serveurs d'application Java EE traditionnels, mais avec d'importantes différences.

Fat/Uber - Contient la partie que vous écrivez littéralement vous-même plus les dépendances directes de votre application PLUS les éléments nécessaires pour faire fonctionner votre application "seule".

Source : Article de Dzone

Answer 2

Le fat jar est le jar qui contient les classes de toutes les bibliothèques dont dépend votre projet et, bien sûr, les classes du projet en cours.

Dans les différents systèmes de construction, le fat jar est créé différemment, par exemple, dans Gradle, on le crée avec ( instruction ) :

task fatJar(type: Jar) {
    manifest {
        attributes 'Main-Class': 'com.example.Main'
    }
    baseName = project.name + '-all'
    from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
    with jar
}

Dans Maven, cela se fait de cette façon (après avoir configuré le jar normal) :

<pluginRepositories>
   <pluginRepository>
        <id>onejar-maven-plugin.googlecode.com</id>
        <url>http://onejar-maven-plugin.googlecode.com/svn/mavenrepo</url>
   </pluginRepository>
  </pluginRepositories>
<!-- ... -->

<plugin>
    <groupid>org.dstovall</groupid>
    <artifactid>onejar-maven-plugin</artifactid>
    <version>1.4.4</version>
    <executions>
        <execution>
            <configuration>
                <onejarversion>0.97</onejarversion>
                <classifier>onejar</classifier>
            </configuration>
            <goals>
                <goal>one-jar</goal>
            </goals>
        </execution>
   </executions>
</plugin>

Answer 3

Fat jar ou uber jar est un jar qui contient tous les fichiers de classe et les ressources du projet, ainsi que toutes ses dépendances. Il existe différentes méthodes pour obtenir cet effet :

• les jar des dépendances sont copiés dans le jar principal, puis chargés à l'aide d'un chargeur de classes spécial (onejar, spring-boot-plugin:repackage).
• les jars des dépendances sont extraits au sommet de la hiérarchie principale des jars (maven-assembly-plugin avec son assemblage jar-with-dependencies)
• les jarres des dépendances sont déballées au sommet de la hiérarchie des jarres principales et leurs paquets sont renommés (maven-shade-plugin avec shade goal)

Voici un exemple de configuration du plugin d'assemblage jar-avec-dépendances :

<project>
  <!-- ... -->
  <build>
    <!-- ... -->
    <plugins>
      <plugin>
        <!-- NOTE: We don't need a groupId specification because the group is
             org.apache.maven.plugins ...which is assumed by default.
         -->
        <artifactId>maven-assembly-plugin</artifactId>
        <version>2.6</version>
        <configuration>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
          <classifier>
        </configuration>
        <!-- ... -->
</project>

Pour une explication plus détaillée : Uber-JAR à imagej.net

Answer 4

Dans le cas d'un jar exécutable, une autre façon de penser à un fat jar est un jar que vous pouvez exécuter en l'invoquant :

java -jar myFatLibrary.jar

sans qu'il soit nécessaire de -cp / --classpath ou même en double-cliquant sur l'icône du bocal.

Answer 5

A partir de la Documentation Gradle :

Dans l'espace Java, les applications et leurs dépendances sont généralement présentés sous la forme de JAR distincts dans une seule archive de distribution. C'est toujours le cas, mais une autre approche est désormais courante : placer les classes et les ressources des dépendances directement dans le JAR de l'application, créant ainsi ce que l'on appelle un uber ou fat JAR.

Voici une démonstration de uberJar tâche en build.gradle fichier :

task uberJar(type: Jar) {
    archiveClassifier = 'uber'

    from sourceSets.main.output

    dependsOn configurations.runtimeClasspath
    from {
        configurations.runtimeClasspath.findAll { it.name.endsWith('jar') }.collect { zipTree(it) }
    }
}

Dans ce cas, nous prenons les dépendances d'exécution du projet - configurations.runtimeClasspath.files - et en enveloppant chacun des fichiers JAR avec l'extension zipTree() méthode. Le résultat est une collection d'arbres de fichiers ZIP, dont le contenu est copié dans le JAR uber avec les classes d'application.