java - generate - Creando JAR ejecutable con Gradle

gradle jar dependency

Question

Hasta ahora he creado archivos ejecutables JAR a través de la función Eclipse "Exportar ..." pero ahora cambié a IntelliJ IDEA y Gradle para la automatización de compilación.

Algunos artículos aquí sugieren el complemento de "aplicación", pero esto no conduce por completo al resultado que esperaba (solo un JAR, sin guiones de inicio ni nada de esto).

¿Cómo puedo lograr el mismo resultado que Eclipse con el diálogo "Exportar ..."?

Answer 1

¿Has probado la tarea ''installApp''? ¿No crea un directorio completo con un conjunto de scripts de inicio?

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

Answer 2

Como han señalado otros, para que un archivo jar sea ejecutable, el punto de entrada de la aplicación debe establecerse en el atributo de Main-Class del archivo de manifiesto. Si los archivos de la clase de dependencia no están colocados, entonces deben establecerse en la entrada de Class-Path del archivo de manifiesto.

He intentado todo tipo de combinaciones de complementos y lo que no es para la simple tarea de crear un archivo ejecutable y, de alguna manera, incluir las dependencias. Todos los complementos parecen faltar de una manera u otra, pero finalmente lo obtuve como quería. No hay scripts misteriosos, ni un millón de mini-archivos diferentes que contaminan el directorio de compilación, un archivo de script de compilación bastante limpio y, sobre todo, no se fusionaron un millón de archivos de terceros externos en mi archivo jar.

Lo siguiente es un copiar y pegar desde here para su conveniencia.

[Cómo hacer] crear un archivo zip de distribución con los jar de dependencia en el subdirectorio /lib y agregar todas las dependencias a la entrada del Class-Path en el archivo de manifiesto:

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

Alojado como una esencia here .

El resultado se puede encontrar en build/distributions y los contenidos descomprimidos se ven así:

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

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

Manifest-Version: 1.0
Clase principal: com.somepackage.MainClass
Ruta de clase: lib / commons-lang3-3.3.2.jar

Answer 3

Gracias Konstantin, funcionó como un amuleto con pocos matices. Por alguna razón, especificar la clase principal como parte del manifiesto jar no funcionó del todo y quería el atributo mainClassName en su lugar. Aquí hay un fragmento de build.gradle que incluye todo para que funcione:

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

Después de ejecutar gradle shadow, obtendrá myapp- {version} -all.jar en su carpeta de compilación, que se puede ejecutar como java -jar myapp- {version} -all.jar.

Answer 4

La solución de menor esfuerzo para mí fue hacer uso del shadow

Además de aplicar el complemento, todo lo que se necesita hacer es:

• Configure la tarea jar para poner su clase principal en manifiesto

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

• ejecutar la tarea gradle ./gradlew shadowJar

• tomar la aplicación-versión-todo.jar de build / libs /

Y finalmente ejecutarlo a través de:

java -jar app-version-all.jar

Answer 5

Las respuestas de JB Nizet y Jorge_B son correctas.

En su forma más simple, crear un JAR ejecutable con Gradle es simplemente una cuestión de agregar las entradas apropiadas al manifest . Sin embargo, es mucho más común tener dependencias que deben incluirse en el classpath, lo que hace que este enfoque sea complicado en la práctica.

El complemento de la aplicación proporciona un enfoque alternativo; en lugar de crear un archivo JAR ejecutable, proporciona:

• una tarea de run para facilitar la ejecución sencilla de la aplicación directamente desde la construcción
• una tarea installDist que genera una estructura de directorios que incluye el JAR incorporado, todos los JAR de los que depende y un script de inicio que lo combina todo en un programa que puede ejecutar
• tareas distZip y distTar que crean archivos que contienen una distribución completa de aplicaciones (scripts de inicio y JAR)

Un tercer enfoque es crear un llamado "JAR gordo" que es un JAR ejecutable que incluye no solo el código de su componente, sino también todas sus dependencias. Hay algunos complementos diferentes que usan este enfoque. He incluido enlaces a algunos que conozco; Estoy seguro de que hay más.

• shadow
• one-jar
• spring-boot
• capsule

Answer 6

Puede definir un artefacto de jar en la configuración del módulo (o estructura del proyecto).

• Haga clic con el botón derecho en el módulo> Abrir configuración de módulo> Artefactos> +> JAR> desde módulos con dependencias.
• Establece la clase principal.

Hacer una jarra es tan fácil como hacer clic en "Crear artefacto ..." en el menú Compilar. Como beneficio adicional, puede empaquetar todas las dependencias en un solo contenedor.

Probado en IntelliJ IDEA 14 Ultimate.

Answer 7

Revisé algunos enlaces para la solución, finalmente hice los pasos mencionados a continuación para que funcione. Estoy usando Gradle 2.9.

Realice los siguientes cambios en su compilación, archivo gradle:

1. Complemento de mencion:

   apply plugin: ''eu.appsatori.fatjar''

2. Proporcione el Buildscript:

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

3. Proporcione la clase principal:

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

4. Crea el fatjar:

   ./gradlew clean fatjar

5. Ejecute el fatjar desde / build / libs /:

   java -jar MyFatJar.jar

Answer 8

Un archivo jar ejecutable es solo un archivo jar que contiene una entrada de clase principal en su manifiesto. Entonces solo necesita configurar la tarea jar para agregar esta entrada en su manifiesto:

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

Es posible que también necesite agregar entradas classpath en el manifiesto, pero eso se haría de la misma manera.

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