Detecção de chamada de um método

Programação Java
#1

Pessoal, tô com uma dúvida aqui. Pra começar deixa eu explicar o cenário…
Tenho uma classe Profiler que deve calcular o tempo gasto para um determinado método (que à priori não sabemos qual é) de uma determinada classe (ou de uma instância dessa classe, que à priori não sabemos qual é também).
Pensei em fazer com annotations. Então eu faria em uma classe A qualquer algo assim…

class A{
           @Profile public void doSomething(){
             ...
           }
}

E em algum lugar eu faria

class Profiler{
    public void watchClass(Class<?> c){
        for(Method m : c.getMethods()){ 
            if(m.isAnnotationPresent(Profile.class)){
                // AQUI EU NÃO SEI O QUE FAZER...
            }
        }
    }
}

Mas eu não sei detectar quando o método foi chamado e quando ele terminou sua execução.

Alguém tem alguma idéia de como fazer isso?

#2

achei interessante o q vc ta fazendo, vou dar uma dica, dê uma olhada no profilador jrat http://jrat.sourceforge.net/, nesse ele coloca as chamadas dos métodos e o tempo q cada um gasta.

#3

Pois é…o que esse framework faz é simplesmente marcar o início do método e o final dele, mas para isso é necessário alterar o código do método, exatamente o que eu queria evitar. Por isso minha idéia de usar annotations. Eu queria fazer um profiler (futuramente até um framework mesmo) que eu pudesse usar em qualquer método de qualquer classe simplesmente anotando-o…

#4

Dica: anotações são só isso - anotações.
Elas não acrescentam comportamento ao seu código POR SI SÓS. E é por isso que você vê que normalmente elas são meras “interfaces” marcadas com o símbolo “@”.
Para que as anotações sirvam para alguma coisa, você precisa que algum outro código leia essas anotações e acrescente algum comportamento a elas.
Por exemplo, em EJB3 você pode “injetar” um valor em um membro de uma classe (por exemplo, para fazer lookup de JNDI), mas isso é porque o application server é que carrega todas as classes e adiciona um monte de comportamentos transacionais etc.

O seu profiler, por exemplo, teria de carregar as classes, olhar as anotações, e inserir algum código que alterasse seu comportamento para poder fazer a medida de tempo. Essa inserção é um exemplo do que se pode fazer com AOP, por sinal, que usa uma técnica dessas.

#5

Existem três maneiras de você fazer isso:

  • Criar um compilador seu que adicione os bytecodes a um código Java pra fazer o profiling (é isso que ferramentas de AOP com o AspectJ fazem);
  • Criar um agente da JVM que vá instrumentar as classes -> http://weblogs.java.net/blog/kellyohair/archive/2005/05/bytecode_instru.html
  • Ou criar os seus objetos usando proxies em tempo de execução (que é cmo ferramentas como o Hibernate fazem)

Enfim, não é simples nem trivial, dá um bocado de trabalho.

#6

Que daria trabalho eu imaginava. Eu não conhecia a AOP. Vou começar a ler à respeito e vou implementar o meu profiler. Quando estiver pronto posto uma mensagem no fórum…

Obrigado pelas respostas…

:wink:

#7