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

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

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

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

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

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

Ce qui suit fonctionne pour moi:

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

Reportez-vous à la documentation Gradle .

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

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).

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")
}

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.

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'

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.

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

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

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.

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

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.

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.