Checkstyle vs. PMD

Estamos introduzindo ferramentas de análise estática no sistema de construção de nosso produto Java. Estamos usando o Maven2, portanto, Checkstyle e integração PMD vêm de graça. No entanto, parece que há uma grande sobreposição de funcionalidade entre essas duas ferramentas, em termos de aplicação de regras básicas de estilo.

Há algum benefício em utilizar ambos? Não quero manter 2 ferramentas se uma funcionar. Se escolhermos um, qual devemos usar e por quê?

Também estamos planejando usar FindBugs. Existem outras ferramentas de análise estática que devemos examinar?

Atualização: o consenso parece ser que o PMD é preferível ao CheckStyle. Não vejo uma razão sólida para usar os dois e não quero manter 2 conjuntos de arquivos de regras, então provavelmente iremos focar exclusivamente no PMD. Também vamos trazer FindBugs e, talvez, eventualmente, Macker para impor regras de arquitetura.

Você definitivamente deve usar FindBugs . Na minha experiência, a taxa de falsos positivos é muito baixa, e mesmo os avisos menos críticos que ela relata valem a pena abordar até certo ponto.

Quanto ao Checkstyle vs. PMD, eu não usaria o Checkstyle porque ele se preocupa apenas com o estilo. Na minha experiência, Checkstyle reportará uma tonelada de coisas que são completamente irrelevantes. O PMD, por outro lado, também é capaz de apontar práticas de codificação questionáveis ​​e sua saída é geralmente mais relevante e útil.

Ambos os softwares são úteis. Checkstyle irá ajudá-lo durante sua programação, verificando seu estilo de codificação, isto é, chaves, nomenclatura, etc. Coisas simples, mas muito numerosas!

PMD irá ajudá-lo a verificar regras mais complicadas, como durante o design de suas classes, ou para problemas mais especiais, como implementar corretamente a função de clone. Simplesmente, o PMD irá verificar o seu estilo de programação

No entanto, ambos os softwares sofrem de regras semelhantes às vezes mal explicadas. Com uma configuração ruim, você pode verificar as coisas duas ou duas coisas opostas, por exemplo, "Remover construtores inúteis" e "Sempre um construtor".

Se escolhermos um, qual devemos usar e por quê?

Essas ferramentas não são concorrentes, mas complementares e devem ser utilizadas simultaneamente.

O tipo de convenção (Checkstyle) é a cola que permite que as pessoas trabalhem juntas e liberem sua criatividade, em vez de gastar tempo e energia entendendo códigos inconsistentes.

Exemplos de estilos de verificação:

• Existe javadoc em métodos públicos?
• O projeto está seguindo as convenções de nomenclatura da Sun?
• O código foi escrito com um formato consistente?

enquanto o PMD lembra as más práticas:

• Pegando uma exceção sem fazer nada
• Ter código morto
• Muitos métodos complexos
• Uso direto de implementações em vez de interfaces
• Implementando o método hashcode () sem o método not equals (Object object)

fonte: http://www.sonarsource.org/what-makes-checkstyle-pmd-findbugs-and-macker-complementary/

Usamos ambos:

• Verifique o estilo para garantir que todos na equipe escrevam o código de maneira semelhante
• PMD para encontrar áreas de código problemáticas e próximos alvos de refatoração

Se o seu principal local de uso é durante o desenvolvimento em eclipse, então CodePro da Instantiations será o melhor. Anteriormente, era uma ferramenta comercial, mas agora o Google comprou o Instantiations, então o CodePro analytix é gratuito agora.

Confira http://code.google.com/javadevtools/download-codepro.html

Se você revisou as listas de regras Checkstyle, PMD e Findbugs, viu que todos os três fornecem uma saída valiosa e todos os três se sobrepõem até certo ponto e também trazem suas próprias regras exclusivas para a mesa. É por isso que ferramentas como o Sonar usam todos os três.

Dito isso, Findbugs tem as regras mais específicas ou de nicho (por exemplo, "Captura duvidosa de IllegalMonitorStateException" - com que frequência você provavelmente encontrará isso?), Portanto, pode ser usado com pouca ou nenhuma configuração e seus avisos devem ser levados a sério. Com Checkstyle e PMD, as regras são mais gerais e relacionadas ao estilo, portanto, devem ser usadas apenas com arquivos de configuração personalizados para poupar a equipe de uma avalanche de feedback irrelevante ("Tab char na linha 5", "Tab char na linha 6", "Tab char na linha 7" ... você entendeu). Eles também fornecem ferramentas poderosas para escrever suas próprias regras avançadas, por exemplo, a regra Checkstyle DescendentToken .

Ao usar todos os três (especialmente com uma ferramenta como Sonar), todos eles devem ser configurados separadamente (leva pelo menos alguns dias para cobrir todas as regras), prestando atenção para evitar a duplicação (todas as três ferramentas detectam que hashCode () foi sobrescrito e igual a () não, por exemplo).

Em resumo, se você considera a análise de código estático valiosa, rejeitar o valor que qualquer um dos três fornece não faz sentido, mas para usar todos os três, é necessário investir tempo para configurá-los para fornecer feedback utilizável.

Sonar (http://www.sonarsource.org/) é uma plataforma aberta muito útil para gerenciar a qualidade do código e inclui Checkstyle, PMD, Findbugs e muito mais.

Isso também indica que todas as 3 ferramentas têm o direito de existir ...

Ambas as ferramentas são configuráveis ​​e podem fazer praticamente as mesmas coisas. Dito isso, se estamos falando sobre coisas prontas para usar, há muitas sobreposições, mas também existem regras / verificações distintas. Por exemplo, Checkstyle tem suporte mais forte para verificar Javadoc e encontrar números mágicos, para citar alguns. Além disso, Checkstyle tem um recurso de "controle de importação" semelhante à funcionalidade do Macker (não usei o Macker).

Se há coisas importantes para você que o Checkstyle faz por padrão que o PMD não, você pode considerar uma configuração mínima do Checkstyle apenas com essas verificações. Em seguida, institua uma política de que a configuração Checkstyle não pode aumentar, simplesmente remova as verificações conforme você implementa uma funcionalidade semelhante com, digamos, regras PMD personalizadas.

Considere também que, se você decidir que o recurso "controle de importação" do Checkstyle cobre o que você deseja do Macker, poderá implementar o PMD / Checkstyle em vez do PMD / Macker. De qualquer forma, são duas ferramentas, mas com Checkstyle, você obteria o que o PMD não faz pronto para uso "de graça".

Checkstyle e PMD são bons na verificação de padrões de codificação e são fáceis de estender. Mas o PMD tem regras adicionais para verificar a complexidade ciclomática, complexidade Npath, etc, o que permite que você escreva um código saudável.

Outra vantagem de usar o PMD é o CPD (Copy / Paste Detector). Ele descobre a duplicação de código em projetos e não está restrito a JAVA. Ele também funciona para JSP. Neal Ford tem uma boa apresentação sobre Metrics Driven Agile Development , que fala sobre muitas ferramentas que são úteis para o desenvolvimento Java / Java EE

Acho que Checkstyle e PMD são os melhores para impor problemas de estilo e bugs de codificação simples e óbvios. Embora eu tenha descoberto que gosto de usar o Eclipse e todos os avisos que ele fornece melhor para esse propósito. Reforçamos as coisas usando preferências compartilhadas e marcando-as como erros reais. Dessa forma, eles nunca são verificados em primeiro lugar.

O que eu recomendo fortemente e com entusiasmo é usar FindBugs. Como funciona no nível do bytecode, pode verificar coisas que são impossíveis no nível da fonte. Enquanto ele expele seu quinhão de lixo, ele encontrou muitos bugs reais e importantes em nosso código.

E 10 anos depois ... Em 2018 eu uso todos eles Checkstyle, PMD e FindBugs.

Comece com FindBugs . Talvez adicione PMD e Checkstyle mais tarde.

Nunca aplique cegamente as regras padrão !

Passos:

• executar uma ferramenta com regras padrão em um projeto que tem muito código
• adapte as regras a este projeto, comente as regras inúteis com algumas notas
• concentre-se nas regras mais fáceis (NPE, verificações de logger, verificações de recursos não fechados, ...)
• execute algumas correções para regras que você considere valiosas (uma de cada vez!)
• faça isso para cada ferramenta, mas não todas de uma vez!
• repita este processo

Idealmente, cada projeto pode ter regras separadas. Gosto de executar as regras por meio da compilação (via plug-ins do maven) e falho em erros de regra quando sei que um projeto passa em todas as regras que defini. Isso força os desenvolvedores a agirem, porque os relatórios não são suficientes . Desse ponto em diante, seu projeto é praticamente à prova de balas e você pode até adicionar mais regras posteriormente e / ou escrever regras personalizadas.

Um ponto que não vi até agora é que existem plug-ins para IDEs que impõem conjuntos de regras CheckStyle em seu código, enquanto plug-ins PMD relatam apenas violações. Por exemplo, em um projeto de vários sites em várias equipes de programação, é importante aplicar os padrões ativamente, em vez de apenas reportar sobre eles.

Ambas as ferramentas têm plug-ins disponíveis para IntelliJ, NetBeans e Eclipse (em minha opinião, isso cobre a maioria dos usos). Não estou tão familiarizado com o NetBeans, então só posso comentar sobre IntelliJ e Eclipse.

De qualquer forma, os plug-ins PMD para IntelliJ e Eclipse irão gerar relatórios sob demanda sobre violações de PMD dentro da base de código do projeto.

Os plug-ins CheckStyle, por outro lado, destacarão as violações instantaneamente e podem (pelo menos para IntelliJ, tenho menos experiência com Eclipse) ser configurados para converter automaticamente alguns problemas (por exemplo, para 'OneStatementPerLine', colocará CR-LF entre as instruções, para 'NeedBraces', adicionará colchetes onde estão faltando, etc.). Obviamente, apenas as violações mais simples podem ser corrigidas automaticamente, mas ainda é uma ajuda em projetos legados ou em projetos localizados em vários locais.

'On demand' para PMD significa que o desenvolvedor deve decidir conscientemente executar o relatório. Considerando que as violações do Checkstyle são automaticamente relatadas a eles conforme se desenvolvem. Enquanto o PMD faz contêm um conjunto de regras mais extensa, em minha mente a enforecement automática / relatórios de violações em IDEs vale o incômodo de manter 2 conjuntos de regras.

Portanto, para qualquer projeto em que trabalho, usamos ambas as ferramentas, Checkstyle aplicado no IDE, PMD relatado no IDE e ambos relatados e medidos em compilações (por meio do Jenkins).

Dê uma olhada no qulice-maven-plugin que combina Checkstyle, PMD, FindBugs e alguns outros analisadores estáticos e os pré-configura. A beleza dessa combinação é que você não precisa configurá-los individualmente em cada projeto:

<plugin>
  <groupId>com.qulice</groupId>
  <artifactId>qulice-maven-plugin</artifactId>
  <version>0.15</version>
  <executions>
    <execution>
      <goals>
        <goal>check</goal>
      </goals>
    </execution>
  </executions>
</plugin>

Gostaria de repetir o comentário de que PMD é o produto mais atual para verificação de estilo / convenção Java. Com relação ao FindBugs, muitos grupos de desenvolvimento comercial estão usando Coverity.

PMD é o que encontro mais pessoas se referindo. Checkstyle era o que as pessoas se referiam há 4 anos, mas acredito que o PMD é mantido de forma mais contínua e o que outros IDEs / plug-ins optam por trabalhar.

Acabei de começar a usar Checkstyle e PMD. Para mim, PMD é mais fácil de criar regras personalizadas para coisas como se existe System.gc (), Runtime.gc (), contanto que você possa escrever a consulta XPath, o que também não é difícil de todo. No entanto, o PMD não me mostrou que tem o recurso de mostrar o número da coluna. Portanto, para coisas como verificar os limites das colunas. Você pode querer usar Checkstyle.

PMD é a melhor ferramenta quando comparado com estilos de verificação. Os checkstyles podem não ter a capacidade de analisar o código enquanto o PMD oferece muitos recursos para fazer isso! Offcourse PMD não lançou regras para javadoc, comentários, recuos e etc. E a propósito, estou planejando implementar essas regras ....... obrigado