Introduction à FindBugs

1. Vue d'ensemble

FindBugs est un outil open source utilisé pour effectuer une analyse statique sur du code Java.

Dans cet article, nous allons jeter un œil à la configuration de FindBugs sur un projet Java et à son intégration dans l'EDI et la build Maven.

2. FindBugs Maven Plugin

2.1. Configuration Maven

Pour commencer à générer des rapports d'analyse statique, nous devons d'abord ajouter le plugin FindBugs dans notre pom.xml :

   org.codehaus.mojo findbugs-maven-plugin 3.0.4   

Vous pouvez consulter la dernière version du plugin sur Maven Central.

2.2. Génération de rapports

Maintenant que le plugin Maven est correctement configuré, générons la documentation du projet à l'aide de la commande mvn site .

Le rapport sera généré dans le dossier target / site du répertoire du projet sous le nom findbugs.html .

Vous pouvez également exécuter la commande mvn findbugs: gui pour lancer l'interface graphique afin de parcourir les rapports générés pour le projet en cours.

Le plugin FindBugs peut également être configuré pour échouer dans certaines circonstances - en ajoutant la vérification de l' objectif d'exécution à notre configuration:

 org.codehaus.mojo findbugs-maven-plugin 3.0.4  Max     check    

L' effort - lorsqu'il est au maximum, effectue une analyse plus complète et précise, révélant plus de bogues dans le code, cependant, cela consomme plus de ressources et prend plus de temps à compléter.

Vous pouvez maintenant exécuter la commande mvn verify , pour vérifier si la construction réussira ou non - en fonction des défauts détectés lors de l'exécution de l'analyse.

Vous pouvez également améliorer le processus de génération de rapport et prendre plus de contrôle sur l'analyse, en ajoutant une configuration de base à la déclaration du plugin:

 org.baeldung.web.controller.* FindNullDeref FindReturnRef 

L' option onlyAnalyze déclare une valeur séparée par des virgules des classes / packages éligibles pour l'analyse.

Les options visiteurs / omitVisiteurs sont également des valeurs séparées par des virgules, elles sont utilisées pour spécifier quels détecteurs doivent / ne doivent pas être exécutés pendant l'analyse - Notez que les visiteurs et omitVisitors ne peuvent pas être utilisés en même temps .

Un détecteur est spécifié par son nom de classe, sans aucune qualification de package. Trouvez les détails de tous les noms de classe de détecteurs disponibles en suivant ce lien.

3. Plug-in FindBugs Eclipse

3.1. Installation

L'installation IDE du plug-in FindBugs est assez simple - il vous suffit d'utiliser la fonction de mise à jour logicielle d'Eclipse , avec le site de mise à jour suivant: //findbugs.cs.umd.edu/eclipse .

Pour vous assurer que FindBugs est correctement installé dans votre environnement Eclipse, recherchez l'option intitulée FindBugs sous Windows -> Préférences -> Java.

3.2. Navigation dans les rapports

Afin de lancer une analyse statique sur un projet à l'aide du plugin FindBugs Eclipse, vous devez faire un clic droit sur le projet dans l'explorateur de packages, puis cliquer sur l'option intitulée rechercher des bogues .

Après le lancement, Eclipse affiche les résultats sous la fenêtre Bug Explorer comme indiqué dans la capture d'écran ci-dessous:

Depuis la version 2, FindBugs a commencé à classer les bogues avec une échelle de 1 à 20 pour mesurer la gravité des défauts:

  • Le plus effrayant : classé entre 1 et 4.
  • Effrayant : classé entre 5 et 9.
  • Troublant : classé entre 10 et 14.
  • De préoccupation : classé entre 15 et 20.

Alors que le classement des bogues décrit la gravité, le facteur de confiance reflète la probabilité que ces bogues soient signalés comme réels. La confiance s'appelait à l'origine priorité , mais elle a été renommée dans la nouvelle version.

Bien entendu, certains défauts peuvent être sujets à interprétation, et ils peuvent même exister sans nuire au comportement souhaité d'un logiciel. C'est pourquoi, dans une situation réelle, nous devons configurer correctement les outils d'analyse statique en choisissant un ensemble limité de défauts à activer dans un projet spécifique.

3.3. Configuration Eclipse

Le plugin FindBugs facilite la personnalisation de la stratégie d'analyse des bogues, en offrant différentes manières de filtrer les avertissements et de limiter la rigueur des résultats. Vous pouvez vérifier l'interface de configuration en allant dans Fenêtre -> Préférences -> Java -> FindBugs:

Vous pouvez librement décocher les catégories indésirables, augmenter le rang minimum à signaler, spécifier la confiance minimale à signaler et personnaliser les marqueurs pour les classements de bogues - Avertissement, Info ou Erreur.

FindBugs divise les défauts en plusieurs catégories:

  • Correctness - rassemble les bogues généraux, par exemple les boucles infinies, l'utilisation inappropriée de equals () , etc.
  • Mauvaise pratique , par exemple la gestion des exceptions, les flux ouverts, la comparaison des chaînes, etc.
  • Performances , par exemple objets inactifs
  • Exactitude multithread - rassemble les incohérences de synchronisation et divers problèmes dans un environnement multi-thread
  • Internationalisation - regroupe les problèmes liés à l'encodage et à l'internationalisation des applications
  • Malicious code vulnerability – gathers vulnerabilities in code, e.g. code snippets that can be exploited by potential attackers
  • Security – gathers security holes related to specific protocols or SQL injections
  • Dodgy – gathers code smells, e.g. useless comparisons, null checks, unused variables, etc

Under the Detector configuration tab, you can check the rules you're supposed to respect in your project:

The speed attribute reflects how costly the analysis will be. The fastest the detector, the smallest the resources consumed to perform it.

You can find the exhaustive list of bugs recognized by FindBugs at the official documentation page.

Under the Filter files panel, you can create custom file filters, in order to include/exclude parts of the code-base. This feature is useful – for example – when you want to prevent “unmanaged” or “trash” code, defects to pop up in the reports, or may exclude all classes from the test package for instance.

4. FindBugs IntelliJ IDEA Plugin

4.1. Installation

If you are an IntelliJ IDEA fan, and you want to start inspecting Java code using FindBugs, you can simply grab the plugin installation package from the official JetBrains site, and extract it to the folder %INSTALLATION_DIRECTORY%/plugins. Restart your IDE and you're good to go.

Alternatively, you can navigate to Settings -> Plugins and search all repositories for FindBugs plugin.

By the time of writing this article, the version 1.0.1 of the IntelliJ IDEA plugin is just out,

To make sure that the FindBugs plugin is properly installed, check for the option labeled “Analyze project code” under Analyze -> FindBugs.

4.2. Reports Browsing

In order to launch static analysis in IDEA, click on “Analyze project code”, under Analyze -> FindBugs, then look for the FindBugs-IDEA panel to inspect the results:

You can use the second column of commands on the left side of the screenshot, to group defects using different factors:

  1. Group by a bug category.
  2. Group by a class.
  3. Group by a package.
  4. Group by a bug rank.

It is also possible to export the reports in XML/HTML format, by clicking the “export” button in the fourth column of commands.

4.3. Configuration

The FindBugs plugin preferences pages inside IDEA is pretty self-explanatory:

This settings window is quite similar to the one we've seen in Eclipse, thus you can perform all kinds of configuration in an analogous fashion, starting from analysis effort level, bugs ranking, confidence, classes filtering, etc.

The preferences panel can be accessed inside IDEA, by clicking the “Plugin preferences” icon under the FindBugs-IDEA panel.

5. Report Analysis for the Spring-Rest Project

In this section we're going to shed some light on a static analysis done on the spring-rest project available on Github as an example:

Most of the defects are minor — Of Concern, but let's see what we can do to fix some of them.

Method ignores exceptional return value:

File fileServer = new File(fileName); fileServer.createNewFile();

As you can probably guess, FindBugs is complaining about the fact that we're throwing away the return value of the createNewFile() method. A possible fix would be to store the returned value in a newly declared variable, then, log something meaningful using the DEBUG log level — e.g. “The named file does not exist and was successfully created” if the returned value is true.

The method may fail to close stream on exception: this particular defect illustrates a typical use case for exception handling that suggests to always close streams in a finally block:

try { DateFormat dateFormat = new SimpleDateFormat("yyyy_MM_dd_HH.mm.ss"); String fileName = dateFormat.format(new Date()); File fileServer = new File(fileName); fileServer.createNewFile(); byte[] bytes = file.getBytes(); BufferedOutputStream stream = new BufferedOutputStream(new FileOutputStream(fileServer)); stream.write(bytes); stream.close(); return "You successfully uploaded " + username; } catch (Exception e) { return "You failed to upload " + e.getMessage(); }

When an exception is thrown before the stream.close() instruction, the stream is never closed, that's why it's always preferable to make use of the finally{} block to close streams opened during a try/catch routine.

An Exception is caught when Exception is not thrown: As you may already know, catching Exception is a bad coding practice, FindBugs thinks that you must catch a most specific exception, so you can handle it properly. So basically manipulating streams in a Java class, catching IOException would be more appropriate than catching a more generic Exception.

Field not initialized in the constructor but dereferenced without null check: it always a good idea to initialize fields inside constructors, otherwise, we should live with the possibility that the code will raise an NPE. Thus, it is recommended to perform null checks whenever we're not sure if the variable is properly initialized or not.

6. Conclusion

In this article, we've covered the basic key points to use and customize FindBugs in a Java project.

As you can see, FindBugs is a powerful, yet simple static analysis tool, it helps to detect potential quality holes in your system – if tuned and used correctly.

Enfin, il convient de mentionner que FindBugs peut également être exécuté dans le cadre d'un outil de révision de code automatique et continu distinct comme Sputnik , ce qui peut être très utile pour donner aux rapports beaucoup plus de visibilité.

L'exemple de code que nous avons utilisé pour l'analyse statique est disponible à l'adresse over sur Github.