Jak zmusić gradle do ponownego pobierania zależności?

Jak mogę powiedzieć stopniowi, aby ponownie pobierał zależności z repozytoriów?

Zasadniczo można odświeżyć zależności w pamięci podręcznej za pomocą opcji wiersza polecenia --refresh-dependencies . Możesz również usunąć buforowane pliki w obszarze ~/.gradle/caches. Przy następnej kompilacji Gradle będzie próbował pobrać je ponownie.

Jaki jest twój konkretny przypadek użycia? Czy korzystasz z wersji dynamicznej zależności lub wersji SNAPSHOT?

W systemach uniksowych możesz usunąć wszystkie istniejące artefakty (artefakty i metadane), które Gradle pobrał, używając:

rm -rf $HOME/.gradle/caches/

Jeśli używasz najnowszej wersji Gradle, możesz użyć opcji --refresh-dependencies.

./gradlew build --refresh-dependencies

możesz zapoznać się z instrukcją Gradle .

Opcja --refresh-dependencies informuje Gradle, aby zignorował wszystkie wpisy w pamięci podręcznej dla rozwiązanych modułów i artefaktów. Nowe rozwiązanie zostanie wykonane dla wszystkich skonfigurowanych repozytoriów, z ponownie obliczonymi wersjami dynamicznymi, odświeżonymi modułami i pobranymi artefaktami.

Możesz powiedzieć Gradle'owi, aby ponownie pobrał niektóre zależności ze skryptu kompilacji, oznaczając zależność jako „zmieniającą się”. Następnie Gradle będzie sprawdzać dostępność aktualizacji co 24 godziny, ale można to skonfigurować za pomocą rozdzielczości DSL strategii. Uważam, że przydatne jest użycie tego do kompilacji SNAPSHOT lub NIGHTLY.

configurations.all {
    // Check for updates every build
    resolutionStrategy.cacheChangingModulesFor 0, 'seconds'
}

Rozszerzony:

dependencies {
    implementation group: "group", name: "projectA", version: "1.1-SNAPSHOT", changing: true
}

Skondensowany:

implementation('group:projectA:1.1-SNAPSHOT') { changing = true }

Znalazłem to rozwiązanie w tym wątku na forum .

Dla Maca

./gradlew build --refresh-dependencies

Dla Windowsa

gradlew build --refresh-dependencies

Można także spróbować gradlew assembleDevelopmentDebug --refresh-dependencies

W przypadku systemu Windows ... aby umożliwić stopniowe pobieranie określonych zależności:

1. usuń zależności, które chcesz ponownie pobrać z katalogu poniżej:

   C:\Users\%USERNAME%\.gradle\caches\modules-2\files-2.1
   

2. usuń wszystkie katalogi metadanych ze ścieżki:

   C:\Users\%USERNAME%\.gradle\caches\modules-2\metadata-*
   

3. uruchom gradle build(lub gradlew buildjeśli używasz otoki stopni) w katalogu głównym projektu.

Uwaga: liczby w powyższych ścieżkach plików mogą być różne dla Ciebie.

Można usunąć folder z buforowanymi słoikami.

W moim przypadku na Macu biblioteka była buforowana na ścieżce:

/Users/MY_NAME/.gradle/caches/modules-2/files-2.1/cached-library-to-remove

Usunąłem buforowany folder biblioteki (w powyższym przykładzie „cached-library-to-remove”), usunąłem folder kompilacji mojego projektu i ponownie skompilowałem. Pobrano wtedy świeżą bibliotekę.

Zamiast usuwać całą pamięć podręczną stopni, jak sugerują niektóre odpowiedzi tutaj, możesz usunąć pamięć podręczną dla określonej grupy lub identyfikatora artefaktu. Dodałem następującą funkcję do mojego .bash_profile:

deleteGradleCache() {
  local id=$1
  if [ -z "$id" ]; then
    echo "Please provide an group or artifact id to delete"
    return 1
  fi
  find ~/.gradle/caches/ -type d -name "$id" -prune -exec rm -rf "{}" \; -print
}

Stosowanie:

$ deleteGradleCache com.android.support

Następnie przy następnej kompilacji lub po ponownej synchronizacji gradle ponownie pobierze zależności.

Można to zrobić na 2 sposoby:

1. Korzystanie z opcji wiersza polecenia do odświeżania cashe zależności.
2. Możesz usunąć lokalną pamięć podręczną, w której artefasty są buforami według Gradle i uruchomić kompilację

Korzystanie z opcji --refresh-dependencies :

./gradlew build --refresh-dependencies

Krótkie wyjaśnienie - opcja odświeżania-zależności informuje Gradle o ignorowaniu wszystkich zapisanych w pamięci podręcznej pozycji dla rozwiązanych modułów i artefaktów.

Długie wyjaśnienie

• Z Gradle-zależności-odświeżania zawsze trafi na serwer zdalny, aby sprawdzić zaktualizowane artefakty: jednak Gradle uniknie pobrania pliku, w którym ten sam plik już istnieje w pamięci podręcznej.
  • Pierwszy stopień wykona żądanie HEAD i sprawdzi, czy serwer zgłasza plik jako niezmieniony od ostatniego razu (czy „długość treści” i „ostatnia modyfikacja” nie uległy zmianie). W takim przypadku pojawi się komunikat: „Zasób buforowany jest aktualny (lastModified: {})”.
  • Następny Gradle określi zdalną sumę kontrolną, jeśli to możliwe (na podstawie żądania HEAD lub pobierając plik „.sha1”). Jeśli ta suma kontrolna pasuje do innego pliku już pobranego (z dowolnego repozytorium), to Gradle po prostu skopiuje plik do pamięć podręczna zamiast ponownego pobierania. W takim przypadku pojawi się komunikat: „„ Znaleziono lokalnie dostępny zasób z pasującą sumą kontrolną: [{}, {}] ”.

Korzystanie z funkcji usuwania: po usunięciu pamięci podręcznej

rm -rf $HOME/.gradle/caches/

Po prostu czyścisz wszystkie zbuforowane słoiki i sumy sha1, a Gradle znajduje się w sytuacji, gdy nie ma żadnych artefaktów na twoim komputerze i musi pobrać wszystko. Tak, po raz pierwszy będzie działał w 100%, ale kiedy zostanie wydany kolejny SNAPSHOT i będzie on częścią twojego drzewa zależności, znów staniesz przed wyborem odświeżenia lub wyczyszczenia pamięci podręcznej.

To zadziałało dla mnie. Upewnij się, że Gradle nie jest ustawiony na offline, usuwając zaznaczenie przycisku w Plik> Ustawienia> Gradle> Praca offline.

Dodaj to do najwyższego poziomu swojego build.gradle, miło mieć powyższe zależności

configurations.all {
    resolutionStrategy.cacheChangingModulesFor 0, 'seconds'
}

Upewniłem się, że moje zależności są zapisane w następujący sposób:

implementation('com.github.juanmendez:ThatDependency:ThatBranch-SNAPSHOT') {
    changing = true
}

Następnie otwieram panel Gradle w Android Studio i klikam przycisk ze strzałkami w niebieskim kółku. Zawsze widzę, że moje aktualizacje otrzymują nową świeżą kopię.

Żadne z powyższych rozwiązań nie działało dla mnie.

Jeśli używasz IntelliJ, dla mnie to rozwiązało po prostu odświeżenie wszystkich projektów Gradle:

Dla tych, którzy zastanawiają się, gdzie uruchamiać polecenia gradle:

1. Otwórz Android Studio
2. Kliknij Terminal (znajdziesz go w bazie Android Studio)
3. Narzędzie polecenia otworzy się
4. Wpisz swoje polecenie gradlew build --refresh-dependencies

Dla Androida Studio 3.4.1

Wystarczy otworzyć kartę oceny (może znajdować się po prawej stronie) i kliknąć prawym przyciskiem myszy element nadrzędny na liście (powinien mieć nazwę „Android”), a następnie wybrać opcję „Odśwież zależności”.

To powinno rozwiązać problem.

Mb Spóźniłem się, ale moje rozwiązanie dotyczy pojedynczego repozytorium. Myślę, że usunięcie ~ / .gradle / * to przesada. Problem, na który wpadłem, polegał na tym, że usuwałem katalog, w którym znajdowały się źródła, a gradle uzyskiwał inną wersję nie od nexusa. Aby tego uniknąć, uruchamiam następną:

~/.gradle$ find . -type d -name 'group.plugins.awssdk'
./caches/modules-2/files-2.1/group.plugins.awssdk
./caches/modules-2/metadata-2.23/descriptors/group.plugins.awssdk

~/.gradle$ rm -r ./caches/modules-2/files-2.1/group.plugins.awssdk   ./caches/modules-2/metadata-2.23/descriptors/group.plugins.awssdk

Po tym gradie przeciąganie plików z Nexusa.

Aby odświeżyć wersję „wydania” z pamięci podręcznej, jedyną opcją jest wyczyszczenie lokalnej pamięci podręcznej.

rm -rf $HOME/.gradle/caches/

Aby odświeżyć buforowaną wersję „migawki” możesz:

./gradlew build --refresh-dependencies

Usunięcie wszystkich pamięci podręcznych powoduje ponowne pobranie wszystkich zależności. więc zajmuje to dużo czasu i jest to nudne, poczekaj jeszcze raz, aby ponownie pobrać wszystkie zależności.

Jak jednak mogłem rozwiązać ten problem poniżej.

Po prostu usuń grupy, które wymagają odświeżenia.

Np .: jeśli chcemy odświeżyć grupę com.user.test

rm -fr ~/.gradle/caches/modules-2/files-2.1/com.user.test/

następnie usuń zależność z build.gradle i dodaj ją ponownie. wtedy odświeży zależności, czego chcemy.

Myślę, że problem z wersją 2.14.1 rozwiązuje ten problem. Przyjęta odpowiedź jest poprawna, ale występuje błąd w gradiencie z zależnościami -refresh. 2.14.1 to naprawia.

Zobacz https://discuss.gradle.org/t/refresh-dependencies-should-use-cachechangingmodulesfor-0s/556

usuń ten katalog:

C:\Users\[username]\.gradle

W większości przypadków wystarczy po prostu przebudować projekt. Czasami musisz uruchomić, ./gradlew build --refresh-dependenciesponieważ wspomniano już kilka odpowiedzi (zajmuje to dużo czasu, w zależności od tego, ile masz zależności). Czasem jednak żadna z nich nie zadziała: zależność po prostu nie zostanie zaktualizowana. Następnie możesz to zrobić:

1. Usuń zależność z pliku ocen
2. Uruchom / debuguj swój projekt i poczekaj, aż zakończy się niepowodzeniem (z NonExistingClasspodaniem przyczyny)
3. Kliknij „buduj projekt” i poczekaj, aż zakończy się powodzeniem
4. Uruchom / debuguj jeszcze raz

Jest to śmieszne i wydaje się szaleństwem, ale faktycznie używam tej procedury codziennie, po prostu dlatego, że zależność, której potrzebuję, można aktualizować dziesiątki razy i żadne odpowiednie rozwiązanie nie przyniesie żadnego efektu.

Możesz to zrobić w ten sposób

https://marschall.github.io/2017/04/17/disabling-gradle-cache.html

Cytat z Wyłączanie pamięci podręcznej kompilacji Gradle

Pamięć podręczna kompilacji Gradle może być świetną rzeczą, gdy regularnie budujesz> duże projekty za pomocą Gradle. Jednak tylko od czasu do czasu budując> projekty typu open source, może szybko stać się duży.

Aby wyłączyć pamięć podręczną kompilacji Gradle, dodaj następujący wiersz do ~/.gradle/gradle.properties

org.gradle.caching=false

Możesz wyczyścić istniejącą pamięć podręczną za pomocą

rm -rf $HOME/.gradle/caches/
rm -rf $HOME/.gradle/wrapper/

Jeśli używasz zaćmienia i jeśli chcesz wymusić zaćmienie ponownego ładowania zależności, możesz wypróbować poniższe polecenie

gradlew clean cleaneclipse build eclipse --refresh-dependencies

Działa tylko ręczne usunięcie określonej zależności w folderze pamięci podręcznej ... artefakt zbudowany przez kolegę z repozytorium korporacyjnego.

W moim przypadku żadne z powyższych nie zadziałało, a ja:

• W build.gradle, komentując zależności związane z nierozstrzygniętym importem, który miałem
• Kliknij „Synchronizuj teraz”
• Odkomentowanie tego, co właśnie skomentowałem
• Ponownie kliknij „Synchronizuj teraz”

Następnie mój import został ponownie poprawnie rozwiązany.

Musisz go ponownie pobrać, aby można było ręcznie pobrać i wymienić uszkodzony plik oraz ponownie zsynchronizować projekt. Przejdź do tej lokalizacji C: \ users [nazwa użytkownika] .gradle \ wrapper \ dist \ gradle3.3-all \ 55gk2rcmfc6p2dg9u9ohc3hw9 \ gradle-3.3-all.zip Tutaj usuń gradle3.3allzip i zamień go, pobierając ponownie z tej strony https: / /services.gradle.org/distribution/ Znajdź ten sam plik, pobierz go i wklej do tej lokalizacji, a następnie zsynchronizuj swój projekt. Mam nadzieję, że to też dla ciebie działa.