mundo - gradle jar file

Usando Gradle para construir un jar con dependencias

Question

Tengo una compilación multiproyecto y puse una tarea para construir un contenedor de grasa en uno de los subproyectos. Creé la tarea similar a la descrita en el libro de cocina .

jar {
  from configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }
  manifest { attributes ''Main-Class'': ''com.benmccann.gradle.test.WebServer'' }
}

Ejecutarlo da como resultado el siguiente error:

Causa: ¡No puede cambiar una configuración que no está en estado no resuelto!

No estoy seguro de lo que significa este error. También informé de esto en Gradle JIRA en caso de que sea un error .

Answer 1

Esto funciona bien para mi.

Mi clase principal:

package com.curso.online.gradle;

import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;

public class Main {

    public static void main(String[] args) {
        Logger logger = Logger.getLogger(Main.class);
        logger.debug("Starting demo");

        String s = "Some Value";

        if (!StringUtils.isEmpty(s)) {
            System.out.println("Welcome ");
        }

        logger.debug("End of demo");
    }

}

Y es el contenido de mi archivo build.gradle:

apply plugin: ''java''

apply plugin: ''eclipse''

repositories {
    mavenCentral()
}

dependencies {
    compile group: ''commons-collections'', name: ''commons-collections'', version: ''3.2''
    testCompile group: ''junit'', name: ''junit'', version: ''4.+''
    compile  ''org.apache.commons:commons-lang3:3.0''
    compile  ''log4j:log4j:1.2.16''
}

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

Y escribo lo siguiente en mi consola:

java -jar ProyectoEclipseTest-all.jar

Y la salida es genial:

log4j:WARN No appenders could be found for logger (com.curso.online.gradle.Main)
.
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more in
fo.
Welcome

Answer 2

La respuesta de @ben casi me funciona, excepto que mis dependencias son demasiado grandes y recibí el siguiente error

Execution failed for task '':jar''.
> archive contains more than 65535 entries.

  To build this archive, please enable the zip64 extension.

Para solucionar este problema, tengo que usar el siguiente código

mainClassName = "com.company.application.Main"

jar {
  manifest { 
    attributes "Main-Class": "$mainClassName"
  }  
  zip64 = true
  from {
    configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }
  }
}

Answer 3

La respuesta de @felix casi me trajo allí. Tenía dos problemas:

1. Con Gradle 1.5, la etiqueta manifest no fue reconocida dentro de la tarea fatJar, por lo que el atributo de clase principal no se pudo establecer directamente
2. el jar tenía archivos META-INF externos conflictivos.

La siguiente configuración resuelve esto

jar {
  manifest {
    attributes(
      ''Main-Class'': ''my.project.main'',
    )
  }
}

task fatJar(type: Jar) {
  manifest.from jar.manifest
  classifier = ''all''
  from {
    configurations.runtime.collect { it.isDirectory() ? it : zipTree(it) }
  } {
        exclude "META-INF/*.SF"
        exclude "META-INF/*.DSA"
        exclude "META-INF/*.RSA"
  }
  with jar
}

Para agregar esto a la tarea de ensamblaje o compilación estándar, agregue:

artifacts {
    archives fatJar
}

Answer 4

Para generar un JAR con una clase ejecutable principal, evitando problemas con los JAR firmados, sugiero el plugin de gradle-one-jar . Un simple complemento que utiliza el proyecto One-JAR .

Fácil de usar:

apply plugin: ''gradle-one-jar''

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath ''com.github.rholder:gradle-one-jar:1.0.4''
    }
}

task myjar(type: OneJar) {
    mainClass = ''com.benmccann.gradle.test.WebServer''
}

Answer 5

Publiqué una solución en JIRA contra Gradle:

// Include dependent libraries in archive.
mainClassName = "com.company.application.Main"

jar {
  manifest { 
    attributes "Main-Class": "$mainClassName"
  }  

  from {
    configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }
  }
}

Answer 6

Si desea que la tarea jar comporte normalmente y una tarea fatJar , use lo siguiente:

task fatJar(type: Jar) {
    classifier = ''all''
    from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
    with jar
}

La parte importante es with jar . Sin él, las clases de este proyecto no están incluidas.

Answer 7

Si estás acostumbrado a la hormiga, entonces podrías intentar lo mismo con Gradle:

task bundlemyjava{
    ant.jar(destfile: "build/cookmyjar.jar"){
        fileset(dir:"path to your source", includes:''**/*.class,*.class'', excludes:''if any'')
        } 
}

Answer 8

Simple sulution

jar {
    manifest {
        attributes ''Main-Class'': ''cova2.Main''
    } 
    doFirst {
        from { configurations.runtime.collect { it.isDirectory() ? it : zipTree(it) } }
    }
}