Come posso forzare Gradle a scaricare di nuovo le dipendenze?

Come posso dire a Gradle di scaricare nuovamente le dipendenze dai repository?

In genere, è possibile aggiornare le dipendenze nella cache con l'opzione della riga di comando --refresh-dependencies . Puoi anche eliminare i file memorizzati nella cache in ~/.gradle/caches. Con la build successiva Gradle tenterebbe di scaricarli di nuovo.

Qual è il tuo caso d'uso specifico? Usi le versioni di dipendenza dinamica o le versioni SNAPSHOT?

Sui sistemi Unix, puoi eliminare tutti gli artefatti esistenti (artefatti e metadati) che Gradle ha scaricato usando:

rm -rf $HOME/.gradle/caches/

Se stai usando una versione recente di Gradle, puoi usare l'opzione --refresh-dependencies.

./gradlew build --refresh-dependencies

puoi fare riferimento al manuale Gradle .

L'opzione --refresh-dependencies dice a Gradle di ignorare tutte le voci memorizzate nella cache per i moduli e gli artefatti risolti. Verrà eseguita una nuova risoluzione su tutti i repository configurati, con le versioni dinamiche ricalcolate, i moduli aggiornati e gli artefatti scaricati.

Puoi dire a Gradle di scaricare nuovamente alcune dipendenze nello script di compilazione contrassegnando la dipendenza come "modifica". Gradle verificherà quindi la disponibilità di aggiornamenti ogni 24 ore, ma questo può essere configurato utilizzando la risoluzione DSL di strategia. Trovo utile usarlo per build SNAPSHOT o NIGHTLY.

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

Allargato:

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

Condensato:

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

Ho trovato questa soluzione in questo thread del forum .

Per MAC

./gradlew build --refresh-dependencies

Per Windows

gradlew build --refresh-dependencies

Puoi anche provare gradlew assembleDevelopmentDebug --refresh-dependencies

Per Windows ... al fine di effettuare il download graduale di nuove dipendenze specifiche :

1. elimina le dipendenze che desideri scaricare nuovamente dalla directory seguente:

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

2. elimina tutte le directory dei metadati nel percorso:

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

3. eseguire gradle build(o gradlew buildse si utilizza il wrapper gradle) nella directory principale del progetto.

nota: i numeri nei percorsi dei file sopra potrebbero essere diversi per te.

Si può rimuovere la cartella con vasetti memorizzati nella cache.

Nel mio caso, su Mac la libreria è stata memorizzata nella cache nel percorso:

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

Ho rimosso la cartella della libreria memorizzata nella cache ("cache-library-to-remove" nell'esempio sopra), ho eliminato la cartella di build del mio progetto e compilata di nuovo. Quindi è stata scaricata una nuova libreria.

Invece di rimuovere l'intera cache gradle, come suggerito da alcune risposte, è possibile eliminare la cache per un gruppo specifico o un ID artefatto. Ho aggiunto la seguente funzione alla mia .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
}

Uso:

$ deleteGradleCache com.android.support

Quindi, nella build successiva o in caso di risincronizzazione, Gradle scaricherà nuovamente le dipendenze.

Ci sono 2 modi per farlo:

1. Utilizzo dell'opzione della riga di comando per aggiornare il cashe delle dipendenze.
2. È possibile eliminare la cache locale in cui gli artefasti sono cache di Gradle e attivare la generazione

Utilizzando l' opzione --refresh-dependencies :

./gradlew build --refresh-dependencies

Breve spiegazione : l'opzione di aggiornamento delle dipendenze dice a Gradle di ignorare tutte le voci memorizzate nella cache per i moduli e gli artefatti risolti.

Spiegazione lunga

• Con Gradle –refresh-dependencies colpirà sempre il server remoto per verificare la presenza di artefatti aggiornati: tuttavia Gradle eviterà di scaricare un file in cui lo stesso file esiste già nella cache.
  • First Gradle farà una richiesta HEAD e verificherà se il server riporta il file come invariato dall'ultima volta (se "lunghezza-contenuto" e "ultima modifica" sono invariati). In questo caso verrà visualizzato il messaggio: "La risorsa memorizzata nella cache è aggiornata (lastModified: {})."
  • Next Gradle determinerà il checksum remoto, se possibile (dalla richiesta HEAD o scaricando un file '.sha1'). Se questo checksum corrisponde a un altro file già scaricato (da qualsiasi repository), Gradle copierà semplicemente il file nel cache, piuttosto che riscaricare. In questo caso riceverai il messaggio: "" Trovato risorsa disponibile localmente con checksum corrispondente: [{}, {}] ".

Utilizzo di elimina: quando si eliminano le cache

rm -rf $HOME/.gradle/caches/

Devi solo pulire tutti i vasetti memorizzati nella cache e le somme sha1 e Gradle è in una situazione in cui non ci sono artefatti sulla tua macchina e deve scaricare tutto. Sì, funzionerà al 100% per la prima volta, ma quando viene rilasciato un altro SNAPSHOT ed è parte del tuo albero delle dipendenze, dovrai affrontare di nuovo la scelta per aggiornare o eliminare le cache.

Questo ha funzionato per me. Assicurati che Gradle non sia impostato su offline deselezionando il pulsante in File> Impostazioni> Gradle> Lavoro offline.

Aggiungi questo al livello superiore del tuo build.gradle, bello avere dipendenze sopra

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

Mi sono assicurato che le mie dipendenze fossero scritte in questo modo:

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

Successivamente, apro il pannello Gradle in Android Studio e faccio clic sul pulsante blu delle frecce circolari. Posso sempre vedere i miei aggiornamenti ottenere una nuova copia.

Nessuna delle soluzioni sopra ha funzionato per me.

Se usi IntelliJ, ciò che lo ha risolto per me è stato semplicemente aggiornare tutti i progetti Gradle:

Per coloro che si chiedono dove eseguire i comandi Gradle:

1. Apri Android Studio
2. Fai clic su Terminale (lo troverai nella base di Android Studio)
3. Lo strumento di comando si aprirà
4. Digita il tuo comando gradlew build --refresh-dependencies

Per Android Studio 3.4.1

Basta aprire la scheda Gradle (che si trova sulla destra) e fare clic con il tasto destro del mouse sull'elemento principale nell'elenco (dovrebbe essere chiamato "Android"), quindi selezionare "Aggiorna dipendenze".

Questo dovrebbe risolvere il tuo problema.

Mb Sono troppo tardi, tuttavia la mia soluzione è per un singolo repository. Penso che eliminare ~ / .gradle / * sia eccessivo. Il problema a cui mi sono imbattuto è che stavo eliminando la directory in cui c'erano le fonti e Gradle stava ottenendo un'altra versione non da Nexus. Per evitare che corro il prossimo:

~/.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

Dopo quel grado trascina i file da Nexus.

Per aggiornare la versione "release" memorizzata nella cache, l'unica opzione è quella di cancellare la cache locale.

rm -rf $HOME/.gradle/caches/

Per aggiornare la versione "snapshot" memorizzata nella cache è possibile:

./gradlew build --refresh-dependencies

L'eliminazione di tutte le cache fa scaricare nuovamente tutte le dipendenze. quindi ci vuole così tanto tempo ed è noioso aspettare ancora per scaricare nuovamente tutte le dipendenze.

Come mai potrei essere in grado di risolvere questo sotto modo.

Elimina solo i gruppi che devono essere aggiornati.

Es: se vogliamo aggiornare il gruppo com.user.test

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

quindi rimuovere la dipendenza da build.gradle e aggiungerla di nuovo. quindi aggiornerà le dipendenze da ciò che vogliamo.

Penso che il grado 2.14.1 risolva il problema. La risposta accettata è corretta, ma è presente un bug in gradle con –refresh-dependencies. 2.14.1 lo risolve.

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

elimina questa directory:

C:\Users\[username]\.gradle

Per la maggior parte dei casi, semplicemente ricostruire il progetto dovrebbe fare il trucco. A volte devi eseguire ./gradlew build --refresh-dependenciescome già indicato in diverse risposte (richiede molto tempo, a seconda di quante dipendenze hai). Tuttavia, a volte nessuno di questi funzionerà: la dipendenza non verrà aggiornata. Quindi, puoi farlo:

1. Rimuovi la dipendenza dal tuo file gradle
2. Esegui / esegui il debug del progetto e attendi che non riesca (con NonExistingClassmotivo)
3. Premi "build project" e attendi che finisca correttamente
4. Esegui / debug ancora una volta

Questo è ridicolo e sembra una follia, ma in realtà uso questa procedura quotidianamente, semplicemente perché la dipendenza di cui ho bisogno può essere aggiornata dozzine di volte e nessuna delle soluzioni adeguate avrebbe alcun effetto.

Puoi farlo in questo modo

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

Per citare Disabilitando la Gradle Build Cache

La cache di build Gradle può essere un'ottima cosa quando si creano regolarmente> grandi progetti con Gradle. Tuttavia, quando solo occasionalmente costruisce progetti open source>, può rapidamente diventare grande.

Per disabilitare la cache di build Gradle aggiungere la seguente riga a ~/.gradle/gradle.properties

org.gradle.caching=false

È possibile pulire la cache esistente con

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

Se stai usando eclipse e se vuoi forzare eclipse a ricaricare le dipendenze puoi provare sotto il comando

gradlew clean cleaneclipse build eclipse --refresh-dependencies

Funziona solo una cancellazione manuale della dipendenza specifica nella cartella cache ... un artefatto creato da un collega nel repository aziendale.

Nel mio caso nessuno dei precedenti ha funzionato, quello che ho fatto è stato:

• In build.gradle, commentando le dipendenze legate alle importazioni irrisolte che avevo
• Facendo clic su "Sincronizza ora"
• Uncommenting quello che ho appena commentato
• Fare di nuovo clic su "Sincronizza ora"

Quindi le mie importazioni sono state correttamente risolte di nuovo.

È necessario scaricarlo di nuovo, in modo da poter scaricare e sostituire manualmente il file danneggiato e sincronizzare nuovamente il progetto. Vai a questa posizione C: \ users [nome utente] .gradle \ wrapper \ dist \ gradle3.3-all \ 55gk2rcmfc6p2dg9u9ohc3hw9 \ gradle-3.3-all.zip Qui elimina gradle3.3allzip e sostituiscilo scaricando nuovamente da questo sito https: / /services.gradle.org/distributions/ Trova lo stesso file e scaricalo e incollalo in quella posizione Quindi sincronizza il tuo progetto. Spero che funzioni anche per te.