Comment ajouter une dépendance de fichier .jar local au fichier build.gradle?


608

J'ai donc essayé d'ajouter ma dépendance de fichier local .jar à mon fichier build.gradle:

apply plugin: 'java'

sourceSets {
    main {
        java {
            srcDir 'src/model'
        }
    }
}

dependencies {
    runtime files('libs/mnist-tools.jar', 'libs/gson-2.2.4.jar')
    runtime fileTree(dir: 'libs', include: '*.jar')
} 

Et vous pouvez voir que j'ai ajouté les fichiers .jar dans le dossier referencedLibraries ici: https://github.com/WalnutiQ/wAlnut/tree/version-2.3.1/referencedLibraries

Mais le problème est que lorsque j'exécute la commande: gradle build sur la ligne de commande, j'obtiens l'erreur suivante:

error: package com.google.gson does not exist
import com.google.gson.Gson;

Voici mon référentiel entier: https://github.com/WalnutiQ/wAlnut/tree/version-2.3.1


Êtes-vous sûr de l'exécution au lieu de la compilation? compiler des fichiers (....)
Gabriele Mariotti

3
il semble que ce soit une dépendance de compilation si jar ne peut pas être construit. essayez: compilez des fichiers ('libs / mnist-tools.jar', 'libs / gson-2.2.4.jar') si vous avez toujours un problème, essayez des chemins absolus car cela pourrait également être un problème.
patrz jaka franca

1
Cette question Stack Overflow m'a finalement donné la réponse dont j'avais besoin.
grue

Réponses:


456

Si vous avez vraiment besoin de prendre ce fichier .jar à partir d'un répertoire local,

Ajoutez à côté de votre gradle de module (pas le fichier de gradle de l'application):

repositories {
   flatDir {
       dirs 'libs'
   }
}


dependencies {
   implementation name: 'gson-2.2.4'
}

Cependant, étant un .jar standard dans un référentiel Maven réel, pourquoi n'essayez-vous pas cela?

repositories {
   mavenCentral()
}
dependencies {
   implementation 'com.google.code.gson:gson:2.2.4'
}

4
Je suis venu chercher exactement cela, mais j'ai trouvé que mon référentiel local ne résout pas les dépendances transitives. (Gradle 2.7, l'exemple POM est com.mojang: authlib: 1.5.21 extrait par minecraftforge.net)
Karl the Pagan

1
Si vous avez des fichiers jar locaux dans plusieurs répertoires, vous devez tous les ajouter au flatDir. Ex: - flatDir {dirs 'libs1', 'libs2', 'libs3'}
Dhumil Agarwal

9
J'ai un gradle.buildfichier - Qu'est-ce que ce "fichier Gradle d'application" et le "Gradle de module"?
Lealo

2
Y a-t-il une chance que quelqu'un mette à jour la réponse avec un lien vers la section de documentation officielle de Gradle décrivant ces fonctionnalités?
misanthrope

2
implementation(":gson:2.2.4")semble être le moyen de le faire.
Eng.Fouad

697

Selon la documentation , utilisez un chemin relatif pour une dépendance de jar locale comme suit:

dependencies {
    implementation files('libs/something_local.jar')
}

8
@Gubatron c'est documenté maintenant: gradle.org/docs/current/userguide/…
David Moles

7
je voulais juste ajouter que pour ceux qui utilisent des chemins relatifs vers notre pot: les dépendances {compilent les fichiers ("libs / something_local.jar"} (c'est-à-dire les guillemets doubles et non les guillemets simples) sont nécessaires à Groovy pour évaluer le chemin. citations sont prises littéralement Groovy.
specialk1st

Donc j'utilise la même chose et j'obtiens une erreur de compilation (on dirait qu'il ne trouve pas le pot là-bas.) Si je donne un chemin absolu, cela fonctionne bien.
RV_Dev

Je préférerais cette solution, mais j'ai trouvé que si le fichier n'existe pas, aucune erreur n'est produite par Gradle. Je l'ai trouvé personnellement, voir cette question SO pour plus de détails: stackoverflow.com/q/42527631/4851565
entpnerd

J'obtenais une erreur similaire même après avoir utilisé cette solution. Erreur j'ai mis le dossier libs sous des applications qui ne sont pas au même niveau que les applications
Rishabh Dugar

315

Vous pouvez également effectuer cette opération en incluant tous les fichiers JAR dans le référentiel local. De cette façon, vous n'auriez pas à le spécifier à chaque fois.

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
}

3
Ceci est utilisé pour compiler tous les fichiers JAR du répertoire lib. C'est la solution parfaite (y)
Sheraz Ahmad Khilji

1
... sauf si vous prévoyez de partager ce répertoire libs avec différents modules ayant différents ensembles de dépendances, comme ne pas mettre de code serveur avec du code client, ou avoir plus d'une version d'une dépendance dans un sous-module différent.
Ajax

Il s'agit de mon implémentation préférée par rapport à la réponse acceptée car elle indique explicitement l'emplacement des fichiers. Il est utile lorsque vous faites référence à un référentiel tel que mavenCentral pour certaines bibliothèques et des copies locales pour d'autres. Dans ce cas, il peut y avoir un décalage pendant que gradle recherche les bibliothèques locales dans les autres référentiels.
satbot

1
Notez que dir peut également être un chemin absolu. Aussi, au lieu de «inclure», j'ai dû utiliser «comprend».
eriel marimon

53

Ce qui suit fonctionne pour moi:

compile fileTree(dir: 'libs', include: '*.jar')

Reportez-vous à la documentation Gradle .


6
réponse brillante, la seule solution qui a fonctionné pour moi après avoir cherché pendant des jours
Stardust

il est important de se rappeler que c'est cette méthode si vous ne voulez pas qu'une bibliothèque spécifique soit compilée avec votre projet, vous devrez vous rappeler de la supprimer du dossier libs ... je n'aime pas cette méthode car je ne vois pas quelle bibliothèque je ajouté sauf si j'entre dans la bibliothèque
Jesus Dimrix

1
En quoi est-ce différent de la réponse de @ Nightwolf?
Trenton

2
Impossible de trouver la méthode compile () pour les arguments [répertoire 'libs'] sur l'objet de type org.gradle.api.internal.artifacts.dsl.dependencies.DefaultDependencyHandler
ieXcept

33

Vous pouvez essayer de réutiliser votre référentiel Maven local pour Gradle:

  • Installez le bocal dans votre référentiel Maven local:

    mvn install:install-file -Dfile=utility.jar -DgroupId=com.company -DartifactId=utility -Dversion=0.0.1 -Dpackaging=jar

  • Vérifiez que le fichier jar est installé dans votre ~/.m2/référentiel Maven local

  • Activez votre référentiel Maven local dans votre build.gradlefichier:

    repositories {
      mavenCentral()  
      mavenLocal()  
    }
    
    dependencies {  
      implementation ("com.company:utility:0.0.1")  
    }
    • Maintenant, vous devriez avoir le pot activé pour l'implémentation dans votre projet

Celui-ci m'a aidé quand tout le reste a échoué!
User3

Bien que cela fonctionne, il s'agit d'un contournement et ne doit pas être utilisé dans un environnement de production / étape automatisé car cela ajoute une dépendance supplémentaire d'avoir un dossier .m2 (installation maven) dans le système de génération.
saurav.varma

29

La réponse acceptée est bonne, cependant, j'aurais eu besoin de diverses configurations de bibliothèque dans ma génération Gradle multi-projet pour utiliser la même bibliothèque Java tierce.

L'ajout de « $ rootProject.projectDir » à l' élément de chemin « dir » dans ma fermeture « allprojects » signifiait que chaque sous-projet faisait référence au même répertoire « libs », et non à une version locale de ce sous-projet:

//gradle.build snippet
allprojects {
    ...

    repositories {
        //All sub-projects will now refer to the same 'libs' directory
        flatDir {
            dirs "$rootProject.projectDir/libs"
        }
        mavenCentral()
    }

    ...
}

EDIT par Quizzie: changé "$ {rootProject.projectDir}" en "$ rootProject.projectDir" (fonctionne dans la dernière version de Gradle).


2
mais comment faire référence à ce dossier libs dans le fichier build.gradle de la bibliothèque? Toute aide à ce sujet.
jeevs

1
Changez simplement "$ {rootProject.projectDir}" en "$ rootProject.projectDir" pour le faire fonctionner à nouveau.
Quizzie

4
Assurez-vous d'utiliser des guillemets doubles plutôt que des guillemets simples car ces derniers ne seront pas interpolés.
FP Freely

1
Cette approche m'a aidé.
Shreyash

1
Toutes les réponses ici m'ont beaucoup aidé. Ce modèle est celui que nous utilisons et il permet aux personnes travaillant en équipe de simplement déposer des fichiers JAR dans ce répertoire lorsqu'ils travaillent sur des succursales.
Lucy

13

Une solution pour ceux qui utilisent Kotlin DSL

Les solutions ajoutées jusqu'à présent sont excellentes pour l'OP, mais ne peuvent pas être utilisées avec Kotlin DSL sans les avoir d'abord traduites. Voici un exemple de la façon dont j'ai ajouté un .JAR local à ma génération à l'aide de Kotlin DSL:

dependencies {
    compile(files("/path/to/file.jar"))
    testCompile(files("/path/to/file.jar"))
    testCompile("junit", "junit", "4.12")
}

N'oubliez pas que si vous utilisez Windows, vos barres obliques inverses devront être échappées:

...
compile(files("C:\\path\\to\\file.jar"))
...

N'oubliez pas non plus que les guillemets doivent être des guillemets doubles et non des guillemets simples.


Modifier pour 2020:

Les mises à jour de Gradle sont obsolètes compileet testCompileen faveur de implementationet testImplementation. Ainsi, le bloc de dépendance ci-dessus ressemblerait à ceci pour les versions actuelles de Gradle:

dependencies {
    implementation(files("/path/to/file.jar"))
    testImplementation(files("/path/to/file.jar"))
    testImplementation("junit", "junit", "4.12")
}

1
+1 a fonctionné pour moi! Savez-vous comment faire de même sans avoir à produire le fichier jar (au cas où je produirais le jar)?
Kareem Jeiroudi

2
@KareemJeiroudi Je peux mal comprendre votre question, mais si vous parlez de faire d'un module une dépendance du projet, vous feriez quelque chose comme ceci compile(project(":MyProject")):, où "MyProject" est défini dans votre settings.gradlefichier avec quelque chose comme include("MyProject").
Jonathan Landrum

12

Un moyen simple de le faire est

compile fileTree(include: ['*.jar'], dir: 'libs')

il compilera tous les fichiers .jar dans votre répertoire libs dans l'application.


Est-ce que fileTree fonctionne pour tous les sous-répertoires du dossier libs. Exemple de quelques jars à l'intérieur du libs / sping / spring.jar, dans ce cas inclut-il également le printemps .jar?
mgr

Non, non. Techniquement, cela ne devrait pas aussi bien, car nous donnons le 'dir: libs' et non les sous-répertoires des libs.
ZygoteInit

Dans ce cas, comment obtenir toutes les bibliothèques des sous-répertoires avec des tâches minimales (car notre projet contient tellement de sous-répertoires.
mgr

Hé @mallikgm désolé pour la réponse tardive, avez-vous essayé d'ajouter un caractère générique dans le chemin dir comme compile fileTree (inclure: [' .jar'], dir: 'libs ')
ZygoteInit

2
En quoi est-ce différent de la réponse de @ Nightwolf?
Trenton

8

Je n'ai pas pu faire fonctionner la suggestion ci-dessus sur https://stackoverflow.com/a/20956456/1019307 . Cela a fonctionné pour moi cependant. Pour un fichier secondstring-20030401.jarque j'ai stocké dans un libs/répertoire à la racine du projet:

repositories {
    mavenCentral()
    // Not everything is available in a Maven/Gradle repository.  Use a local 'libs/' directory for these.
    flatDir {
       dirs 'libs'
   }
}

...

compile name: 'secondstring-20030401'

Merci! Je ne sais pas pourquoi, mais cela a fonctionné pour moi. créé un dossier «libs» à la racine de mon projet, inséré le .jar dedans et copié votre entrée «nom de compilation». Bien sûr, l'extension .jar a également été supprimée.
anon58192932

Non, cela ne me fonctionne pas Impossible de trouver: miglayout-core :. Recherche dans les emplacements suivants: fichier: /user/path/to/miglayout-core.jar
Well Smith

ce travail si vous souhaitez ajouter un répertoire de fichiers comme référentiel: docs.gradle.org/current/userguide/…
Grubhart

7

La question a déjà reçu une réponse détaillée. Je veux encore ajouter quelque chose qui me semble très surprenant:

La tâche "dépendances gradle" ne répertorie aucune dépendance de fichier. Même si vous pourriez le penser, car ils ont été spécifiés dans le bloc "dépendances" après tout.

Ne vous fiez donc pas à la sortie de ceci pour vérifier si vos fichiers lib locaux référencés fonctionnent correctement.


6

La solution qui a fonctionné pour moi est l'utilisation de fileTree dans le fichier build.gradle. Conservez le .jar qui doit être ajouté comme dépendance dans le dossier libs. Donnez le code ci-dessous dans le bloc dependenices dans build.gradle:

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
}

5

La meilleure façon de le faire est d'ajouter ceci dans votre fichier build.gradle et de cliquer sur l'option de synchronisation

dependency{
    compile files('path.jar')
}

3

Vous pouvez ajouter un pot en faisant:

Pour gradle, entrez simplement le code suivant build.gradle:

dependencies {
...
compile fileTree(dir: 'lib', includes: ['suitetalk-*0.jar'])
...
}

et pour maven il suffit de suivre les étapes:

Pour Intellij: Fichier-> structure du projet-> modules-> onglet dépendance-> cliquez sur + signe-> pot et dépendance-> sélectionnez les pots que vous souhaitez importer-> ok-> appliquer (si visible) -> ok

N'oubliez pas que si vous avez une java.lang.NoClassDefFoundError: Could not initialize classexception au moment de l'exécution, cela signifie que les dépendances dans jar ne sont pas installées pour cela, vous devez ajouter toutes les dépendances dans le projet parent.


0

Goto File -> Project Structure -> Modules -> app -> Dependencies Tab -> Click on + (button) -> Select File Dependency -> Select jar file in the lib folder

Cette étape ajoutera automatiquement votre dépendance à gralde

Très simple


3
Est-ce un chemin à travers certains menus Java IDE? Probablement une idée?
Utgarda

1
Oui, cela ressemble à quelque chose pour IntelliJ IDEA, et je ne pense pas que cela fonctionnera. Ou, il semblera que cela fonctionne jusqu'à ce qu'une modification soit apportée à la configuration de Gradle qui se traduise par une "synchronisation", et la synchronisation est à sens unique de Gradle vers les paramètres IntelliJ. Il ne se synchronise pas dans l'autre sens - du moins je ne le pense pas.
RenniePet

1
Si vous avez sélectionné l'importation automatique, le .JAR importé manuellement sera supprimé lors de la prochaine modification en build.gradle.
Jonathan Landrum

-1

Soyez prudent si vous utilisez l'intégration continue, vous devez ajouter vos bibliothèques dans le même chemin sur votre serveur de build.

Pour cette raison, je préfère ajouter du jar au référentiel local et, bien sûr, faire de même sur le serveur de build.


-3

Autrement:

Ajoutez une bibliothèque dans l'arborescence. Faites un clic droit sur celui-ci. Sélectionnez le menu "Ajouter en tant que bibliothèque". Une boîte de dialogue apparaît, vous permettant de sélectionner le module. OK et c'est fait.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.