Wer ist Caller einer Methode/Prozedur -> Entscheidbar?

[hdi]

Hallo,

also es geht darum, ich wollte fragen ob es irgendeine Möglichkeit gibt, ausser die vordefinierten Log-Java-Klassen-Dingsn zu nutzen, also ganz generell, für eine Methode herauszufinden woher sie gecalled wurde?

Bsp für meinen Log:

In Zeile x der Klasse y rufe ich auf

log("Some text");

wobei diese Methode einer ArrayList<String> einen Eintrag hinzufügt. Nun ist die Frage ob sowas zu realisieren ist
für die Methode log wie (Pseudo-Code) :

public void log(String s){
   String caller = Whatever.whichLineIs_X();
   String line = IDontKnow.whichCallerIs_Y();
   String time = System.getCurrentTimeMillis();

   // Jetzt neuen Eintrag in der ArrayList<String>:
   add(time+" : "+caller+"("+line+")"+" --> "+s);
}

also ich rufe in Klasse "Class" in Zeile 9 auf:

log("Hallo")

und als String wird dann in der ArrayList gespeichert zB:

"12:03 : Class(9) --> Hallo"

gibt es solche vordefinierten System-Funktionen wo ich solche Infos abrufen kann, woher zB eine Methode
nun eigentlich aufgerufen wurde?
Oder wie könnte ich das realisieren?

(Ich weiss dass es irgendwas mit Logging in Java schon gibt, aber ich hatte das mal probiert und fand
es irgendwie total unübersichtlich bzw. für meine Anwendung total überladen)

thx

 

[shad0w]

Du willst den Stack Trace, oder?

StackTraceElement[] stea = Thread.currentThread().getStackTrace();
for (StackTraceElement ste : stea) {
    System.out.println(ste);
}

Die Klasse eines StackTraceElements kriegst du mit ste.getClassName();
Methodenname mit ste.getMethodName();
die Line Number mit ste.getLineNumber();

HTH

 

[shad0w]

Um es noch klarer zu machen:

public void log() {
        StackTraceElement ste = Thread.currentThread().getStackTrace()[2]; //evtl ArrayIndexOutOfBounds möglich...
        System.out.println("Class: " + ste.getClassName());
        System.out.println("Method: " + ste.getMethodName());
        System.out.println("Source file: " + ste.getFileName());
        System.out.println("Line: " + ste.getLineNumber());
}

Ist ein bisschen unsauber, aber für debugging-zwecke ok.

 

[hdi]

ah, prima dankeschön

aber eine Frage:

StackTraceElement ste = Thread.currentThread().getStackTrace()[2]; //evtl ArrayIndexOutOfBounds möglich..

warum wird das dritte Element des Arrays genommen? D.h. was ist denn dieser StackTrace genau, was is da
drin gespeichert, wieso [2] und weshalb und wann ist ein OutOfBounds möglich??

 

[HoaX]

was ein stacktrace ist und was eine ArrayIndexOutOfBoundsException ist verrät beides die zugehörige JavaDoc.

warum 2? ich vermute weil index0=getStrackTrace() und index1=currentThread() ist, aber das kannst du auch leicht prüfen

 

[shad0w]

Während die JVM ein Java-Programm ausführt, gibt es grob gesagt zwei Speicherbereiche: den Stack und den Heap. Auf dem Heap "leben" alle Objekte, während auf dem Stack die Lokalen Variablen (also die in einer Methode) "leben", z.B.

void meth(double d) { //d ist lokale Variable, ist auf dem Stack
int i = 0; //i ist lokale Variable, ist auf dem Stack
Object o = new Object(); //o ist Referenz auf Object, ist auf dem Stack, ABER das Object selbst ist auf dem Heap!!
}

Wenn du eine Methode aufrufst, und diese Methode dann wieder zu ihrem Caller zurückkehrt, muss die JVM ja wissen, wohin sie zurückkehren muss, d.h. wie der Zustand der Caller-Methode war! Z.B.:

class Test {

void meth1(int i) {
++i;
System.out.println(i);
}

void meth2() {
int i = 5;
meth1(i);
System.out.println(i);
}

public static void main(String[] args) {
new Test().meth2();
System.out.println("the end");
}

}

Zuerst wird main aufgerufen, der Stack sieht (grob) so aus:

main: String[] args == ?; nächste auszuführende zeile: 1

Zunächst mal ist args undefiniert. args wird dann mit den Argumenten gefüllt, die der User der JVM (java.exe) beim Aufruf übergibt:

main: String[] args == Ref. auf String[]; nächste auszuführende zeile: 1

Dann wird ein neues Object der Klasse Test auf dem Heap erzeugt, und meth2() aufgerufen. Dazu wird ein neues Stack Frame angelegt und auf den Stack "gepusht". Wir sind jetzt am Anfang von meth2, und der Stack sieht so aus (er "wächst" nach oben):

meth2: i == ?; nächste auszuführende zeile: 1
main: String[] args == Ref. auf String[]; nächste auszuführende zeile: 2

Nächstes Statement setzt i auf 5

meth2: i == 5; nächste auszuführende zeile: 2
main: String[] args == Ref. auf String[]; nächste auszuführende zeile: 2

Als nächstes wird meth1 aufgerufen, der Parameter i ist noch undefiniert:

meth1: i == ?; nächste auszuführende zeile: 1
meth2: i == 5; nächste auszuführende zeile: 3
main: String[] args == Ref. auf String[]; nächste auszuführende zeile: 2

Dann wird das Argument von meth2 übergeben, d.h. in den Parameter i geschrieben:

meth1: i == 5; nächste auszuführende zeile: 1
meth2: i == 5; nächste auszuführende zeile: 3
main: String[] args == Ref. auf String[]; nächste auszuführende zeile: 2

Dann kommt ++i:

meth1: i == 6; nächste auszuführende zeile: 2
meth2: i == 5; nächste auszuführende zeile: 3
main: String[] args == Ref. auf String[]; nächste auszuführende zeile: 2

Danach haben wir also die Ausgabe 6.

meth1: i == 6; nächste auszuführende zeile: 3
meth2: i == 5; nächste auszuführende zeile: 3
main: String[] args == Ref. auf String[]; nächste auszuführende zeile: 2

meth1 endet nun und ihr Stack Frame wird vom Stack wieder entfernt ("gepopt" ):

meth2: i == 5; nächste auszuführende zeile: 3
main: String[] args == Ref. auf String[]; nächste auszuführende zeile: 2

Wir sind dann wieder in meth2 (und hatten uns gemerkt, wo wir hier weiter machen müssen, nämlich bei Zeile 3), und erhalten die Ausgabe 5.

meth2: i == 5; nächste auszuführende zeile: 4
main: String[] args == Ref. auf String[]; nächste auszuführende zeile: 2

meth2 endet und ihr Stack Frame wird vom Stack gepopt.

main: String[] args == Ref. auf String[]; nächste auszuführende zeile: 2

Wir sind also wieder in main, es geht bei Zeile 2 weiter; Ausgabe "the end".

main: String[] args == Ref. auf String[]; nächste auszuführende zeile: 3

main endet also, der Stack ist nun leer und das Programm endet.

Der Stack Trace ist eine grobe Auflistung des Stacks, und darin kannst zu jedem Zeitpunkt sehen, welche Methode welche aufgerufen hat, um zur jetzigen Ausführungsstelle zu gelangen.

Warum jetzt das 3. Element des Stack Trace genommen werden muss, sollte klar sein. Im ersten (obersten) Element steht die aktuell ausgeführte Methode und das ist getStackTrace(). Im zweiten steht dann log(), weil von dort aus getStackTrace() aufgerufen worden ist. Und im dritten steht dann der Caller von log() und den wolltest du ja.

Es kann aber laut javadoc theoretisch sein, dass getStackTrace() nur ein leeres Array zurückgibt. Das bezieht sich aber vermute ich mal auf die jeweilige JVM. Wenn es also bei deiner JVM klappt, ist es ja für dein debugging ok. Ansonsten würde eine ArrayIndexOutOfBoundsException geworfen (die du auch abfangen könntest).

OK, soviel dazu. Noch Fragen?

 

[hdi]

danke für die ausführliche erklärung! mir war auch wichtig zu wissen wann ein oob geworfen werden kann, aber du sagst ja entweder immer oder nie, richtig?

damit bin ich beruhigt und verwende so meinen logger.

mfg

 

[shad0w]

Auf einem anderen PC (andere JVM...) könnte es aber theoretisch dazu kommen.
Also vielleicht lieber das Array auf ausreichende Länge testen.

StackTraceElement[] stea = Thread.currentThread().getStackTrace();
if (stea.length >= 3) {
   StackTraceElement ste = stea[2];
   ...
}