Comment trouver / supprimer les dépendances inutilisées dans Gradle

Je voulais trouver des dépendances inutilisées dans mon projet. Y a-t-il une fonctionnalité pour cela dans Gradle, comme dans Maven?

MISE À JOUR: 28-06-2016: Prise en charge d'Android pour les dépendances inutilisées

En juin 2017 , ils ont publié le 4.0.0 version et renommé le nom du projet racine "gradle-lint-plugin"en "nebula-lint-plugin". Ils ont également ajouté la prise en charge d'Android aux dépendances inutilisées .

En mai 2016, Gradle a implémenté le plugin Gradle lint pour rechercher et supprimer les dépendances indésirables

Plugin Gradle Lint: Documentation complète

Le plugin Gradle Lint est un outil linter enfichable et configurable pour identifier et signaler les modèles de mauvaise utilisation ou d'obsolescence dans les scripts Gradle et les fichiers associés.

Ce plugin a différentes règles. La règle de dépendance inutilisée est l'une d'entre elles. Il a trois caractéristiques spécifiques.

1. Supprime les dépendances inutilisées.
2. Promeut les dépendances transitives utilisées directement par votre code en dépendances explicites de premier ordre.
3. Déplace les dépendances vers la configuration «correcte».

Pour appliquer la règle, ajoutez:

gradleLint.rules += 'unused-dependency'

Les détails de la règle de dépendance inutilisée sont donnés dans la dernière partie.

Pour appliquer le plugin Gradle lint:

buildscript { repositories { jcenter() } }
plugins {
  id 'nebula.lint' version '0.30.2'
}

Alternativement:

buildscript {
  repositories { jcenter() }
  dependencies {
    classpath 'com.netflix.nebula:gradle-lint-plugin:latest.release'
  }
}

apply plugin: 'nebula.lint'

Définissez les règles contre lesquelles vous souhaitez pelucher:

gradleLint.rules = ['all-dependency'] // Add as many rules here as you'd like

Pour une version d'entreprise, nous vous recommandons de définir les règles de lint dans un script init.gradle ou dans un script Gradle inclus via le mécanisme Gradle apply from.

Pour les projets multimodules, nous vous recommandons d'appliquer le plugin dans un allprojectsbloc:

allprojects {
  apply plugin: 'nebula.lint'
  gradleLint.rules = ['all-dependency'] // Add as many rules here as you'd like
}

Les détails de la règle de dépendance inutilisée sont donnés dans cette partie

Pour appliquer la règle, ajoutez:

gradleLint.rules += 'unused-dependency'

La règle inspecte les binaires compilés émanant des ensembles de sources de votre projet à la recherche de références de classe et fait correspondre ces références aux dépendances que vous avez déclarées dans votre bloc de dépendances .

Plus précisément, la règle apporte les ajustements suivants aux dépendances:

1. Supprime les dépendances inutilisées

• Les bocaux de style familial comme com.amazonaws: aws-java-sdk sont supprimés, car ils ne contiennent aucun code

2. Promeut les dépendances transitives qui sont utilisées directement par votre code en dépendances explicites de premier ordre

• Cela a pour effet secondaire de diviser les fichiers JAR de style familial, comme com.amazonaws: aws-java-sdk, dans les parties que vous utilisez réellement, et de les ajouter en tant que dépendances de premier ordre

3. Déplace les dépendances vers la configuration «correcte»

• Les Webjars sont déplacés vers la configuration d'exécution
• Les fichiers JAR qui ne contiennent pas de classes et de contenu en dehors de META-INF sont déplacés vers l'exécution
• 'xerces', 'xercesImpl', 'xml-apis' doit toujours être limité à l'exécution
• Les fournisseurs de services (fichiers JAR contenant META-INF / services) comme mysql-connector-java sont déplacés vers le runtime s'il n'y a pas de référence prouvable à la compilation
• Les dépendances sont déplacées vers la configuration d'ensemble source la plus élevée possible. Par exemple, 'junit' est déplacé vers testCompile à moins qu'il n'y ait une dépendance explicite sur celui-ci dans l'ensemble de sources principal (rare).

MISE À JOUR: plugins précédents

Pour votre aimable information, je souhaite partager sur les plugins précédents

1. Le plugin Gradle qui trouve les dépendances inutilisées, déclarées et transitives est com.github.nullstress.dependency-analysis

Mais sa dernière version 1.0.3 est créée le 23 décembre 2014 . Après cela, il n'y a plus de mises à jour.

NB: Beaucoup de nos ingénieurs sont confus à propos de ce plugin car ils n'ont mis à jour que le numéro de version, rien d'autre.

Le projet mentionné dans les réponses précédentes semble mort. J'utilise gradle-dependency-analyser . La configuration est simple:

buildscript {
  repositories {
    jcenter()
  }
  dependencies {
    classpath 'ca.cutterslade.gradle:gradle-dependency-analyze:1.0.3'
  }
}

apply plugin: 'ca.cutterslade.analyze'

Alors fais:

$ gradle analyzeDependencies

J'ai eu beaucoup de chance avec le plugin Gradle Dependency Analysis . Pour commencer, ajoutez les deux éléments suivants à votre script de génération Gradle.

buildscript {
    repositories {
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath "com.github.nullstress:DependencyAnalysisPlugin:1.0.3"
    }
}

et

apply plugin: "dependencyAnalysis"

Une fois ceux-ci en place, courez gradle analyze. S'il y a des dépendances inutilisées, vous obtiendrez un échec de construction qui affiche une sortie similaire au texte ci-dessous, ainsi qu'une liste des dépendances inutilisées (déclarées et transitives). L'échec de build est vraiment pratique si vous voulez imposer qu'il ne devrait y avoir aucune dépendance inutilisée via une build CI.

:foo:analyze FAILED

FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':foo:analyze'.
> The project has unused declared artifacts

Je viens d'apprendre celui-ci: https://plugins.gradle.org/plugin/com.autonomousapps.dependency-analysis

Github

D'après les apparences, il est en développement actif, mais je ne l'ai pas encore testé.

Edit: En fait, c'est assez génial, il fournit de nombreux conseils (par exemple, s'il faut utiliser l'api ou l'implémentation)

Note de l'éditeur: cette réponse n'est pas à jour. Veuillez voir la première réponse .

Vous pouvez essayer le plugin Gradle com.github.nullstress.dependency-analysis

Créez un extrait de script à utiliser dans toutes les versions de Gradle:

buildscript {
  repositories {
    jcenter()
  }
  dependencies {
    classpath "com.github.nullstress:DependencyAnalysisPlugin:1.0.3"
  }
}

apply plugin: "com.github.nullstress.dependency-analysis"

Créez un extrait de script pour le nouveau mécanisme de plug-in en incubation introduit dans Gradle 2.1:

plugins {
  id "com.github.nullstress.dependency-analysis" version "1.0.3"
}

De plus, il y a un fil de discussion ( y a-t-il un équivalent Gradle de "mvn dependency: analysez"? ) Dans le forum Gradle à ce sujet.

Les projets sur la plupart des réponses historiques sont morts, mais gradle-dependency-analysis semble être en vie au 30/05/2016.