Come aggiungere la dipendenza di file .jar locale al file build.gradle?

Quindi ho provato ad aggiungere la mia dipendenza di file .jar locale al mio file 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')
} 

E puoi vedere che ho aggiunto i file .jar nella cartella ReferencedLibraries qui: https://github.com/WalnutiQ/wAlnut/tree/version-2.3.1/referencedLibraries

Ma il problema è che quando eseguo il comando: gradle build sulla riga di comando ottengo il seguente errore:

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

Ecco il mio intero repository: https://github.com/WalnutiQ/wAlnut/tree/version-2.3.1

Se hai davvero bisogno di prendere quel .jar da una directory locale,

Aggiungi accanto al tuo modulo gradle (non il file gradle app):

repositories {
   flatDir {
       dirs 'libs'
   }
}


dependencies {
   implementation name: 'gson-2.2.4'
}

Tuttavia, essendo un file .jar standard in un vero repository maven, perché non provi questo?

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

Secondo la documentazione , utilizzare un percorso relativo per una dipendenza jar locale come segue:

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

Si potrebbe anche fare questo che includerebbe tutti i JAR nel repository locale. In questo modo non dovresti specificarlo ogni volta.

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

Per me funziona quanto segue:

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

Fare riferimento alla documentazione del grado .

Puoi provare a riutilizzare il tuo repository Maven locale per Gradle:

• Installa il vaso nel tuo repository Maven locale:

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

• Verifica di avere il jar installato nel tuo ~/.m2/repository Maven locale

• Abilita il tuo repository Maven locale nel tuo build.gradlefile:

  repositories {
    mavenCentral()  
    mavenLocal()  
  }
  
  dependencies {  
    implementation ("com.company:utility:0.0.1")  
  }

  • Ora dovresti avere il vaso abilitato per l'implementazione nel tuo progetto

La risposta accettata è buona, tuttavia, avrei bisogno di varie configurazioni di libreria all'interno della mia build Gradle multi-progetto per utilizzare la stessa libreria Java di terze parti.

Aggiunta di ' $ rootProject.projectDir ' all'elemento percorso ' dir ' all'interno di my ' chiusura allprojects ' significava che ogni sottoprogetto faceva riferimento alla stessa directory ' libs ' e non una versione locale per quel sottoprogetto:

//gradle.build snippet
allprojects {
    ...

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

    ...
}

EDIT di Quizzie: modificato "$ {rootProject.projectDir}" in "$ rootProject.projectDir" (funziona nella versione Gradle più recente).

Una soluzione per chi utilizza Kotlin DSL

Le soluzioni aggiunte finora sono ottime per l'OP, ma non possono essere utilizzate con Kotlin DSL senza prima tradurle. Ecco un esempio di come ho aggiunto un .JAR locale alla mia build usando Kotlin DSL:

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

Ricorda che se stai usando Windows, le barre rovesciate dovranno essere sfuggite:

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

E ricorda anche che le virgolette devono essere virgolette doppie, non virgolette singole.

Modifica per il 2020:

Gli aggiornamenti di Gradle sono deprecati compilee testCompilein favore di implementatione testImplementation. Quindi il blocco delle dipendenze sopra sarebbe simile a questo per le versioni Gradle attuali:

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

Un modo semplice per farlo è

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

compilerà tutti i file .jar nella directory libs in App.

Non ho potuto ottenere il suggerimento sopra su https://stackoverflow.com/a/20956456/1019307 per funzionare. Questo ha funzionato per me però. Per un file secondstring-20030401.jarche ho archiviato in una libs/directory nella radice del progetto:

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'

Alla domanda è già stata data una risposta dettagliata. Voglio ancora aggiungere qualcosa che mi sembra molto sorprendente:

L'attività "Dipendenze graduali" non elenca dipendenze di file. Anche se potresti pensarlo, dato che dopo tutto sono stati specificati nel blocco "dipendenze".

Quindi non fare affidamento sull'output di questo per verificare se i file lib locali referenziati funzionano correttamente.

La soluzione che ha funzionato per me è l'uso di fileTree nel file build.gradle. Mantenere il file .jar che deve essere aggiunto come dipendenza nella cartella libs. Dare il seguente codice nel blocco dependenices in build.gradle:

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

Il modo migliore per farlo è aggiungerlo nel file build.gradle e premere l'opzione di sincronizzazione

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

Puoi aggiungere jar facendo:

Per il gradle basta inserire il seguente codice build.gradle:

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

e per Maven basta seguire i passaggi:

Per Intellij: File-> struttura del progetto-> moduli-> scheda dipendenza-> fai clic su + segno-> vaso e dipendenza-> seleziona i vasetti che vuoi importare-> ok-> applica (se visibile) -> ok

Ricorda che se hai java.lang.NoClassDefFoundError: Could not initialize classun'eccezione in fase di runtime ciò significa che le dipendenze nel vaso non sono installate per questo devi aggiungere tutte le dipendenze nel progetto padre.

Vai a File -> Struttura del progetto -> Moduli -> app -> Scheda Dipendenze -> Fai clic su + (pulsante) -> Seleziona dipendenza file -> Seleziona file jar nella cartella lib

Questo passaggio aggiungerà automaticamente la tua dipendenza a gralde

Molto semplice

Fai attenzione se stai utilizzando l'integrazione continua, devi aggiungere le tue librerie nello stesso percorso sul tuo server di compilazione.

Per questo motivo, preferirei aggiungere jar al repository locale e, naturalmente, fare lo stesso sul server di compilazione.

Un altro modo:

Aggiungi libreria nella vista ad albero. Fai clic destro su questo. Seleziona il menu "Aggiungi come libreria". Viene visualizzata una finestra di dialogo che consente di selezionare il modulo. OK ed è fatto.