Créer un JAR exécutable avec Gradle

Jusqu'à présent, j'ai créé des fichiers JAR exécutables via la fonctionnalité "Exporter ..." d'Eclipse, mais maintenant je suis passé à IntelliJ IDEA et Gradle pour l'automatisation de la construction.

Certains articles suggèrent ici le plugin "application", mais cela ne conduit pas entièrement au résultat attendu (juste un JAR, pas de scripts de démarrage ou quelque chose comme ça).

Comment puis-je obtenir le même résultat qu'Eclipse avec la boîte de dialogue "Exporter ..."?

Un fichier jar exécutable est simplement un fichier jar contenant une entrée Main-Class dans son manifeste. Il vous suffit donc de configurer la tâche jar pour ajouter cette entrée dans son manifeste:

jar {
    manifest {
        attributes 'Main-Class': 'com.foo.bar.MainClass'
    }
}

Vous devrez peut-être également ajouter des entrées de chemin de classe dans le manifeste, mais cela se ferait de la même manière.

Voir http://docs.oracle.com/javase/tutorial/deployment/jar/manifestindex.html

Les réponses de JB Nizet et Jorge_B sont correctes.

Dans sa forme la plus simple, la création d'un fichier JAR exécutable avec Gradle consiste simplement à ajouter les entrées appropriées au manifeste . Cependant, il est beaucoup plus courant d'avoir des dépendances qui doivent être incluses dans le chemin de classe, ce qui rend cette approche délicate en pratique.

Le plugin d'application fournit une approche alternative; au lieu de créer un JAR exécutable, il fournit:

• une runtâche pour faciliter l'exécution facile de l'application directement à partir de la construction
• une installDisttâche qui génère une structure de répertoires comprenant le JAR intégré, tous les JAR dont elle dépend et un script de démarrage qui rassemble le tout dans un programme que vous pouvez exécuter
• distZipet les distTartâches qui créent des archives contenant une distribution complète de l'application (scripts de démarrage et JAR)

Une troisième approche consiste à créer un soi-disant "fat JAR" qui est un JAR exécutable qui inclut non seulement le code de votre composant, mais également toutes ses dépendances. Il existe quelques plugins différents qui utilisent cette approche. J'ai inclus des liens vers quelques-uns que je connais; Je suis sûr qu'il y en a d'autres.

• ombre
• un pot
• botte à ressort
• capsule

Comme d'autres l'ont noté, pour qu'un fichier jar soit exécutable, le point d'entrée de l'application doit être défini dans l' Main-Classattribut du fichier manifeste. Si les fichiers de classe de dépendance ne sont pas colocalisés, ils doivent être définis dans l' Class-Pathentrée du fichier manifeste.

J'ai essayé toutes sortes de combinaisons de plugins et ce qui ne l'est pas pour la simple tâche de créer un fichier exécutable et, d'une manière ou d'une autre, d'inclure les dépendances. Tous les plugins semblent manquer d'une manière ou d'une autre, mais finalement je l'ai eu comme je le voulais. Pas de scripts mystérieux, pas un million de mini-fichiers différents polluant le répertoire de construction, un fichier de script de construction assez propre, et surtout: pas un million de fichiers de classe tiers étrangers fusionnés dans mon archive jar.

Ce qui suit est un copier-coller à partir d' ici pour votre commodité.

[Comment] créer un fichier zip de distribution avec des jars de dépendances dans le sous /lib- répertoire et ajouter toutes les dépendances à l' Class-Pathentrée dans le fichier manifeste:

apply plugin: 'java'
apply plugin: 'java-library-distribution'

repositories {
    mavenCentral()
}

dependencies {
    compile 'org.apache.commons:commons-lang3:3.3.2'
}

// Task "distZip" added by plugin "java-library-distribution":
distZip.shouldRunAfter(build)

jar {
    // Keep jar clean:
    exclude 'META-INF/*.SF', 'META-INF/*.DSA', 'META-INF/*.RSA', 'META-INF/*.MF'

    manifest {
        attributes 'Main-Class': 'com.somepackage.MainClass',
                   'Class-Path': configurations.runtime.files.collect { "lib/$it.name" }.join(' ')
    }
    // How-to add class path:
    //     /programming/22659463/add-classpath-in-manifest-using-gradle
    //     https://gist.github.com/simon04/6865179
}

Hébergé comme un essentiel ici .

Le résultat peut être trouvé dans build/distributionset le contenu décompressé ressemble à ceci:

lib / commons-lang3-3.3.2.jar
MyJarFile.jar

Contenu de MyJarFile.jar#META-INF/MANIFEST.mf:

Version du manifeste: 1.0
Classe principale: com.somepackage.MainClass
Chemin de classe: lib / commons-lang3-3.3.2.jar

La solution la moins efficace pour moi était d'utiliser le plugin gradle-shadow-plugin

Outre l'application du plugin, tout ce qui doit être fait est:

Configurez la tâche jar pour mettre votre classe principale dans le manifeste

jar {
  manifest {
   attributes 'Main-Class': 'com.my.app.Main'
  }
}

Exécutez la tâche gradle

./gradlew shadowJar

Prenez le fichier app-version-all.jar de build / libs /

Et enfin exécutez-le via:

java -jar app-version-all.jar

Avez-vous essayé la tâche 'installApp'? Ne crée-t-il pas un répertoire complet avec un ensemble de scripts de démarrage?

http://www.gradle.org/docs/current/userguide/application_plugin.html

Merci Konstantin, cela a fonctionné comme un charme avec quelques nuances. Pour une raison quelconque, la spécification de la classe principale dans le cadre du manifeste jar ne fonctionnait pas tout à fait et il souhaitait plutôt l'attribut mainClassName. Voici un extrait de build.gradle qui comprend tout pour le faire fonctionner:

plugins {
  id 'java' 
  id 'com.github.johnrengelman.shadow' version '1.2.2'
}
...
...
apply plugin: 'application'
apply plugin: 'com.github.johnrengelman.shadow'
...
...
mainClassName = 'com.acme.myapp.MyClassMain'
...
...
...
shadowJar {
    baseName = 'myapp'
}

Après avoir exécuté gradle shadowJar, vous obtenez myapp- {version} -all.jar dans votre dossier de construction qui peut être exécuté en tant que java -jar myapp- {version} -all.jar.

Vous pouvez définir un artefact jar dans les paramètres du module (ou dans la structure du projet).

• Cliquez avec le bouton droit sur le module> Ouvrir les paramètres du module> Artefacts> +> JAR> à partir des modules avec dépendances.
• Définissez la classe principale.

Créer un pot est alors aussi simple que de cliquer sur "Construire un artefact ..." dans le menu Construire. En prime, vous pouvez regrouper toutes les dépendances dans un seul bocal.

Testé sur IntelliJ IDEA 14 Ultimate.

J'ai vérifié plusieurs liens pour la solution, puis j'ai finalement suivi les étapes mentionnées ci-dessous pour la faire fonctionner. J'utilise Gradle 2.9.

Apportez les modifications suivantes à votre build, fichier gradle:

1. Mentionnez le plugin:

   apply plugin: 'eu.appsatori.fatjar'

2. Fournissez le Buildscript:

   buildscript {
   repositories {
       jcenter()
   }
   
   dependencies {
       classpath "eu.appsatori:gradle-fatjar-plugin:0.3"
   }
   }

3. Fournissez la classe principale:

   fatJar {
     classifier 'fat'
     manifest {
       attributes 'Main-Class': 'my.project.core.MyMainClass'
     }
     exclude 'META-INF/*.DSA', 'META-INF/*.RSA', 'META-INF/*.SF'
   }

4. Créez le fatjar:

   ./gradlew clean fatjar

5. Exécutez le fatjar depuis / build / libs /:

   java -jar MyFatJar.jar

Vous pouvez utiliser le plugin SpringBoot:

plugins {
  id "org.springframework.boot" version "2.2.2.RELEASE"
}

Créer le pot

gradle assemble

Et puis lancez-le

java -jar build/libs/*.jar

Remarque: votre projet n'a PAS besoin d'être un projet SpringBoot pour utiliser ce plugin.