O Probekit é uma estrutura na plataforma Eclipse utilizada
para gravar e utilizar probes. Probes são fragmentos de código Java™ que podem ser inseridos
em um programa para fornecer informações sobre o programa durante sua execução.
Para entender os probes, inicie com o probe de amostra descrito aqui. Ele é um
probe básico que imprime uma mensagem identificando todos os métodos chamados
quando o programa é executado.
Os probes são definidos por entradas feitas no editor Probekit. Esta
amostra contém um fragmento único;
fragmentos determinam o que o probe
faz. As definições de fragmento incluem:
- Uma especificação do tipo de fragmento. Esse fragmento é um fragmento entry, o que significa
que é executado no tempo de entrada do método.
- Itens de dados que o fragmento pode acessar. Aqui, os itens de dados permitem que o fragmento acesse nomes de classes e de métodos.
- O snippet do código Java que define a lógica do probe. Esse fragmento chama o System.out.println para exibir o nome da classe e dos métodos que são executados.
No editor Probekit, o probe é semelhante ao seguinte:

Após a criação de um probe que utiliza o editor Probekit, é possível aplicá-lo
aos arquivos de classe e jar para o projeto. Em seguida, quando o projeto for executado, o código de fragmento será executado juntamente com o programa.
Aqui está uma visão geral de como criar e utilizar probes, incluindo informações sobre como o Probekit ajuda você:
- O editor Probekit é utilizado para criar probes em arquivos de origem Probekit.
Os arquivos de origem Probekit devem ter a extensão .probe. Eles podem conter
um ou mais probes e cada probe pode conter um ou mais fragmentos de probe.
- O Probekit monta os fragmentos de probe em um conjunto de métodos Java e,
em seguida, compila-os. Quando o Probekit compila um probe, ele combina os fragmentos de probe com clichê Java padrão e gera código fonte Java para uma nova
classe de probe. As funções geradas dos fragmentos de probe aparecem
como métodos estáticos da nova classe com probe.
- Quando um probe é aplicado, você especifica a classe de destino e os arquivos jar que deseja investigar. O mecanismo BCI (Byte-Code Instrumentation) do Probekit faz referência à lista de probes disponíveis e seus padrões de destino e chamadas de inserções em métodos de fragmento de probe nos programas de destino. O processo de inserção de instruções
de chamada em métodos de destino é referido como instrumentação.
A classe que contém um método instrumentado é chamada de classe com probe.
Os itens de dados pedidos por um fragmento de probe (por exemplo, o nome do método
e o nome de classe) são transmitidos como argumentos.
- Após a instrumentação do aplicativo. Os
fragmentos de probe são executados quando o programa é executado.
O
tipo de fragmento de probe determina quando um fragmento é executado. É possível especificar tipos que fazem com que o fragmento seja executado nas seguintes ocasiões:
- Na hora da entrada do método.
- Na hora da saída do método (um retorno normal ou como o resultado de uma exceção).
- Na hora da rotina de tratamento de exceção. Isto é, na parte superior de uma cláusula catch, ou na parte superior de uma cláusula finally que é chamada como o resultado de uma exceção.
- Antes do código original no inicializador estático da classe.
- Antes de cada unidade de código executável (quando as informações de código fonte estão disponíveis).
- Quando métodos específicos são chamados. (Nesse caso, a instrumentação é feita
no site de chamada, não dentro do método chamado).
Os fragmentos de probe podem acessar itens de dados que fornecem vários tipos de informações
sobre o aplicativo no ponto em que são inseridos. Exemplo:
- Nome do pacote, classe e método
- Assinatura do método
- Objeto this
- Argumentos
- Valor de retorno
Para que o probe seja aplicado apenas a determinadas classes e métodos, especifique
os destinos ou configure filtros. Para obter informações adicionais, consulte Destinos e Filtros do Probe.