Pergunta

Eu estou trabalhando em uma biblioteca onde queremos determinar o quanto da nossa biblioteca está sendo usado. OU SEJA queremos saber quantos métodos em nossa biblioteca são públicos, mas nunca sendo chamado.

Objetivo: Análise estática Determinar quantas linhas de código chamar cada método público no pacote Um no projeto atual. Se o número de chamadas é zero, o método deve ser reportada como tal.

Foi útil?

Solução

Eu acredito que você está procurando este plugin eclipse -> UCDetector

A partir da documentação (aviso de pagamento para segundo ponto)

  • Desnecessário código (mortos)
  • Código, onde a visibilidade pode ser alterado para protegido, padrão ou private
  • Métodos de campos, que podem ser final

Em escala maior, se você quer fazer Objeto Nível Análise Estática, olhar para esta ferramenta da IBM -> Análise estrutural para Java . É realmente útil para a análise de objeto de bibliotecas, APIs, etc.

Outras dicas

Não exatamente que você está procurando, mas:

Algo semelhante ser feito com as ferramentas de cobertura de código (como Cobertura ). Eles não fazem inspeção estática do código-fonte, mas o instrumento bytecode para reunir métricas em tempo de execução. Claro, você precisa para conduzir a aplicação de uma forma que exerce todo padrão de uso, e pode perder os caminhos de código mais raros.

Na frente de análise estática, talvez essas ferramentas podem ajudá-lo (os usos projeto Apache-los para verificar a compatibilidade de API para novos lançamentos, parece que essa tarefa é algo relacionado ao que você está tentando fazer):

  • Clirr é uma ferramenta que verifica as bibliotecas Java para compatibilidade binária e fonte com versões mais antigas. Basicamente você dá dois conjuntos de arquivos jar e Clirr despeja uma lista de mudanças na API pública.
  • JDiff é um Javadoc doclet que gera um relatório HTML de todos os pacotes, classes, construtores, métodos e campos que tenham sido removidos, adicionados ou alterados de qualquer modo, incluindo a sua documentação, quando duas APIs são comparados.

usar o cliente de chamadas reflexivos é um buraco na análise estática a considerar. Como não há nenhuma maneira de saber com certeza que um método particular não está sendo chamado via algum esquema de reflexão bizarro. Então, talvez uma combinação de tempo de execução e análise estática poderia ser melhor.

Eu não acho que você é capaz de medir como "muitas vezes" uma classe ou uma função é necessário.
Há algumas perguntas simples:

  • O que define, se uma estatística de uso de sua biblioteca de jogos é "normal" ou um "outlier"? É errado matar-se no jogo com muita freqüência? Você usaria a classe "killScreen" com mais frequência como um bom jogador.
  • O que define "muito"? Tempo ou contagem de uso? POJOs irá consumir tempo raros, mas são usadas com bastante freqüência.

Conclusão:
Eu não sei o que você está tentando realizar.
Se você deseja exibir suas dependências de código, existem outras ferramentas para fazer isso . Se você está tentando medir a sua execução de código, existem ou benchmarks para Java. Se você é um geek estatística, você vai ser feliz com RapidMiner ;)

Boa sorte com isso!

Eu sugeriria JDepend mostra as dependências entre pacotes e classes, excelente para encontrar dependências cíclicas! http://clarkware.com/software/JDepend.html (Ele tem um eclipse plugin: http://andrei.gmxhome.de/jdepend4eclipse/

e também PMD para outras métricas http://pmd.sourceforge.net/

IntelliJ tem uma ferramenta para detectar métodos, campos, classe que pode ter modificadores mais restritas. É também um tem uma solução rápida para aplicar essas alterações que você pode economizar muito trabalho também. Se você não quer pagar por isso, você pode obter a licença eval de 30 dias, que é mais do que tempo suficiente para mudar seu código, não é algo que o seu precisa fazer muito frequentemente.

BTW: IntelliJ tem cerca de 650 inspeções de código para melhorar a qualidade do código, cerca de metade tem correções automáticas então eu sugiro que passar um par de dias usando-o para refatorar / arrumar seu código

.

Por favor, dê uma olhada Dead Code Detector . Se propõe a fazer apenas o que você está procurando:. Encontrar código não utilizado usando análise estática

Aqui está algumas listas de ferramentas de cobertura de código Java. Eu não usei qualquer um destes pessoalmente, mas pode você começar:

Proguard pode ser uma opção também ( http://proguard.sourceforge.net/ ):

"Alguns usos de ProGuard são:

  • ...
  • Listagem de código morto, para que ele possa ser removido do código-fonte.
  • ... "

Veja também http://proguard.sourceforge.net/manual/examples.html #deadcode

Você pode escrever seu próprio utilitário para que (dentro de uma hora depois de ler este) usando a biblioteca de análise ASM bytecode ( http: //asm.ow2.org ). Você precisará implementar um ClassVisitor e uma MethodVisitor. Você vai usar uma ClassReader para analisar os arquivos de classe em sua biblioteca.

  • visitMethod do seu ClassVisitor (..) será chamado para cada método declarado.
  • visitMethodInsn do seu MethodVisitor (..) será chamado para cada método chamado.

Manter um mapa para fazer a contagem. As chaves representam os métodos (veja abaixo). Aqui está algum código: 

class MyClassVisitor {
    // ...
    public void visit(int version, int access, String name, ...) {
        this.className = name;
    }
    public MethodVisitor visitMethod(int access, String name, String desc, ...):
        String key = className + "." + name + "#" + desc;
        if (!map.containsKey() {
            map.put(key, 0);
        }
        return new MyMethodVisitor(map);
    }
    // ...
}

void class MyMethodVisitor {
    // ...
    public visitMethodInsn(int opcode, String name, String owner, String desc, ...) {
        String key = owner + "." + name + "#" + desc;
        if (!map.containsKey() {
            map.put(key, 0);
        }
        map.put(key, map.get(key) + 1);
    }
    // ...
}

Basicamente é isso. Seu está começando o show com algo como isto: 

Map<String,Integer> map = new HashMap<String,Integer>();
for (File classFile : my library) {
    InputStream input = new FileInputStream(classFile);
    new ClassReader(input).accept(new MyClassVisitor(map), 0);
    input.close();
}
for (Map.Entry<String,Integer> entry : map.entrySet()) {
    if (entry.getValue() == 0) {
        System.out.println("Unused method: " + entry.getKey());
    }
}

Aproveite!

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top