Introduzione a FindBugs

1. Panoramica

FindBugs è uno strumento open source utilizzato per eseguire analisi statiche sul codice Java.

In questo articolo, daremo uno sguardo alla configurazione di FindBugs su un progetto Java e alla sua integrazione nell'IDE e nella build Maven.

2. FindBugs Maven Plugin

2.1. Configurazione Maven

Per iniziare a generare rapporti di analisi statica, dobbiamo prima aggiungere il plugin FindBugs nel nostro pom.xml :

   org.codehaus.mojo findbugs-maven-plugin 3.0.4   

Puoi controllare l'ultima versione del plugin su Maven Central.

2.2. Generazione di report

Ora che abbiamo configurato correttamente il plug-in Maven, generiamo la documentazione del progetto utilizzando il comando mvn site .

Il report verrà generato nella cartella target / site nella directory del progetto con il nome findbugs.html .

È inoltre possibile eseguire il comando mvn findbugs: gui per avviare l'interfaccia GUI e sfogliare i report generati per il progetto corrente.

Il plugin FindBugs può anche essere configurato per fallire in alcune circostanze, aggiungendo il controllo dell'obiettivo di esecuzione alla nostra configurazione:

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

Lo sforzo - quando è al massimo, esegue un'analisi più completa e precisa, rivelando più bug nel codice, tuttavia, consuma più risorse e richiede più tempo per il completamento.

È ora possibile eseguire il comando mvn verify , per verificare se la compilazione avrà successo o meno, a seconda dei difetti rilevati durante l'esecuzione dell'analisi.

È inoltre possibile migliorare il processo di generazione dei report e assumere un maggiore controllo sull'analisi, aggiungendo alcune configurazioni di base alla dichiarazione del plug-in:

 org.baeldung.web.controller.* FindNullDeref FindReturnRef 

L' opzione onlyAnalyze dichiara i valori separati da virgola di classi / pacchetti idonei per l'analisi.

Anche le opzioni visitatori / omitVisitors sono valori separati da virgola, vengono utilizzate per specificare quali rilevatori devono / non devono essere eseguiti durante l'analisi - Notare che i visitatori e gli omitVisitors non possono essere utilizzati contemporaneamente .

Un rilevatore è specificato dal nome della sua classe, senza alcuna qualifica di pacchetto. Trovare i dettagli di tutti i nomi di classi di rilevatori disponibili seguendo questo collegamento.

3. FindBugs Eclipse Plugin

3.1. Installazione

L'installazione IDE del FindBugs Plugin è piuttosto semplice: è sufficiente utilizzare la funzione di aggiornamento del software in Eclipse , con il seguente sito di aggiornamento: //findbugs.cs.umd.edu/eclipse .

Per assicurarti che FindBugs sia installato correttamente nel tuo ambiente Eclipse, quindi, cerca l'opzione etichettata FindBugs in Windows -> Preferenze -> Java.

3.2. Navigazione rapporti

Per avviare un'analisi statica su un progetto utilizzando il plug-in FindBugs Eclipse, è necessario fare clic con il pulsante destro del mouse sul progetto in Esplora pacchetti, quindi fare clic sull'opzione denominata trova bug .

Dopo il lancio, Eclipse mostra i risultati nella finestra Bug Explorer come mostrato nello screenshot qui sotto:

A partire dalla versione 2, FindBugs ha iniziato a classificare i bug con una scala da 1 a 20 per misurare la gravità dei difetti:

  • Più spaventoso : classificato tra 1 e 4.
  • Spaventoso : classificato tra 5 e 9.
  • Problematico : classificato tra 10 e 14.
  • Di preoccupazione : classificato tra 15 e 20.

Mentre il grado di bug descrive la gravità, il fattore di fiducia riflette la probabilità che questi bug vengano contrassegnati come veri. La fiducia era originariamente chiamata priorità , ma è stata rinominata nella nuova versione.

Naturalmente, alcuni difetti possono essere interpretati e possono anche esistere senza causare alcun danno al comportamento desiderato di un software. Ecco perché, in una situazione del mondo reale, dobbiamo configurare correttamente gli strumenti di analisi statica scegliendo un insieme limitato di difetti da attivare in un progetto specifico.

3.3. Configurazione Eclipse

Il plug-in FindBugs semplifica la personalizzazione della strategia di analisi dei bug, offrendo vari modi per filtrare gli avvisi e limitare la severità dei risultati. Puoi controllare l'interfaccia di configurazione andando su Finestra -> Preferenze -> Java -> FindBugs:

È possibile deselezionare liberamente le categorie indesiderate, aumentare il grado minimo da segnalare, specificare la confidenza minima da segnalare e personalizzare i marcatori per i gradi di bug: Avviso, Informazioni o Errore.

FindBugs divide i difetti in molte categorie:

  • Correttezza - raccoglie bug generali, ad esempio cicli infiniti, uso inappropriato di equals () , ecc
  • Cattiva pratica , ad esempio gestione delle eccezioni, flussi aperti, confronto di stringhe, ecc
  • Prestazioni , ad esempio oggetti inattivi
  • Correttezza multithread : raccoglie incoerenze di sincronizzazione e vari problemi in un ambiente multi-thread
  • Internazionalizzazione : raccoglie i problemi relativi alla codifica e all'internazionalizzazione dell'applicazione
  • 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.

Infine, vale la pena ricordare che FindBugs può anche essere eseguito come parte di uno strumento di revisione automatica continua del codice separato come Sputnik , che può essere molto utile per dare ai rapporti molta più visibilità.

Il codice di esempio che abbiamo utilizzato per l'analisi statica è disponibile su Github.