Einführung in FindBugs

1. Übersicht

FindBugs ist ein Open Source-Tool zur statischen Analyse von Java-Code.

In diesem Artikel werden wir uns mit dem Einrichten von FindBugs in einem Java-Projekt und dessen Integration in die IDE und den Maven-Build befassen.

2. FindBugs Maven Plugin

2.1. Maven-Konfiguration

Um statische Analyseberichte zu erstellen, müssen wir zuerst das FindBugs-Plugin in unsere pom.xml einfügen :

   org.codehaus.mojo findbugs-maven-plugin 3.0.4   

Sie können die neueste Version des Plugins in Maven Central herunterladen.

2.2. Berichterstellung

Nachdem wir das Maven-Plugin richtig konfiguriert haben, generieren wir die Projektdokumentation mit dem Befehl mvn site .

Der Bericht wird im Ordner target / site im Projektverzeichnis unter dem Namen findbugs.html generiert .

Sie können auch den Befehl mvn findbugs: gui ausführen , um die GUI-Oberfläche zu starten und die generierten Berichte für das aktuelle Projekt zu durchsuchen.

Die FindBugs Plugin kann auch fehlschlagen unter Umständen so konfiguriert werden - durch die Ausführung Ziel Zugabe Scheck an unsere Konfiguration:

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

Der Aufwand - wenn das Maximum erreicht ist, wird eine vollständigere und präzisere Analyse durchgeführt, wobei mehr Fehler im Code aufgedeckt werden. Dies verbraucht jedoch mehr Ressourcen und dauert länger.

Sie können jetzt den Befehl mvn verify ausführen , um zu überprüfen, ob der Build erfolgreich ist oder nicht - abhängig von den beim Ausführen der Analyse festgestellten Fehlern.

Sie können auch den Prozess der Berichterstellung verbessern und mehr Kontrolle über die Analyse übernehmen, indem Sie der Plugin-Deklaration eine grundlegende Konfiguration hinzufügen:

 org.baeldung.web.controller.* FindNullDeref FindReturnRef 

Die Option onlyAnalyze deklariert durch Kommas getrennte Werte von Klassen / Paketen, die für die Analyse in Frage kommen.

Die Visitors / omitVisitors- Optionen sind ebenfalls durch Kommas getrennte Werte. Sie werden verwendet, um anzugeben, welche Detektoren während der Analyse ausgeführt werden sollen / nicht. Beachten Sie, dass Besucher und omitVisitors nicht gleichzeitig verwendet werden können .

Ein Detektor wird durch seinen Klassennamen ohne Paketqualifikation angegeben. Über diesen Link finden Sie die Details aller verfügbaren Detektorklassennamen.

3. FindBugs Eclipse Plugin

3.1. Installation

Die IDE Installation des FindBugs Plugin ist ziemlich einfach - Sie müssen nur die Software - Update - Funktion in Eclipse verwenden müssen , mit der folgenden Update - Site: //findbugs.cs.umd.edu/eclipse .

Um sicherzustellen, dass FindBugs ordnungsgemäß in Ihrer Eclipse-Umgebung installiert ist, suchen Sie unter Windows -> Einstellungen -> Java nach der Option FindBugs .

3.2. Durchsuchen von Berichten

Um eine statische Analyse eines Projekts mit dem FindBugs Eclipse-Plugin zu starten, müssen Sie im Paket-Explorer mit der rechten Maustaste auf das Projekt klicken und dann auf die Option mit der Bezeichnung Fehler suchen klicken .

Nach dem Start zeigt Eclipse die Ergebnisse im Bug Explorer-Fenster an, wie im folgenden Screenshot gezeigt:

Ab Version 2 hat FindBugs damit begonnen, Fehler mit einer Skala von 1 bis 20 zu bewerten, um die Schwere von Fehlern zu messen:

  • Am gruseligsten : zwischen 1 und 4 eingestuft.
  • Beängstigend : zwischen 5 und 9.
  • Beunruhigend : zwischen 10 und 14 eingestuft.
  • Besorgniserregend : zwischen 15 und 20 eingestuft.

Während der Fehlerrang den Schweregrad beschreibt, spiegelt der Konfidenzfaktor die Wahrscheinlichkeit wider, dass diese Fehler als echte gekennzeichnet werden. Das Vertrauen wurde ursprünglich als Priorität bezeichnet , aber in der neuen Version umbenannt.

Natürlich können einige Fehler interpretiert werden, und sie können sogar existieren, ohne das gewünschte Verhalten einer Software zu beeinträchtigen. Aus diesem Grund müssen wir in einer realen Situation statische Analysewerkzeuge ordnungsgemäß konfigurieren, indem wir eine begrenzte Anzahl von Fehlern auswählen, die in einem bestimmten Projekt aktiviert werden sollen.

3.3. Eclipse-Konfiguration

Das FindBugs-Plugin erleichtert das Anpassen der Fehleranalysestrategie, indem es verschiedene Möglichkeiten bietet, Warnungen zu filtern und die Strenge der Ergebnisse zu begrenzen. Sie können die Konfigurationsoberfläche überprüfen, indem Sie zu Fenster -> Einstellungen -> Java -> FindBugs gehen:

Sie können unerwünschte Kategorien frei deaktivieren, den zu meldenden Mindestrang erhöhen, das zu meldende Mindestvertrauen festlegen und Markierungen für Fehlerränge anpassen - Warnung, Info oder Fehler.

FindBugs unterteilen Fehler in viele Kategorien:

  • Korrektheit - sammelt allgemeine Fehler, z. B. Endlosschleifen, unangemessene Verwendung von equals () usw.
  • Schlechte Vorgehensweise , z. B. Ausnahmebehandlung, geöffnete Streams, Vergleich von Zeichenfolgen usw.
  • Leistung , zB Leerlaufobjekte
  • Multithread-Korrektheit - Sammelt Synchronisationsinkonsistenzen und verschiedene Probleme in einer Multithread-Umgebung
  • Internationalisierung - Sammelt Probleme im Zusammenhang mit der Codierung und der Internationalisierung von Anwendungen
  • 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.

Abschließend ist zu erwähnen, dass FindBugs auch als Teil eines separaten Tools zur kontinuierlichen automatischen Codeüberprüfung wie Sputnik ausgeführt werden kann. Dies kann sehr hilfreich sein, um den Berichten mehr Sichtbarkeit zu verleihen.

Der Beispielcode, den wir für die statische Analyse verwendet haben, ist auf Github verfügbar.