gradle - comment puis-je construire un pot avec un répertoire lib avec d'autres pots dedans?

Question

Dans gradle - comment puis-je intégrer des jars à l'intérieur de mon jar de sortie de construction dans le répertoire lib (plus précisément lib/enttoolkit.jar et lib/mail.jar)?

Answer 1

Lifted mot pour mot: http://docs.codehaus.org/display/GRADLE/Cookbook#Cookbook-Creatingafatjar

Gradle 0,9:

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

Gradle 0,8:

jar.doFirst { 
    for(file in configurations.compile) { 
     jar.merge(file) 
    } 
} 

Les extraits ci-dessus ne comprennent que la compilation des dépendances pour ce projet, pas d'exécution transitive dépendances. Si vous souhaitez également les fusionner, remplacez le fichier configurations.compile par le fichier configurations.runtime.

EDIT: seulement le choix des bocaux dont vous avez besoin

Faire une nouvelle configuration, releaseJars peut-être

configurations { 
    releaseJars 
} 

Ajouter les pots que vous voulez que la configuration

dependencies { 
    releaseJars group: 'javax.mail', name: 'mail', version: '1.4' 
    //etc 
} 

utilisez cette configuration dans la tâche de pot décrite ci-dessus.

Answer 2

J'avais besoin de la même chose que vous avez demandé, et utilisé cette méthode. vous n'avez peut-être pas besoin d'une déclaration de configuration personnalisée, mais j'ai dû séparer les fichiers jar utilisés localement de ceux déclarés dans un fichier super-build.

configurations{ 
    //declare custom config if necessary, otherwise just use compile 
    myLibs 
} 
dependencies { 
    //add lib/*.jar files to myLibs 
    myLibs fileTree(dir: 'lib', include: '*.jar') 
    compile { 
     //set compile configuration to extend from myLibs 
     extendsFrom myLibs 
    } 
} 
// task to copy libs to output/lib dir 
task copyToLib(type: Copy) { 
    into "$buildDir/output/lib" 
    from configurations.myLibs 
} 

jar { 
    //include contents of output dir 
    from "$buildDir/output" 
    manifest { 
     //... 
    } 
} 

//set build task to depend on copyToLib 
build.dependsOn(copyToLib) 

Answer 3

Si vous avez tous les pots dans un répertoire (permet de l'appeler libs) dans votre projet, il vous suffit ceci:

jar { 
    into('lib') { 
     from 'libs' 
    } 
} 

Je suppose qu'il est plus probable que ces pots sont des dépendances de une sorte. Ensuite, vous pouvez le faire comme ceci:

configurations { 
    // configuration that holds jars to copy into lib 
    extraLibs 
} 
dependencies { 
    extraLibs 'org.something:something-dep1:version' 
    extraLibs 'org.something:something-dep2:version' 
} 

jar { 
    into('lib') { 
     from configurations.extraLibs 
    } 
} 

Answer 4

aussi je devais faire quelque chose de similaire et n'a pas été tout à fait en mesure d'obtenir ce que Guus et stigkj a suggéré de travailler, mais se sont assez proches avec leur aide pour obtenir ce travail (Guus 'exemple a explosé sur la

apply plugin: 'groovy' 

repositories { 
    mavenCentral() 
} 

configurations { 
    // custom config of files we want to include in our fat jar that we send to hadoop 
    includeInJar 
} 

dependencies { 
    includeInJar 'org.codehaus.groovy:groovy:1.8.6' 

    configurations.compile.extendsFrom(configurations.includeInJar) 
} 

jar { 
    into('lib') { 
     println "includeInJar: " + configurations.includeInJar.collect { File file -> file } 
     from configurations.includeInJar 
    } 

} 

fermeture dependencies { compile { extendsFrom myLibs }} pour moi. Puis, en cours d'exécution gradle jar et en examinant le pot créé me donne cette sortie, montrant que j'obtenir le fichier jar d'avoir groovy, ainsi que tous les pots que c'est dépendant à l'intérieur du "gros pot":

% gradle jar                               
includeInJar: [/Users/tnaleid/.gradle/caches/artifacts-8/filestore/org.codehaus.groovy/groovy/1.8.6/jar/553ca93e0407c94c89b058c482a404427ac7fc72/groovy-1.8.6.jar, /Users/tnaleid/.gradle/caches/artifacts-8/filestore/antlr/antlr/2.7.7/jar/83cd2cd674a217ade95a4bb83a8a14f351f48bd0/antlr-2.7.7.jar, /Users/tnaleid/.gradle/caches/artifacts-8/filestore/asm/asm/3.2/jar/9bc1511dec6adf302991ced13303e4140fdf9ab7/asm-3.2.jar, /Users/tnaleid/.gradle/caches/artifacts-8/filestore/asm/asm-tree/3.2/jar/cd792e29c79d170c5d0bdd05adf5807cf6875c90/asm-tree-3.2.jar, /Users/tnaleid/.gradle/caches/artifacts-8/filestore/asm/asm-commons/3.2/jar/e7a19b8c60589499e35f5d2068d09013030b8891/asm-commons-3.2.jar, /Users/tnaleid/.gradle/caches/artifacts-8/filestore/asm/asm-util/3.2/jar/37ebfdad34d5f1f45109981465f311bbfbe82dcf/asm-util-3.2.jar, /Users/tnaleid/.gradle/caches/artifacts-8/filestore/asm/asm-analysis/3.2/jar/c624956db93975b7197699dcd7de6145ca7cf2c8/asm-analysis-3.2.jar] 
:compileJava UP-TO-DATE 
:compileGroovy UP-TO-DATE 
:processResources UP-TO-DATE 
:classes UP-TO-DATE 
:jar 

BUILD SUCCESSFUL 

Total time: 3.387 secs 

% jar tvf build/libs/gradletest.jar                         
    0 Mon Mar 12 11:40:00 CDT 2012 META-INF/ 
    25 Mon Mar 12 11:40:00 CDT 2012 META-INF/MANIFEST.MF 
    0 Mon Mar 12 11:40:00 CDT 2012 lib/ 
5546084 Mon Mar 05 13:13:32 CST 2012 lib/groovy-1.8.6.jar 
445288 Mon Mar 05 13:13:38 CST 2012 lib/antlr-2.7.7.jar 
43398 Mon Mar 05 13:13:40 CST 2012 lib/asm-3.2.jar 
21878 Mon Mar 05 13:13:40 CST 2012 lib/asm-tree-3.2.jar 
33094 Mon Mar 05 13:13:40 CST 2012 lib/asm-commons-3.2.jar 
36551 Mon Mar 05 13:13:40 CST 2012 lib/asm-util-3.2.jar 
17985 Mon Mar 05 13:13:40 CST 2012 lib/asm-analysis-3.2.jar 

Answer 5

simple:

task copyToLib(type: Copy) { 
    into "$buildDir/libs/lib" 
    from configurations.runtime 
} 

jar { dependsOn copyToLib } 

terme, il:

$ gradle jar 
... 
$ tree build/libs 

build/libs 
├── your-project-0.0.1.BUILD-SNAPSHOT.jar 
└── lib 
    ├── akka-actor-2.0.jar 
    ├── akka-camel-2.0.jar 
    ├── ... ... ... 
    ├── spring-expression-3.1.0.RELEASE.jar 
    └── zmq-2.1.9.jar 

1 directory, 46 files 

Answer 6

Ci-dessous le code pourrait être jugé.Cela dépend de la tâche jar et est de type Jar

task createJobJar(dependsOn:jar,type:Jar) { 
    manifest { 
     attributes(
       "Implementation-Title": 'Job ' 
       ,"Implementation-Version": version 
     ) 
    } 
    classifier 'job' 
    destinationDir new File("$buildDir") 
    into('libs'){ 
     from configurations.compile 
    } 
    into('classes'){ 
     from "$buildDir/classes" 
    } 
    into('resources'){ 
     from "$projectDir/src/main/resources" 
    } 
    into('scripts'){ 
     from "$projectDir/src/main/scripts" 
    } 
} 

Le code ci-dessus contient un contenu différent dans différents répertoires. Testé sur la gradation 2.2

Answer 7

Dans mon cas, j'avais besoin d'inclure un contenu du projet racine Jar dans le sous-projet Jar. Donc, pour le faire fonctionner, on peut utiliser ce modèle:

jar{ 
    manifest{ 
    attributes 'Main-Class':'<main class>' 
    } 
    def conf= configurations.find {it.name.equals('compile') } 
    File jar= conf.files.find {it.name.contains('<name or part of the name of produced Jar>')} 

    FileTree fileTree=zipTree(jar) 
    from fileTree 
} 

Mon exemple:

jar{ 
    manifest{ 
     attributes 'Main-Class':'alexiy.jace.Jace' 
    } 
    description='Make a runnable API Jar' 
    def conf= configurations.find {it.name.equals('compile') } 
    File tools= conf.files.find {it.name.contains('Tools')} 

    FileTree fileTree=zipTree(tools) 
    from fileTree 
} 

Answer 8

task <taskname>(type: Jar) { 
    archiveName 'nameofjar.jar' 
    doFirst { 
    manifest { 
      attributes 'Class-Path': configurations.compile.files.collect{ project.uri(it) }.join(' ') 
     } 
    } 
}