Probekit er et rammeverk på Eclipse-plattformen som du kan bruke til å skrive og bruke prober.
Prober er Java™-kodefragmenter som kan settes inn i et program for
å gi informasjon om programmet mens det kjøres.
For å forstå prober begynner du med eksempelproben beskrevet her. Det er en grunnleggende probe som skriver ut
en melding som identifiserer alle metodene som bli kalt når programmet ditt kjøres.
Prober er definert av oppføringene i Probekit-redigeringsprogrammet. Dette eksempelet inneholder
et enkelt fragment,
fragmenter bestemmer hva proben gjør. Fragmentdefinisjoner omfatter:
- En
spesifikasjon av fragmenttypen. Dette fragmentet er et entry-fragment,
noe som betyr at det kjøres ved metodeinngangen.
- Dataelementer som fragmentet kan få tilgang til. Her gjør dataelementene det mulig for
fragmentet å få tilgang til klasse- og metodenavn.
- Java-kodesnutten som definerer probens logikk.
Dette fragmentet kaller
System.out.println for å vise klasse- og metodenavnet til metodene som kjøres.
Slik ser proben ut i Probekit-redigeringsprogrammet:

Når du har opprettet en probe ved hjelp av Probekit-redigeringsprogrammet, kan du ta den i bruk i class-
eller JAR-filene for prosjektet. Når du så kjører prosjektet, vil fragmentkoden kjøres sammen med programmet.
Her er en oversikt over hvordan du oppretter og bruker prober, inkludert informasjon om hvordan
Probekit hjelper deg:
- Du bruker Probekit-redigeringsprogrammet til å opprette prober i Probekit-kildefilene.
Probekit-kildefilene må ha filtypen .probe. De kan inneholde en eller flere prober, og hver probe kan
inneholde en eller flere probefragmenter.
- Probekit samler probefragmentene i et sett med Java-metoder, og kompilerer dem. Når Probekit kompilerer
en probe, kombineres probefragmentene med Java-standardtekst, og Java-kildekode genereres for en ny probeklasse. Funksjonene
som genereres fra probefragmentet blir vist som statiske metoder for den nye probeklassen.
- Når du tar i bruk en probe, oppgir du klasse- og JAR-målfiler som du ønsker å undersøke. BCI-motoren for
Probekit refererer til listen over tilgjengelige prober og målmønstrene deres og setter inn kall til
probefragmentmetoder i målprogrammene. Prosessen med å sette inn kallsetninger i målmetodene, kalles
instrumentering.
En klasse som inneholder en instrumentert metode kalles en probebehandlet klasse.
Dataelementene som et probefragment ber om (for eksempel metodenavnet og klassenavnet), sendes som
argumenter.
- Etter at applikasjonen er instrumentert. Probefragmentene vil kjøres når
programmet kjøres.
Typen probefragment bestemmer når et fragment kjøres. Du kan oppgi typer som gjør
at fragmentet kjøres ved disse anledningene:
- Ved metodeinngang.
- Ved metodeutgang (enten en vanlig avslutning eller som et resultat av et unntak).
- Ved unntaksbehandling, det vil si på begynnelsen av et catch-ledd eller på begynnelsen av et
finally-ledd, som blir kalt som et resultat av et unntak.
- Før den opprinnelige koden i klassens statiske initialiserer.
- Før hver utførbar kodeenhet (når kildekodeinformasjon er tilgjengelig).
- Når bestemte metoder blir kalt. (Da blir instrumenteringen utført ved kallstedet, ikke i den kalte metoden).
Probefragmenter kan få tilgang til dataelementer som gir forskjellig type informasjon om
applikasjonen ved punktet der de er satt inn. For eksempel:
- Pakke-, klasse- og metodenavn
- Metodesignatur
- this-objekt
- Argumenter
- Returverdi
Hvis du bare vil ta i bruk proben på bestemte klasser og metoder, oppgir du mål eller definerer filtre.
Du finner mer informasjon under Probemål og filtre.