Jak dodać zależność lokalnego pliku .jar do pliku build.gradle?

Próbowałem więc dodać moją lokalną zależność pliku .jar do mojego pliku 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')
} 

I widać, że dodałem pliki .jar do folderu referencedLibraries tutaj: https://github.com/WalnutiQ/wAlnut/tree/version-2.3.1/referencedLibraries

Problem polega jednak na tym, że po uruchomieniu polecenia: gradle build w wierszu polecenia pojawia się następujący błąd:

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

Oto moje całe repozytorium: https://github.com/WalnutiQ/wAlnut/tree/version-2.3.1

Jeśli naprawdę musisz pobrać plik .jar z katalogu lokalnego,

Dodaj obok oceny modułu (nie pliku oceny aplikacji):

repositories {
   flatDir {
       dirs 'libs'
   }
}


dependencies {
   implementation name: 'gson-2.2.4'
}

Jednak będąc standardowym plikiem .jar w prawdziwym repozytorium maven, dlaczego tego nie spróbujesz?

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

Zgodnie z dokumentacją użyj ścieżki względnej dla lokalnej zależności jar w następujący sposób:

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

Możesz to również zrobić, co obejmowałoby wszystkie pliki JAR w lokalnym repozytorium. W ten sposób nie będziesz musiał tego określać za każdym razem.

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

Poniższe działa dla mnie:

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

Zobacz dokumentację Gradle .

Możesz spróbować ponownie użyć lokalnego repozytorium Maven dla Gradle:

• Zainstaluj słoik w lokalnym repozytorium Maven:

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

• Sprawdź, czy słoik jest zainstalowany w ~/.m2/lokalnym repozytorium Maven

• Włącz lokalne repozytorium Maven w swoim build.gradlepliku:

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

  • Teraz powinieneś mieć włączony jar do implementacji w swoim projekcie

Przyjęta odpowiedź jest dobra, jednak potrzebowałbym różnych konfiguracji bibliotek w mojej wieloprojektowej wersji Gradle, aby korzystać z tej samej biblioteki Java innej firmy.

Dodanie „ $ rootProject.projectDir ” do elementu ścieżki „ dir ” w moim zamknięciu „ allprojects ” oznaczało, że każdy podprojekt odwoływał się do tego samego katalogu „ libs ”, a nie wersji lokalnej dla tego podprojektu:

//gradle.build snippet
allprojects {
    ...

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

    ...
}

EDIT by Quizzie: zmieniono „$ {rootProject.projectDir}” na „$ rootProject.projectDir” (działa w najnowszej wersji Gradle).

Prostym sposobem na to jest

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

skompiluje wszystkie pliki .jar w katalogu libs w aplikacji.

Rozwiązanie dla osób korzystających z Kotlin DSL

Rozwiązania dodane do tej pory są świetne dla OP, ale nie można ich używać z DSL Kotlin bez uprzedniej ich tłumaczenia. Oto przykład, w jaki sposób dodałem lokalny plik .JAR do mojej kompilacji za pomocą DSL Kotlin:

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

Pamiętaj, że jeśli używasz systemu Windows, odwrotne ukośniki będą musiały być poprzedzone znakami ucieczki:

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

Pamiętaj też, że cudzysłowy muszą być podwójnymi, a nie pojedynczymi.

Edytuj na 2020 r .:

Aktualizacje stopni były przestarzałe compilei testCompilena rzecz implementationoraz testImplementation. Tak więc powyższy blok zależności wyglądałby tak dla bieżących wersji Gradle:

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

Nie mogłem uzyskać powyższej sugestii na https://stackoverflow.com/a/20956456/1019307 do pracy. To zadziałało dla mnie. W przypadku pliku secondstring-20030401.jarzapisanego w libs/katalogu w katalogu głównym projektu:

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'

Odpowiedź na to pytanie została już szczegółowo wyjaśniona. Nadal chcę dodać coś, co wydaje mi się bardzo zaskakujące:

Zadanie „gradle dependencies” nie wyświetla żadnych zależności plików. Nawet jeśli możesz tak myśleć, ponieważ zostały one określone w bloku „zależności”.

Więc nie polegaj na wynikach tego, aby sprawdzić, czy Twoje lokalne pliki lib działają poprawnie.

Rozwiązaniem, które działało dla mnie, jest użycie fileTree w pliku build.gradle. Zachowaj plik .jar, który należy dodać jako zależność w folderze libs. Podaj poniższy kod w bloku zależności w build.gradle:

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

Najlepszym sposobem na to jest dodanie tego do pliku build.gradle i wybranie opcji synchronizacji

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

Możesz dodać słoik robiąc:

Dla grad po prostu wstaw następujący kod build.gradle:

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

a dla maven wykonaj następujące kroki:

W przypadku Intellij: Plik-> struktura projektu-> moduły-> karta zależności-> kliknij + znak-> jar i zależność-> wybierz słoiki, które chcesz zaimportować-> ok-> zastosuj (jeśli jest widoczny) -> ok

Pamiętaj, że jeśli masz jakiś java.lang.NoClassDefFoundError: Could not initialize classwyjątek w czasie wykonywania, oznacza to, że zależności w słoiku niezainstalowane, musisz dodać wszystkie zależności w projekcie nadrzędnym.

Idź do pliku -> Struktura projektu -> Moduły -> aplikacja -> karta Zależności -> Kliknij + (przycisk) -> Wybierz zależność pliku -> Wybierz plik jar w folderze lib

Te kroki automatycznie dodadzą twoją zależność do gralde

Bardzo prosta

Zachowaj ostrożność, jeśli używasz ciągłej integracji, musisz dodać biblioteki w tej samej ścieżce na serwerze kompilacji.

Z tego powodu wolę dodać jar do lokalnego repozytorium i oczywiście zrobić to samo na serwerze kompilacji.

Inny sposób:

Dodaj bibliotekę w widoku drzewa. Kliknij ten przycisk prawym przyciskiem myszy. Wybierz menu „Dodaj jako bibliotekę”. Pojawi się okno dialogowe pozwalające wybrać moduł. OK i gotowe.