Creazione di JAR eseguibili con Gradle

Fino ad ora ho creato file JAR eseguibili tramite la funzione “Esporta …” di Eclipse, ma ora sono passato a IntelliJ IDEA e Gradle per l’automazione della build.

Alcuni articoli suggeriscono il plugin “application”, ma questo non porta interamente al risultato che mi aspettavo (solo un JAR, nessun script di avvio o qualcosa del genere).

Come posso ottenere lo stesso risultato di Eclipse con la finestra di dialogo “Esporta …”?

Un file jar eseguibile è solo un file jar contenente una voce Main-Class nel suo manifest. Quindi è sufficiente configurare l’ attività jar per aggiungere questa voce nel manifest:

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

Potrebbe anche essere necessario aggiungere voci di classpath nel manifest, ma ciò avverrebbe nello stesso modo.

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

Entrambe le risposte di JB Nizet e Jorge_B sono corrette.

Nella sua forma più semplice, creare un JAR eseguibile con Gradle è solo questione di aggiungere le voci appropriate al manifest . Tuttavia, è molto più comune avere dipendenze che devono essere incluse nel classpath, rendendo questo approccio difficile nella pratica.

Il plug-in dell’applicazione fornisce un approccio alternativo; invece di creare un JAR eseguibile, fornisce:

  • un’attività di run per facilitare facilmente l’esecuzione dell’applicazione direttamente dalla compilazione
  • un’attività installDist che genera una struttura di directory che include il JAR costruito, tutti i JAR da cui dipende e uno script di avvio che lo riunisce in un programma che è ansible eseguire
  • distZip e distTar attività che creano archivi contenenti una distribuzione completa dell’applicazione (script di avvio e JAR)

Un terzo approccio consiste nel creare un cosiddetto “fat JAR” che è un JAR eseguibile che include non solo il codice del componente, ma anche tutte le sue dipendenze. Esistono alcuni plugin diversi che utilizzano questo approccio. Ho incluso collegamenti ad alcuni di cui sono a conoscenza; Sono sicuro che ce ne sono di più.

  • ombra
  • un jar
  • spring-boot
  • capsula

Come altri hanno notato, affinché un file jar sia eseguibile, il punto di ingresso dell’applicazione deve essere impostato nell’attributo Main-Class del file manifest. Se i file della class di dipendenza non sono collocati, devono essere impostati nella voce Class-Path del file manifest.

Ho provato tutti i tipi di combinazioni di plugin e cosa non per il semplice compito di creare un jar eseguibile e in qualche modo in qualche modo, includere le dipendenze. Tutti i plugin sembrano mancare in un modo o nell’altro, ma alla fine l’ho preso come volevo. Nessun script misterioso, non un milione di mini file diversi che inquinano la directory di costruzione, un file di script di compilazione piuttosto pulito, e soprattutto: non un milione di file di terze parti straniere si sono fusi nel mio archivio jar.

Il seguente è un copia-incolla da qui per la vostra convenienza ..

[How-to] creare un file zip di distribuzione con i file delle dipendenze nella sottodirectory /lib e aggiungere tutte le dipendenze alla voce Class-Path nel file manifest:

 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: // https://stackoverflow.com/questions/22659463/add-classpath-in-manifest-using-gradle // https://gist.github.com/simon04/6865179 } 

Ospitato come un esempio qui .

Il risultato può essere trovato in build/distributions e il contenuto decompresso è simile al seguente:

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

Contenuti di MyJarFile.jar#META-INF/MANIFEST.mf :

Versione manifesta: 1.0
Main-Class: com.somepackage.MainClass
Percorso di class: lib / commons-lang3-3.3.2.jar

La soluzione meno dispendiosa per me consisteva nell’utilizzare il plugin gradle-shadow

Oltre ad applicare il plugin, tutto ciò che deve essere fatto è:

  • Configura l’attività jar per mettere in evidenza la tua class Main

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

  • eseguire il compito gradle ./gradlew shadowJar

  • prendi l’ app-version-all.jar da build / libs /

E finalmente eseguirlo tramite:

 java -jar app-version-all.jar 

Hai provato l’attività “installApp”? Non crea una directory completa con un set di script di avvio?

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

È ansible definire un artefatto del jar nelle impostazioni del modulo (o nella struttura del progetto).

  • Fare clic col tasto destro sul modulo> Apri impostazioni modulo> Artefatti> +> JAR> da moduli con dipendenze.
  • Imposta la class principale.

Creare un jar è semplice come fare clic su “Crea artefatto …” dal menu Genera. Come bonus, puoi raggruppare tutte le dipendenze in un singolo barattolo.

Testato su IntelliJ IDEA 14 Ultimate.

Grazie Konstantin, ha funzionato come un fascino con poche sfumature. Per qualche ragione, specificare la class principale come parte del manifest jar non funzionava e voleva invece l’attributo mainClassName. Ecco uno snippet di build.gradle che include tutto per farlo funzionare:

 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' } 

Dopo aver eseguito gradle shadowJar hai la mia app- {versione} -all.jar nella tua cartella build che può essere eseguita come java -jar myapp- {versione} -all.jar.

Ho controllato abbastanza alcuni collegamenti per la soluzione, infine ho fatto i passaggi sotto indicati per farlo funzionare. Sto usando Gradle 2.9.

Apporta le seguenti modifiche al tuo file build, gradle:

  1. Plugin di menzione:

     apply plugin: 'eu.appsatori.fatjar' 
  2. Fornisci il codice build:

     buildscript { repositories { jcenter() } dependencies { classpath "eu.appsatori:gradle-fatjar-plugin:0.3" } } 
  3. Fornire la class principale:

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

     ./gradlew clean fatjar 
  5. Esegui il fatjar da / build / libs /:

     java -jar MyFatJar.jar