Methoden Rückverfolgung Methodenaufruf

[ichwilleinennam]

Hallo zusammen,

ist es möglich herauszufinden aus welcher Methode und Klasse heraus eine Methode aufgerufen wurde, ohne Code in der aufrufenden Klasse ändern zu müssen.


Mit freundlichen Grüßen

 

[stone71]

Du solltest am Anfang der Methode einen Breakpoint setzen und dies dann Debuggen. Wenn dieser Punkt erreicht wird, dann sieht Du aus welcher Klasse der Aufruf kam. Eine andere Möglichkeit ist die References zu prüfen, wenn Du Dich zum Beispiel in Eclipse befindest.

 

[pl4gu33]

du kannst dafür den DeBug- Modus benutzen .... du setzt einen Haltepunkte in der Methode und siehst dann dort, wer die Methode aufgerufen hat.

Allgemein kannst auch auf die Methode klicken und mit Strg+Alt+H die History aufrufen und siehst alle Klasse und Methoden, die die Methode aufrufen in Eclipse

 

[ichwilleinennam]

Danke erstmal für die Antworten,

leider zielen diese etwas an meiner eigentlichen Frage vorbei. Ich weiß wie ich den Debugger benutze.


Ich suche allerdings zur Zeit nach einer Lösung im Quellcode auf den Namen und die Klasse der aufrufenden Methode zugreifen zu können. Kennt jemand da eine Möglichkeit?

Mfg

 

[SlaterB]

ohne externe Tools im einfachen Code für ganz schnelle Tests am kürzesten
new Error("test").printStackTrace();

edit:
kompliziertes kommt gleich noch

edit:
ich habe als Hilfsmethode:

in Helper-Klasse:

    public static String getFilteredFirstCaller()   {
        String info = ":: ";
        StackTraceElement[] stArray = Thread.currentThread().getStackTrace();
        if (stArray == null || stArray.length < 1) return info;
        for (StackTraceElement ste : stArray)   {
            String className = ste.getClassName();
            // nach erster interessanter Klasse suchen
            if (!className.startsWith("...Helper") && ...)   {
                info += className + "." + ste.getMethodName() + "(" + ste.getFileName() + ":" + ste.getLineNumber() + ")";
                break;
            }
        }
        return info;
    }

diese Formatierung ist für Eclipse-Konsole hilfreich um dann per Mausklick wie bei Exceptions in entsprechende Klasse springen zu können,
statt Klassenname anzuschauen kann man auch gleich auf 2., 3. oder 4. Element im Array gehen, ausprobieren

 

[Asgar13]

Welche IDE?

Bei Idea klick man auf den Methodennamen und drückt Alt+F7, ein paar mal bestätigen und man hat die Aufrufer.

 

[ichwilleinennam]

Danke SlaterB, das probiere ich gleich mal aus

 

[stone71]

Wahrscheinlich habe ich es nicht verstanden, aber bei Methoden in Eclipse, geht man zu dem Methodennamen, rechte Maustaste, References, dann auf den Bereich, so zum Beispiel Workspace und dann werden die aufrufenden Klassen gezeigt.

 

[Marco13]

ohne externe Tools im einfachen Code für ganz schnelle Tests am kürzesten
new Error("test").printStackTrace();

Mach ich auch manchmal... und insgeheim schäme ich mich immer ein bißchen dafür Aber ist halt praktisch

 

[Andi_CH]

ohne externe Tools im einfachen Code für ganz schnelle Tests am kürzesten
new Error("test").printStackTrace();

Also ich finde das da sieht einfacher aus

package com.javaforum;

public class Test1 {
	
	private void fktA() {
		fktB();
	}
	private void fktB() {
		fktC();
	}
	private void fktC() {
		fktD();
	}
	private void fktD() {
		fktE();
	}
	private void fktE() {
		fktF();
	}
	private void fktF() {
		try {
			throw new Exception();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) {
		Test1 t1 = new Test1();
		t1.fktA();
		t1.fktD();
	}
}

 

[stone71]

Danke SlaterB, das probiere ich gleich mal aus

Des Weiteren würde mir dies aber doch auch das Debuggen zeigen??? Ich sehe doch immer wo meine Methode aufgerufen wurde.

 

[SlaterB]

nicht neidisch sein, Debugger sind immer Ansichtssache, der Code muss dafür anhalten, 50 Aufrufe etwa einer Rekursion sind mühsam,
ein Klick, 3 sec lang 17 fragliche Stellen durchlaufen lassen und danach 100 Zeilen Log anschauen hat auch seine Reize

kann man auch mit dem übernächsten Test am nächsten Tag noch vergleichen

 

[stone71]

Stimmt, akzeptiere diese Einwand... Dann soll man eben logs lesen Dies mache ich auch und threads oder ähnlichen Sachen auch sinnvoll, aber vor allen Dingen im Fehlerfall, ist der Debug-Mode schon nicht schlecht

 

[ichwilleinennam]

Danke Andi_CH , deine Lösung habe ich jetzt eingebaut.

 

[SlaterB]

diese 5 Zeilen sollen schöner sein als eine Zeile? na von mir aus

 

[Andi_CH]

Schönheit ist Geschmackssache

Aber ich gebe zu, dass ich vor lauter kompliziertem Javacode deinen Einzeiler übersehen habe!
Da stand doch noch

ohne externe Tools im einfachen Code für ganz schnelle Tests am kürzesten

new Error("test").printStackTrace();

und der ist wirklich elegant - nur wenn der schon im Original in Java-Tags gestanden hätte, dann hätte ich den nicht übersehen


Debugger sind gut, so lange man ein 1-Thread-System hat, das sehr tolerant programmiert ist.
Debugging eines Systemes in dem jeder Thread einen Timer als Überwachung drin hat und zickig reagiert wenn mal keine Reaktion kommt, ist nahzu unmöglich.
Auch Echtzeitsysteme ... na ja ... da müsste auch gleich die Uhr anhalten.

Ich würde mir schon lange einen Debugger wünschen, der alle Threads des Systemes anhält wenn einer in einen Breakpoint läuft. (Genau so wie ich objektspezifische Breakpoints möchte - also Break nur dann wenn genau in DIESEM Objekt etwas getan wird)