Comment trouver du code inutilisé/mort dans les projets Java
Quels outils utilisez-vous pour rechercher du code inutilisé/mort dans les grands projets Java? Notre produit est en développement depuis quelques années et il devient très difficile de détecter manuellement le code qui n'est plus utilisé. Nous essayons cependant de supprimer autant de code non utilisé que possible.
Les suggestions de stratégies/techniques générales (autres que des outils spécifiques) sont également appréciées.
Edit: Notez que nous utilisons déjà des outils de couverture de code (Clover, IntelliJ), mais ceux-ci sont d'une aide minime. Le code mort a toujours des tests unitaires et apparaît comme étant couvert. J'imagine qu'un outil idéal identifierait les groupes de code qui ont très peu d'autres codes en fonction, ce qui permet une inspection manuelle des documents.
J'instruireais le système en cours d'exécution pour qu'il conserve les journaux d'utilisation du code, puis commence à inspecter le code qui n'est pas utilisé pendant des mois ou des années.
Par exemple, si vous êtes intéressé par les classes inutilisées, toutes les classes pourraient être instrumentées pour se connecter lors de la création d'instances. Ensuite, un petit script pourrait comparer ces journaux à la liste complète des classes pour rechercher les classes inutilisées.
Bien entendu, si vous optez pour la méthode, vous devez garder à l’esprit les performances. Par exemple, les méthodes peuvent uniquement consigner leur première utilisation. Je ne sais pas comment cela se fait de mieux en Java. Nous l'avons fait dans Smalltalk, un langage dynamique permettant la modification de code à l'exécution. Nous instrumentons toutes les méthodes avec un appel de journalisation et désinstallons le code de journalisation après la journalisation d'une méthode pour la première fois. Ainsi, après un certain temps, les performances ne sont plus pénalisées. On pourrait peut-être faire la même chose en Java avec des drapeaux booléens statiques ...
Un plugin Eclipse qui fonctionne assez bien est Détecteur de code inutilisé .
Il traite un projet entier ou un fichier spécifique et présente diverses méthodes de code inutilisé/mort, tout en suggérant des modifications de visibilité (c'est-à-dire une méthode publique pouvant être protégée ou privée).
CodePro a récemment été publié par Google avec le projet Eclipse. C'est gratuit et très efficace. Le plugin a une fonctionnalité ' Find Dead Code ' avec un/plusieurs points d'entrée. Fonctionne assez bien.
Je suis surpris ProGuard n'a pas été mentionné ici. C'est l'un des produits les plus matures du marché.
ProGuard est un outil gratuit pour la réduction de fichiers de classe Java, l’optimiseur, les obfuscateurs, et prévérificateur. Il détecte et supprime les classes inutilisées, les champs, méthodes et attributs. Il optimise le bytecode et supprime les inutilisés instructions. Il renomme les classes, champs et méthodes restants en utilisant des noms courts sans signification. Enfin, il pré-qualifie le traité code pour Java 6 ou pour Java Micro Edition.
Certaines utilisations de ProGuard sont:
- Création d'un code plus compact, pour des archives de code plus petites, un transfert plus rapide sur les réseaux, un chargement plus rapide et une mémoire réduite empreintes de pas.
- Rendre les programmes et les bibliothèques plus difficiles à désosser.
- Liste du code mort, afin qu'il puisse être supprimé du code source.
- Recibler et pré-certifier les fichiers de classe existants pour Java 6 ou supérieur, afin de tirer pleinement parti de leur chargement de classe plus rapide.
Voici un exemple de liste de codes morts: https://www.guardsquare.com/en/products/proguard/manual/examples#deadcode
Une des choses que je sais faire dans Eclipse, sur une seule classe, est de changer toutes ses méthodes en privé, puis de voir quelles plaintes je reçois. Pour les méthodes utilisées, cela provoquera des erreurs et je les ramènerai au niveau d'accès le plus bas possible. Pour les méthodes inutilisées, cela provoquera des avertissements à propos des méthodes inutilisées, qui pourront ensuite être supprimées. Et en prime, vous trouvez souvent des méthodes publiques qui peuvent et devraient être rendues privées.
Mais c'est très manuel.
Nous avons commencé à utiliser Find Bugs pour aider à identifier une partie du funk dans l'environnement riche en cibles de notre base de code pour la refactorisation. Je considérerais également Structure 101 pour identifier les zones trop compliquées de l’architecture de votre base de code afin que vous sachiez où se trouvent les vrais marais.
En théorie, vous ne pouvez pas trouver le code inutilisé de manière déterministe. Il en est une preuve mathématique (enfin, c’est un cas particulier d’un théorème plus général). Si vous êtes curieux, cherchez le problème de l’arrêt.
Cela peut se manifester dans le code Java de plusieurs manières:
- Chargement de classes en fonction des entrées de l'utilisateur, des fichiers de configuration, des entrées de base de données, etc.
- Chargement de code externe;
- Passer des arbres d'objets à des bibliothèques tierces;
- etc.
Cela étant dit, j’utilise IDEA IntelliJ comme IDE de mon choix et il dispose d’outils d’analyse étendus pour les dépendances de findign entre modules, les méthodes inutilisées, les membres inutilisés, les classes inutilisées, etc. La méthode privée qui n'est pas appelée est étiquetée inutilisée, mais une méthode publique nécessite une analyse plus approfondie.
Dans Eclipse Goto Windows> Préférences> Java> Compilateur> Erreurs/Avertissements
et changez-les tous en erreurs. Corrigez toutes les erreurs. C'est le moyen le plus simple. La beauté est que cela vous permettra de nettoyer le code au fur et à mesure que vous écrivez.
Capture d'écran du code Eclipse:
IntelliJ dispose d’outils d’analyse de code permettant de détecter le code inutilisé. Vous devriez essayer de créer autant de champs/méthodes/classes que non-public que possible et qui affichera plus de méthodes/champs/classes non utilisés
J'essayerais également de localiser le code en double afin de réduire le volume de code.
Ma dernière suggestion est d'essayer de trouver du code source ouvert qui, s'il était utilisé, rendrait votre code plus simple.
DCD n'est pas un plugin pour certains IDE mais peut être exécuté à partir de ant ou autonome. Cela ressemble à un outil statique et il peut faire ce que PMD et FindBugs ne peuvent pas . Je vais essayer.
P.S. Comme mentionné dans un commentaire ci-dessous, le projet réside maintenant dans GitHub .
Il existe des outils qui profilent le code et fournissent des données de couverture de code. Cela vous permet de voir (quand le code est exécuté) combien de fois il est appelé. Vous pouvez obtenir l’un de ces outils pour savoir combien de code Orphan vous avez.
- FindBugs est excellent pour ce genre de chose.
- PMD (Project Mess Detector) est un autre outil qui peut être utilisé.
Cependant, ni l'un ni l'autre ne peuvent trouver méthodes statiques publiques qui ne sont pas utilisées dans un espace de travail. Si quelqu'un connaît un tel outil, merci de me le faire savoir.
Des outils de couverture de code, tels que Emma, Cobertura et Clover, vont instrumentaliser votre code et enregistrer les parties de celui-ci qui seront invoquées par l'exécution d'une suite de tests. Ceci est très utile et devrait faire partie intégrante de votre processus de développement. Cela vous aidera à déterminer dans quelle mesure votre suite de tests couvre votre code.
Cependant, ce n'est pas la même chose que d'identifier le vrai code mort. Il identifie uniquement le code couvert (ou non) par des tests. Cela peut vous donner des faux positifs (si vos tests ne couvrent pas tous les scénarios) ainsi que des faux négatifs (si vos tests ont un code d'accès qui n'est en réalité jamais utilisé dans un scénario du monde réel).
J'imagine que le meilleur moyen d'identifier réellement le code mort serait d'instrumenter votre code avec un outil de couverture dans un environnement d'exécution en direct et d'analyser la couverture de code sur une période prolongée.
Si vous travaillez dans un environnement redondant à charge équilibrée (et sinon, pourquoi pas?), Alors je suppose qu'il serait logique d'instrumenter une seule instance de votre application et de configurer votre équilibreur de charge de manière à ce qu'une petite partie aléatoire de vos utilisateurs s'exécutent sur votre instance instrumentée. Si vous effectuez cette opération sur une longue période (pour vous assurer que vous avez couvert tous les scénarios d'utilisation dans le monde réel, telles que les variations saisonnières), vous devriez être en mesure de voir exactement les zones de votre code accessibles en mode réel et les parties correspondantes. ne sont vraiment jamais accédés et donc du code mort.
Personnellement, je ne l'ai jamais vu ainsi et je ne sais pas comment les outils susmentionnés peuvent être utilisés pour instrumenter et analyser le code qui n'est pas appelé par une suite de tests - mais je suis sûr qu'ils peuvent l'être.
Il existe un projet Java - Détecteur de code mort (DCD). Pour le code source, cela ne semble pas bien fonctionner, mais pour le fichier .jar, c'est vraiment bon. De plus, vous pouvez filtrer par classe et par méthode.
Netbeans voici un plugin pour Netbeans détecteur de code mort .
Ce serait mieux s'il pouvait lier et mettre en évidence le code inutilisé. Vous pouvez voter et commenter ici: Bug 181458 - Trouver les classes publiques non utilisées, les méthodes et les champs
Outils de couverture utilisateur, tels que EMMA. Mais ce n’est pas un outil statique (c’est-à-dire qu’il faut exécuter l’application par le biais de tests de régression et de tous les cas d’erreur possibles, ce qui est bien impossible:)
Pourtant, EMMA est très utile.
J'ai trouvé l'outil de couverture Clover qui code les instruments et met en surbrillance le code utilisé et non utilisé. Contrairement à Google CodePro Analytics, cela fonctionne également pour les WebApplications (selon mon expérience et je peux être incorrect sur Google CodePro).
Le seul inconvénient que j'ai remarqué est qu'il ne prend pas en compte les interfaces Java.
J'utilise Doxygen pour développer une carte d'appels de méthodes afin de localiser des méthodes qui ne sont jamais appelées. Sur le graphique, vous trouverez des îlots de groupes de méthodes sans appelants. Cela ne fonctionne pas pour les bibliothèques car vous devez toujours commencer par un point d’entrée principal.
Eclipse peut afficher/mettre en évidence un code inaccessible. JUnit peut vous montrer la couverture de code, mais vous aurez besoin de quelques tests et devrez décider si le test correspondant est manquant ou si le code est vraiment inutilisé.