Como encontrar código não utilizados / mortos em projetos java
https://stackoverflow.com/questions/162551
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Quais as ferramentas que você usa para encontrar código não utilizados / mortos em grandes projetos java? Nosso produto tem estado em desenvolvimento há alguns anos, e ele está ficando muito difícil de detectar manualmente o código que já não está em uso. Nós, contudo, tentar eliminar o máximo de código não utilizados possível.
As sugestões para estratégias / técnicas gerais (exceto ferramentas específicas) também são apreciados.
Editar: Note que já usam ferramentas de cobertura de código (Clover, IntelliJ), mas estes são de pouca ajuda. Código morto ainda tem testes de unidade, e mostra-se como abrangidas. Eu acho que uma ferramenta ideal seria identificar grupos de código que têm muito pouco outro código dependendo dele, permitindo docues inspeção manual.
Solução
Eu faria instrumento o sistema funcionando para manter registros de uso de código, e então começar a inspecionar código que não é usado por meses ou anos.
Por exemplo, se você estiver interessado em aulas não utilizados, todas as classes poderia ser instrumentado para registrar quando instâncias são criadas. E, em seguida, um pequeno script poderia comparar esses logs contra a lista completa de classes para encontrar aulas não utilizados.
É claro, se você for no nível do método que você deve manter o desempenho em mente. Por exemplo, os métodos só poderia registrar seu primeiro uso. Eu não sei como este é o melhor feito em Java. Temos feito isso em Smalltalk, que é uma linguagem dinâmica e, portanto, permite a modificação do código em tempo de execução. Nós instrumento todos os métodos com uma chamada de registro e desinstalar o código de registro depois de um método foi registado pela primeira vez, portanto, depois de algum tempo não mais penalidades de desempenho ocorrem. Talvez uma coisa semelhante pode ser feito em Java com bandeiras booleanas estáticos ...
Outras dicas
Um Eclipse plugin que funciona razoavelmente bem é não utilizado Código Detector.
Ele processa um projeto inteiro, ou um arquivo e mostra específica vários métodos de código não utilizados / mortos, bem como sugerindo mudanças visibilidade (ou seja, um método público que poderia ser protegido ou privado).
CodePro foi recentemente lançado pela Google com o projeto Eclipse. Ele é gratuito e altamente eficaz. O plugin tem um ' Localizar Dead Code ' recurso com um / muitos ponto de entrada (s). Funciona muito bem.
Eu estou surpreso ProGuard não foi mencionado aqui. É um dos mais maduro produtos ao redor.
ProGuard é um Java arquivo de classe shrinker livre, otimizador, obfuscator, e preverifier. Ele detecta e remove as classes não utilizados, campos, métodos e atributos. Ele otimiza bytecode e remove sem uso instruções. Ele renomeia as restantes classes, campos e métodos usando nomes sem sentido curtos. Finalmente, preverifies processado código para Java 6 ou Java Micro Edition.
Alguns usos de ProGuard são:
- Criação de um código mais compacto, para arquivos de código menores, transferência mais rápida através de redes, carregamento mais rápido e memória menor pegadas.
- Fazendo programas e bibliotecas mais difícil de fazer engenharia reversa.
- Listagem de código morto, para que ele possa ser removido do código-fonte.
- Retargeting e preverifying arquivos de classe existentes para Java 6 ou superior, para tirar o máximo partido do seu carregamento mais rápido da classe.
Aqui exemplo para a lista de código morto: https: // www. guardsquare.com/en/products/proguard/manual/examples#deadcode
Uma coisa que eu tenho sido conhecida a fazer em Eclipse, em uma única classe, é mudar todos os seus métodos para privado e depois ver o que as queixas que recebo. Para os métodos que são usados, isso vai provocar erros, e eu devolvê-los para o menor nível de acesso que posso. Para métodos que não são utilizadas, isso vai provocar avisos sobre métodos não utilizados, e aqueles podem ser excluídos. E como um bônus, muitas vezes você encontrar alguns métodos públicos que podem e devem ser feitas privado.
Mas é muito manual.
Nós começamos a usar encontrar bugs para ajudar a identificar algumas das funk na nossa base de código do alvo-rico ambiente para refatorações. Gostaria também de considerar Estrutura 101 para identificar pontos na arquitetura de sua base de código que são muito complicadas, então você sabe onde os pântanos são reais.
Em teoria, você não pode deterministically encontrar código não utilizado. Há uma prova matemática de isso (bem, este é um caso especial de um teorema mais geral). Se você está curioso, olhar para cima a suspensão problema.
Isso pode se manifestar em código Java de várias maneiras:
- Carregando classes com base na entrada do usuário, arquivos de configuração, as entradas de banco de dados, etc;
- código externo Carregando;
- Passando árvores de objeto para bibliotecas de terceiros;
- etc.
Dito isto, eu uso IDEA IntelliJ como meu IDE de escolha e tem ferramentas de análise extensivas para dependências findign entre os módulos, métodos não utilizados, os membros não utilizados, classes não utilizados, etc. Sua bastante inteligentes também como um método particular que isn' t chamada é marcado não utilizado, mas um método público requer uma análise mais extensa.
Em Eclipse Goto Windows> Preferências> Java> Compiler> Erros / Avisos
e mudar todos eles para erros. Corrigir todos os erros. Esta é a maneira mais simples. A beleza é que isso permitirá que você para limpar o código como você escreve.
Tela Código Eclipse:
IntelliJ tem ferramentas de análise de código para detecção de código que não é utilizada. Você deve tentar fazer o maior número de campos / métodos / classes como não-público possível e que vai aparecer mais não utilizados métodos / campos / aulas
Também gostaria de tentar localizar código duplicado como uma forma de reduzir o volume de código.
A minha última sugestão é tentar encontrar o código-fonte aberto, que se usado faria seu código mais simples.
O Structure101 perspectiva fatia vai dar uma lista (e gráfico de dependência) de quaisquer "órfãos" ou "órfão grupos " de classes ou pacotes que não têm dependências de ou para o cluster "main".
DCD não é um plugin para alguns IDE, mas pode ser executado a partir de formiga ou autônomo. Parece uma ferramenta estática e ele pode fazer o que PMD e FindBugs não pode . Vou tentar.
P.S. Como mencionado em um comentário abaixo, o Projeto vive agora na GitHub .
Existem ferramentas que código de perfil e fornecem dados de cobertura de código. Isso permite ver (como código é executado) como muito do que está sendo chamado. Você pode obter qualquer uma dessas ferramentas para descobrir a quantidade de código órfão que você tem.
- FindBugs é excelente para este tipo de coisa.
- PMD (Project Mess Detector) é outra ferramenta que pode ser usado.
No entanto, nem pode encontrar métodos públicos estáticos que não são utilizadas em um espaço de trabalho. Se alguém souber de tal ferramenta a então por favor me avise.
ferramentas de cobertura de usuário, como EMMA. Mas não é ferramenta estática (ou seja, ele necessita para realmente executar o aplicativo por meio de testes de regressão, e através de todos os casos de erro possível, que é, assim, impossível :))
Ainda assim, EMMA é muito útil.
ferramentas de cobertura de código, como Emma, ??Cobertura, e Clover, instrumento vontade seu código e registro que partes dele é invocado pela execução de um conjunto de testes. Isto é muito útil, e deve ser uma parte integrante do seu processo de desenvolvimento. Ela irá ajudá-lo a identificar o quão bem o seu conjunto de testes cobre o seu código.
No entanto, este não é o mesmo que a identificação de código morto real. É só identifica o código que é coberta (ou não coberta) por ensaios. Isto pode lhe dar falsos positivos (se os testes não cobrem todos os cenários), bem como falsos negativos (se o seu código de acesso testes que é na verdade, nunca usado em um cenário do mundo real).
Eu imagino que a melhor maneira de realmente identificar código morto seria instrumento de seu código com uma ferramenta de cobertura em um ambiente de corrida ao vivo e analisar a cobertura de código durante um período prolongado de tempo.
Se você está runnning em um balanceamento de carga ambiente redundante (e se não, por que não?), Então eu acho que faria sentido único exemplo instrumento uma de sua aplicação e configurar o balanceador de carga de tal forma que um acaso, mas pequena , parte de seus usuários executar em sua instância instrumentada. Se você fizer isso durante um período prolongado de tempo (para se certificar de que você cobriu todos os cenários de uso do mundo real - tais variações sazonais), você deve ser capaz de ver exatamente quais áreas do seu código são acessados ??sob uso e quais as partes do mundo real são nunca realmente acessado e código, portanto, mortos.
Eu nunca visto pessoalmente este feito, e não sei como as ferramentas acima mencionadas pode ser usado para instrumento e analisar o código que não está sendo invocado através de um conjunto de testes -. Mas estou certo de que pode ser
Netbeans aqui é um plugin para o NetBeans mortos detector código .
Seria melhor se pudesse ligar e destacar o código não utilizado. Você pode votar e comentar aqui: Bug 181458 - Encontrar não utilizados públicas classes, métodos, campos
Eclipse pode mostrar / code destaque que não pode ser alcançado. JUnit pode mostrar-lhe a cobertura de código, mas você precisa de alguns testes e tem que decidir se o teste relevante é ausente ou o código é realmente utilizada.
Eu encontrei ferramenta de cobertura de Clover que código e destaques do código que é usado instrumentos e que não é utilizada. Ao contrário do Google Analytics CodePro, ele também funciona para WebApplications (como por minha experiência e I podem estar incorretas sobre o Google CodePro).
A única desvantagem que eu notei é que ele não leva interfaces Java em conta.
Eu uso Doxygen para desenvolver um mapa chamada de método para localizar métodos que nunca são chamados. No gráfico você vai encontrar ilhas de aglomerados método sem chamadores. Isso não funciona para as bibliotecas desde que você sempre precisa começar de algum ponto de entrada principal.
