Introdução ao FindBugs

1. Visão geral

FindBugs é uma ferramenta de código aberto usada para executar* análise estática *no código Java.

Neste artigo, veremos como configurar o FindBugs em um projeto Java e integrá-lo ao IDE e à compilação do Maven.

===* 2. Plugin FindBugs Maven *

====* 2.1 Configuração do Maven *

Para começar a gerar relatórios de análise estática, primeiro precisamos adicionar o plug-in FindBugs em nosso pom.xml:

<reporting>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>findbugs-maven-plugin</artifactId>
            <version>3.0.4</version>
        </plugin>
    </plugins>
</reporting>

Você pode conferir o https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.codehaus.mojo%22%20AND%20a%3A%22findbugs-maven-plugin%22 [ última versão do plugin] no Maven Central.

====* 2.2 Geração de relatório *

Agora que o plug-in Maven está configurado corretamente, vamos gerar a documentação do projeto usando o comando mvn site.

O relatório será gerado na pasta* target/site no diretório do projeto com o nome findbugs.html *.

Você também pode executar o comando mvn findbugs: gui para ativar a interface da GUI e procurar os relatórios gerados para o projeto atual.

O plug-in FindBugs também pode ser configurado para falhar sob algumas circunstâncias - adicionando o objetivo de execução check à nossa configuração:

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>findbugs-maven-plugin</artifactId>
    <version>3.0.4</version>
    <configuration>
        <effort>Max</effort>
    </configuration>
    <executions>
        <execution>
            <goals>
                <goal>check</goal>
            </goals>
        </execution>
    </executions>
</plugin>

O effort - quando maximizado, realiza uma análise mais completa e precisa, revelando mais erros no código; no entanto, consome mais recursos e leva mais tempo para concluir.

Agora você pode executar o comando mvn Verifique para verificar se a compilação será bem-sucedida ou não - dependendo dos defeitos detectados durante a execução da análise.

Você também pode aprimorar o processo de geração de relatórios e ter mais controle sobre a análise, adicionando algumas configurações básicas à declaração do plug-in:

<configuration>
    <onlyAnalyze>org..web.controller.*</onlyAnalyze>
    <omitVisitors>FindNullDeref</omitVisitors>
    <visitors>FindReturnRef</visitors>
</configuration>

A opção onlyAnalyze declara valores separados por vírgula de classes/pacotes elegíveis para análise.

As opções visitors _/ omitVisitors_ também são valores separados por vírgula, elas são usadas para especificar quais detectores devem/não devem ser executados durante a análise - Observe que visitors e omitVisitors não podem ser usados ao mesmo tempo .

Um detector é especificado por seu nome de classe, sem qualquer qualificação de pacote. Encontre os detalhes de todos os nomes de classes de detectores disponíveis, seguindo este link.

3. Plug-in do Eclipse FindBugs

====* 3.1 Instalação *

A instalação do IDE do FindBugs Plugin é bastante direta - você só precisa usar o recurso de atualização de software no Eclipse , com o seguinte site de atualização: http://findbugs.cs.umd.edu/eclipse.

Para garantir que o FindBugs esteja instalado corretamente em seu ambiente Eclipse, procure a opção FindBugs em Windows → Preferências → Java.

====* 3.2 Navegação de relatórios *

Para iniciar uma análise estática em um projeto usando o plug-in FindBugs Eclipse, você precisa clicar com o botão direito do mouse no projeto no explorador de pacotes e clicar na opção find bugs.

Após o lançamento, o Eclipse mostra os resultados na janela Bug Explorer, conforme mostrado na captura de tela abaixo:

link:/wp-content/uploads/2016/11/bug_explorer.png [imagem:/wp-content/uploads/2016/11/bug_explorer-300x82.png [imagem, largura = 688, altura = 188]] + A partir de versão 2, o FindBugs começou a classificar erros com uma escala de 1 a 20 para medir a gravidade dos defeitos:

Mais assustador : classificado entre 1 e 4.
Assustador : classificado entre 5 e 9.
Incomodador : classificado entre 10 e 14.
De preocupação : classificado entre 15 e 20.

Enquanto a classificação de erros descreve a gravidade, o fator de confiança reflete a probabilidade desses erros serem sinalizados como reais. A confiança foi originalmente chamada de prioridade , mas foi renomeada na nova versão.

Certamente, alguns defeitos podem estar abertos à interpretação e podem até existir sem causar nenhum dano ao comportamento desejado de um software. É por isso que, em uma situação do mundo real, precisamos configurar corretamente as ferramentas de análise estática, escolhendo um conjunto limitado de defeitos para ativar em um projeto específico.

3.3 Configuração do Eclipse

O plug-in FindBugs facilita a personalização da estratégia de análise de bugs, oferecendo várias maneiras de filtrar os avisos e limitar o rigor dos resultados. Você pode verificar a interface de configuração em Janela → Preferências → Java → FindBugs:

link:/wp-content/uploads/2016/11/fb_preferences-1.png [imagem:/wp-content/uploads/2016/11/fb_preferences-1-300x246.png [imagem, largura = 558, altura = 457] ]

Você pode desmarcar livremente categorias indesejadas, aumentar a classificação mínima para relatar, especificar a confiança mínima para relatar e personalizar marcadores para classificações de bugs - Aviso, Informações ou Erro.

O FindBugs divide os defeitos em várias categorias:

Correção - reúne erros gerais, por exemplo loops infinitos, uso inadequado de _equals () _, etc
Má prática , p. manipulação de exceções, fluxos abertos, comparação de cadeias, etc.
Desempenho , p. objetos ociosos
Correção multithread - reúne inconsistências de sincronização e vários problemas em um ambiente multithread
Internacionalização - reúne problemas relacionados à codificação e internacionalização de aplicativos
Vulnerabilidade de código malicioso - reúne vulnerabilidades no código, por exemplo trechos de código que podem ser explorados por possíveis invasores
Segurança - reúne falhas de segurança relacionadas a protocolos específicos ou injeções de SQL
Dodgy - reúne odores de código, por exemplo comparações inúteis, verificações nulas, variáveis não utilizadas, etc.

Na guia Configuração do detector , você pode verificar as regras que você deve respeitar em seu projeto:

link:/wp-content/uploads/2016/11/fb_preferences_detector-1.png [imagem:/wp-content/uploads/2016/11/fb_preferences_detector-1-300x240.png [imagem, largura = 593, altura = 474] ]

*O atributo speed reflete o custo da análise* . Quanto mais rápido o detector, menores os recursos consumidos para realizá-lo.

Você pode encontrar a lista exaustiva de erros reconhecidos pelo FindBugs em http://findbugs.sourceforge.net/bugDescriptions.html [página oficial da documentação] .

No painel Filtrar arquivos , você pode criar filtros de arquivos personalizados, para incluir/excluir partes da base de código. Esse recurso é útil - por exemplo - quando você deseja impedir o código “não gerenciado” ou “lixo”, os defeitos aparecem nos relatórios ou podem excluir todas as classes do pacote de teste, por exemplo.

4. Plugin FindBugs IntelliJ IDEA

====* 4.1 Instalação *

Se você é um fã do IntelliJ IDEA e deseja começar a inspecionar o código Java usando o FindBugs, pode simplesmente pegar o pacote de instalação do plug-in no site oficial do JetBrains e extraia-o para a pasta% INSTALLATION_DIRECTORY%/plugins. Reinicie o seu IDE e você estará pronto.

Como alternativa, você pode navegar para Configurações → Plugins e procurar em todos os repositórios o plugin FindBugs.

No momento da redação deste artigo, a versão 1.0.1 do plug-in IntelliJ IDEA havia acabado de sair,

Para garantir que o plug-in FindBugs esteja instalado corretamente, verifique a opção “Analyze project code” em Analyze → FindBugs.

====* 4.2 Navegação de relatórios *

Para iniciar a análise estática no IDEA, clique em "Analyze project code", em Analyze → FindBugs, e procure o painel FindBugs-IDEA para inspecionar os resultados:

link:/wp-content/uploads/2016/11/Spring-rest-analysis-1.png [imagem:/wp-content/uploads/2016/11/Spring-rest-analysis-1-300x139.png [imagem, largura = 537, altura = 249]]

Você pode usar a segunda coluna de comandos no lado esquerdo da captura de tela, para agrupar defeitos usando diferentes fatores:

Agrupe por uma categoria de bug.
Agrupe por uma turma.
Agrupe por um pacote.
Agrupe por uma classificação de bug.

Também é possível exportar os relatórios no formato XML/HTML, clicando no botão "exportar" na quarta coluna de comandos.

====* 4.3 Configuração *

As páginas de preferências do plug-in FindBugs no IDEA são bastante auto-explicativas:

link:/wp-content/uploads/2016/11/IntelliJ-Preferences-1-1.png [imagem:/wp-content/uploads/2016/11/IntelliJ-Preferences-1-1-278x300.png [imagem, largura = 530, altura = 572]]

Essa janela de configurações é bastante semelhante à que vimos no Eclipse, portanto, você pode executar todos os tipos de configuração de maneira análoga, a partir do nível de esforço de análise, classificação de bugs, confiança, filtragem de classes, etc.

O painel de preferências pode ser acessado dentro do IDEA, clicando no ícone “Preferências de plug-in” no painel FindBugs-IDEA.

===* 5. Análise de relatório para o projeto Spring-Rest *

Nesta seção, lançaremos alguma luz sobre uma análise estática feita no spring-rest projeto disponível no Github como exemplo:

link:/wp-content/uploads/2016/11/Spring-rest-analysis-2.png [imagem:/wp-content/uploads/2016/11/Spring-rest-analysis-2-300x139.png [imagem, largura = 494, altura = 229]]

A maioria dos defeitos é pequena - De preocupação, mas vamos ver o que podemos fazer para corrigir alguns deles.

*O método ignora um valor de retorno excepcional:*

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

Como você provavelmente pode adivinhar, o FindBugs está reclamando do fato de estarmos descartando o valor de retorno do método createNewFile () _. Uma possível correção seria armazenar o valor retornado em uma variável declarada recentemente e, em seguida, registrar algo significativo usando o nível de log DEBUG - por exemplo "_O arquivo nomeado não existe e foi criado com êxito" se o valor retornado for verdadeiro.

*O método pode falhar ao fechar o fluxo na exceção:* esse defeito específico ilustra um caso de uso típico para manipulação de exceções que sugere *sempre fechar fluxos em um bloco _finally_* :

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();
}

Quando uma exceção é lançada antes da instrução stream.close () _, o fluxo nunca é fechado, por isso é sempre preferível usar o bloco _finally \ {} _ para fechar os fluxos abertos durante uma rotina _try _/ catch_.

*Uma _Exception_ é capturada quando _Exception_ não é lançada* : Como você já deve saber, capturar _Exception_ é uma prática incorreta de codificação, o FindBugs acha que é necessário capturar uma exceção mais específica, para que você possa manipulá-la corretamente. Então, basicamente, manipulando fluxos em uma classe Java, capturar _IOException_ seria mais apropriado do que capturar uma exceção mais genérica.

*Campo não inicializado no construtor, mas desreferenciado sem verificação nula* : sempre é uma boa idéia inicializar campos dentro de construtores; caso contrário, devemos viver com a possibilidade de o código gerar um _https://docs.oracle.com/javase/7/docs/api/java/lang/NullPointerException.html[NPE}._ Portanto, é recomendável executar verificações nulas sempre que não tivermos certeza se a variável foi ou não inicializada corretamente.

6. Conclusão

Neste artigo, abordamos os principais pontos básicos para usar e personalizar os FindBugs em um projeto Java.

Como você pode ver, o FindBugs é uma ferramenta de análise estática poderosa, porém simples, que ajuda a detectar possíveis falhas de qualidade no sistema - se ajustadas e usadas corretamente.

Por fim, vale ressaltar que o FindBugs também pode ser executado como parte de uma ferramenta de revisão automática contínua de código, como* Sputnik *, que pode ser muito útil para dar muito mais visibilidade aos relatórios .

O código de exemplo que usamos para análise estática está disponível over no Github.

TOC

Introdução ao FindBugs