Comment puis-je forcer Gradle à retélécharger les dépendances?

Comment puis-je dire à gradle de télécharger à nouveau les dépendances à partir des référentiels?

En règle générale, vous pouvez actualiser les dépendances dans votre cache avec l'option de ligne de commande --refresh-dependencies . Vous pouvez également supprimer les fichiers mis en cache sous ~/.gradle/caches. Avec la prochaine version, Gradle tenterait de les télécharger à nouveau.

Quel est votre cas d'utilisation spécifique? Utilisez-vous des versions de dépendances dynamiques ou des versions INSTANTANÉES?

Sur les systèmes Unix, vous pouvez supprimer tous les artefacts existants (artefacts et métadonnées) téléchargés par Gradle à l'aide de:

rm -rf $HOME/.gradle/caches/

Si vous utilisez une version récente de Gradle, vous pouvez utiliser l'option --refresh-dependencies.

./gradlew build --refresh-dependencies

vous pouvez vous référer au manuel Gradle .

L'option --refresh-dependencies indique à Gradle d'ignorer toutes les entrées mises en cache pour les modules et artefacts résolus. Une nouvelle résolution sera effectuée par rapport à tous les référentiels configurés, avec les versions dynamiques recalculées, les modules actualisés et les artefacts téléchargés.

Vous pouvez dire à Gradle de télécharger à nouveau certaines dépendances dans le script de construction en signalant la dépendance comme «changeante». Gradle vérifiera alors les mises à jour toutes les 24 heures, mais cela peut être configuré en utilisant le DSL resolutionStrategy. Je trouve utile de l'utiliser pour les builds SNAPSHOT ou NIGHTLY.

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

Étendu:

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

Condensé:

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

J'ai trouvé cette solution sur ce fil de discussion .

Pour Mac

./gradlew build --refresh-dependencies

Pour les fenêtres

gradlew build --refresh-dependencies

Peut également essayer gradlew assembleDevelopmentDebug --refresh-dependencies

Pour Windows ... afin de rendre le téléchargement de Gradle spécifique dépendances :

1. supprimez les dépendances que vous souhaitez télécharger à nouveau dans le répertoire ci-dessous:

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

2. supprimez tous les répertoires de métadonnées du chemin:

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

3. exécuter gradle build(ou gradlew buildsi vous utilisez un wrapper gradle) dans le répertoire racine du projet.

remarque: les numéros dans les chemins de fichiers ci-dessus peuvent être différents pour vous.

On peut supprimer un dossier avec des pots mis en cache.

Dans mon cas, sur Mac, la bibliothèque a été mise en cache sur le chemin:

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

J'ai supprimé le dossier de bibliothèque mis en cache ("cached-library-to-remove" dans l'exemple ci-dessus), supprimé le dossier de construction de mon projet et compilé à nouveau. Une nouvelle bibliothèque a alors été téléchargée.

Au lieu de supprimer l'intégralité de votre cache Gradle, comme le suggèrent certaines réponses, vous pouvez supprimer le cache d'un groupe spécifique ou d'un identifiant d'artefact. J'ai ajouté la fonction suivante à mon .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
}

Usage:

$ deleteGradleCache com.android.support

Ensuite, lors de la prochaine génération ou si vous resynchronisez, gradle téléchargera à nouveau les dépendances.

Il y a 2 façons de procéder:

1. Utilisation de l'option de ligne de commande pour rafraîchir le cashe des dépendances.
2. Vous pouvez supprimer le cache local où les artefasts sont des caches par Gradle et déclencher la construction

Utilisation de l' option --refresh-dependencies :

./gradlew build --refresh-dependencies

Brève explication - l'option refresh-dependencies indique à Gradle d'ignorer toutes les entrées mises en cache pour les modules et artefacts résolus.

Explication longue

• Avec –refresh-dependencies 'Gradle frappera toujours le serveur distant pour vérifier les artefacts mis à jour: cependant, Gradle évitera de télécharger un fichier où le même fichier existe déjà dans le cache.
  • First Gradle fera une requête HEAD et vérifiera si le serveur signale le fichier comme inchangé depuis la dernière fois (si les 'content-length' et 'last-modified' sont inchangés). Dans ce cas, vous obtiendrez le message: "La ressource mise en cache est à jour (lastModified: {})."
  • Gradle suivant déterminera la somme de contrôle à distance si possible (soit à partir de la requête HEAD, soit en téléchargeant un fichier '.sha1'). Si cette somme de contrôle correspond à un autre fichier déjà téléchargé (à partir de n'importe quel référentiel), Gradle copiera simplement le fichier dans la cache, plutôt que de re-télécharger. Dans ce cas, vous obtiendrez le message: "" Ressource disponible localement trouvée avec somme de contrôle correspondante: [{}, {}] ".

Utilisation de la suppression: lorsque vous supprimez des caches

rm -rf $HOME/.gradle/caches/

Vous venez de nettoyer tous les bocaux mis en cache et les sommes sha1 et Gradle est dans une situation où il n'y a aucun artefact sur votre machine et doit tout télécharger. Oui, cela fonctionnera à 100% pour la première fois, mais lorsqu'un autre INSTANTANÉ est publié et qu'il fait partie de votre arbre de dépendance, vous serez de nouveau confronté devant le choix d'actualiser ou de purger les caches.

Cela a fonctionné pour moi. Assurez-vous que Gradle n'est pas réglé sur hors ligne en décochant le bouton dans Fichier> Paramètres> Gradle> Travail hors ligne.

Ajoutez cela au niveau supérieur de votre build.gradle, agréable d'avoir des dépendances ci-dessus

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

Je me suis assuré que mes dépendances sont écrites comme ceci:

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

Par la suite, j'ouvre le panneau Gradle dans Android Studio et clique sur le bouton fléché du cercle bleu. Je peux toujours voir mes mises à jour obtenir une nouvelle copie fraîche.

Aucune des solutions ci-dessus n'a fonctionné pour moi.

Si vous utilisez IntelliJ, ce qui m'a résolu était simplement de rafraîchir tous les projets Gradle:

Pour ceux qui se demandent où exécuter les commandes gradle:

1. Ouvrez Android Studio
2. Cliquez sur Terminal (vous le trouverez dans la base d'Android Studio)
3. L'outil de commande s'ouvre
4. Tapez votre commande gradlew build --refresh-dependencies

Pour Android Studio 3.4.1

Ouvrez simplement l'onglet Gradle (peut être situé à droite) et faites un clic droit sur le parent dans la liste (devrait être appelé "Android"), puis sélectionnez "Actualiser les dépendances".

Cela devrait résoudre votre problème.

Mb Je suis trop tard mais ma solution est pour un référentiel unique. Je pense que supprimer ~ / .gradle / * est exagéré. Le problème que j'ai rencontré est que je supprimais le répertoire où se trouvaient les sources et gradle obtenait une autre version qui ne provenait pas de Nexus. Pour éviter cela, je lance le suivant:

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

Après que gradle glisse des fichiers de Nexus.

Pour actualiser la version 'release' mise en cache, la seule option est de vider le cache local.

rm -rf $HOME/.gradle/caches/

Pour actualiser la version «instantané» mise en cache, vous pouvez:

./gradlew build --refresh-dependencies

La suppression de tous les caches permet de télécharger à nouveau toutes les dépendances. donc cela prend tellement de temps et c'est ennuyeux d'attendre encore une fois pour télécharger à nouveau toutes les dépendances.

Comment pourrais-je être en mesure de résoudre ce problème ci-dessous.

Supprimez simplement les groupes qui doivent être actualisés.

Ex: si nous voulons rafraîchir le groupe com.user.test

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

puis supprimez la dépendance de build.gradle et ajoutez-la à nouveau. alors il rafraîchira les dépendances ce que nous voulons.

Je pense que Gradle 2.14.1 résout le problème. La réponse acceptée est correcte, mais il y a un bogue dans gradle avec –refresh-dependencies. 2.14.1 corrige cela.

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

supprimez ce répertoire:

C:\Users\[username]\.gradle

Pour la majorité des cas, la simple reconstruction du projet devrait suffire. Parfois, vous devez exécuter ./gradlew build --refresh-dependenciescomme plusieurs réponses l'ont déjà mentionné (cela prend beaucoup de temps, selon le nombre de dépendances que vous avez). Cependant, parfois, rien de tout cela ne fonctionnera: la dépendance ne sera tout simplement pas mise à jour. Ensuite, vous pouvez faire ceci:

1. Supprimez la dépendance de votre fichier Gradle
2. Exécutez / déboguez votre projet et attendez qu'il échoue (avec NonExistingClassraison)
3. Appuyez sur "build project" et attendez qu'il se termine avec succès
4. Exécuter / déboguer à nouveau

C'est ridicule et cela ressemble à de la folie, mais j'utilise cette procédure quotidiennement, simplement parce que la dépendance dont j'ai besoin peut être mise à jour des dizaines de fois et aucune des solutions adéquates n'aurait d'effet.

Vous pouvez le faire comme ça

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

Pour citer la désactivation du cache de génération Gradle

Le cache de construction Gradle peut être une bonne chose lorsque vous construisez régulièrement> de grands projets avec Gradle. Cependant, lorsque vous créez des projets open source> occasionnellement, cela peut rapidement devenir important.

Pour désactiver le cache de génération Gradle, ajoutez la ligne suivante à ~/.gradle/gradle.properties

org.gradle.caching=false

Vous pouvez nettoyer le cache existant avec

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

Si vous utilisez eclipse et si vous voulez forcer eclipse à recharger les dépendances, vous pouvez essayer la commande ci-dessous

gradlew clean cleaneclipse build eclipse --refresh-dependencies

Seule une suppression manuelle de la dépendance spécifique dans le dossier cache fonctionne ... un artificiel construit par un collègue du référentiel d'entreprise.

Dans mon cas, rien de ce qui précède n'a fonctionné, ce que j'ai fait était:

• Dans build.gradle, commentant les dépendances liées aux importations non résolues que j'avais
• Cliquez sur "Synchroniser maintenant"
• Commentant ce que je viens de commenter
• Cliquez à nouveau sur "Synchroniser maintenant"

Ensuite, mes importations ont été correctement résolues à nouveau.

Vous devez le télécharger à nouveau, vous pouvez donc télécharger et remplacer manuellement le fichier corrompu et synchroniser à nouveau votre projet. Accédez à cet emplacement C: \ users [nom d'utilisateur] .gradle \ wrapper \ dist \ gradle3.3-all \ 55gk2rcmfc6p2dg9u9ohc3hw9 \ gradle-3.3-all.zip Ici, supprimez gradle3.3allzip et remplacez-le en le téléchargeant à nouveau à partir de ce site https: / /services.gradle.org/distributions/ Recherchez le même fichier, téléchargez-le et collez-le à cet emplacement. Ensuite, synchronisez votre projet. J'espère que ça marchera pour toi aussi.