Klassennamen im statischen Umfeld

[Andi_CH]

Ich kann nichts dafür, aber in der Software hier ist beinahe alles statisch.

Kann ich (z.B. für eine Log-Ausgabe) den Klassennamen ermitteln? (Es geht eigentlich nur um Faulheit ;-) copy paste der log-Funktionalitäten)

Ganz elegant wäre, wenn ich trotz ererbter log-Funktionen der Name der Klasse erhalte aus der ich "log" aufrufe.

Bis jetzt wird der Klassename als

private final static String = "BlaBla";

in jeder Klasse gespeichert und die log-Funktionen gezwungenermassen repliziert, da die Vererbung ja nicht richtig klappt und änderungssicher ist das definitv auch nicht.

String s = (new Test3()).getClass().getName();

erachte ich irgendwie als suboptimal

(Nein, JLog oder was auch immer kommt nicht in Frage, das würde einen kompletten Systemumbau bedeuten und dafür bekomme ich kein grünes Licht :-( )

 

[Michael...]

String s = (new Test3()).getClass().getName();

erachte ich irgendwie als suboptimal

String s = Test3.class.getName();

würde Dir zumindest das erzeugen eines Objektes ersparen ;-)
Aber was wirklich besseres fällt mir grad nicht ein...

 

[Tomate_Salat]

hmm, für ganz faule: du könntest den StackTrace dafür nutzen: http://www.java-forum.org/allgemeine-java-themen/96337-rueckverfolgung-aufrufes.html#post612226

 

[MarderFahrer]

Meine Implementation zu diesem Thema benutzt ebenfalls den Stacktrace um an den Klassennamen zu kommen.

// Trick to get the class name in a static way
Exception e = new Exception();
StackTraceElement[] sTrace = e.getStackTrace();
// sTrace[0] will be always there
String className = sTrace[0].getClassName();

Nicht sehr elegant aber erfüllt seinen Zweck. 😀

 

[Murray]

Anstatt aus der Exception sollte man sich den Stack-Trave m.E. besser über

Thread.currentThread().getStackTrace()

holen.

Ganz ohne den Stack-Trace kommt man aus, wenn man eine anonymous inner class verwendet:

String ownClsName = new Object(){}.getClass().getEnclosingClass().getName();

Ob das aber "billiger" ist als der Weg über den Stack-Trace, müsste man ggfs. (wenn die Stelle wirklich als performance-kritisch erkannt worden ist) analysieren; schließlich muss auch hier ein Objekt instanziiert und später wieder collected werden.

 

[Andi_CH]

String s = Test3.class.getName();

würde Dir zumindest das erzeugen eines Objektes ersparen ;-)
Aber was wirklich besseres fällt mir grad nicht ein...

Hi hi - da bin ich reingerannt - im Zuge von Refactoring werden einige Klassen auseinandergerissen und der Originalname bleibt der gemeinsamen Vaterklasse - Test3 gibt es aber immer noch.
Abgesehen davon: Wenn ich den Klassennamen verwenden muss um an den Klassennamen zu kommen .... na ja muss wohl nicht weitertippen 🙂

Ganz elegant wäre halt schon "this".className() .... (logisch, dass es "this" in diesem Kontext nicht gibt.)

Werde wohl den Stacktrace verwenden - geloggt wird hier eigentlich nur in Fehlerfällen und während der Entwicklung - ansonsten ist das per boolean unterdrückt.

 

[Tomate_Salat]

wäre soetwas eine Lösungsmöglichkeit:

public class App 
{
	public static void main(String[] args)
	{
		Log.info("Hallo welt");
		Demo.doIt();
		Demo demo=new Demo();
		demo.doItInit();
		Log.print();		
	}
}

class Demo
{
	public static void doIt()
	{
		Log.info("test");
	}
	
	public void doItInit()
	{
		Log.info("do ist init");
	}
}

class Log
{
	private StringBuilder log=new StringBuilder();

	private static Log logger=new Log();
	
	public static void info(String text)
	{					
		StackTraceElement caller=Thread.currentThread().getStackTrace()[2];
		
		if(caller!=null) {
			logger.log.append(
				"info|" + caller.getClassName() +  "|" + text + "\n"
			);
		}
	}
	
	public static void print()
	{
		System.out.println(logger.log.toString());
	}
}

Ausgabe:

info|inf.test.App|Hallo welt
info|inf.test.Demo|test
info|inf.test.Demo|do ist init

?

 

[Andi_CH]

An so etwas ähnlichem bin ich gerade dran.

Das ist mehr als Dokumentation für die "Nachwelt" gedacht ;-)

Interessant ist die Tatsache, dass die Exception nur einen Eintrag im StackTraceElement[] liefert (Der zweite der unten gezeigten), der Thread hingegen zwei. Ich werde wohl nach ".java:" suchen

StackTraceElement[] steArr = Thread.currentThread().getStackTrace();
for (StackTraceElement ste : steArr) {
	System.out.println("----------------------------------------------");
	System.out.println("ste         = " + ste);
	System.out.println("ClassName   = " + ste.getClassName());
	System.out.println("FileName    = " + ste.getFileName());
	System.out.println("LineNumber  = " + ste.getLineNumber());
	System.out.println("MethodeName = " + ste.getMethodName());
}

----------------------------------------------
ste         = java.lang.Thread.getStackTrace(Unknown Source)
ClassName   = java.lang.Thread
FileName    = null
LineNumber  = -1
MethodeName = getStackTrace
----------------------------------------------
ste         = com.javaforum.test.ShowClassname.main(ShowClassname.java:20)
ClassName   = com.javaforum.test.ShowClassname
FileName    = ShowClassname.java
LineNumber  = 20
MethodeName = main

 

[Murray]

Interessant ist die Tatsache, dass die Exception nur einen Eintrag im StackTraceElement[] liefert (Der zweite der unten gezeigten), der Thread hingegen zwei. Ich werde wohl nach ".java:" suchen

Damit würdest du dich darauf verlassen, dass der Bytecode auch solche Informationen enthält - was man beim Compiler mit -g:none allerdings unterdrücken kann. Daher wäre der Code darauf angewiesen, mit bestimmten Compileroptionen übersetzt zu werden.
Aber eigentlich musst du auch nichts suchen: der von Thread.getStackTrace() gelieferte Stack-Trace enthält eben immer am Anfang Thread.getStackTrace. Insofern kannst du davon ausgehen, dass die relevante Information eben bei Index 1 steht.

 

[Tomate_Salat]

dass die relevante Information eben bei Index 1 steht.

fast richtig, sie stehen bei [c]2[/c]. Denn bei index [c]0[/c] steht sowas wie:
[c]java.lang.Thread.getStackTrace(Unknown Source)[/c]
somit steht bei [c]1[/c] die Loggerklasse und bei [c]2[/c] die relevanten Informationen.

 

[Murray]

fast richtig, sie stehen bei [c]2[/c]. Denn bei index [c]0[/c] steht sowas wie:
[c]java.lang.Thread.getStackTrace(Unknown Source)[/c]
somit steht bei [c]1[/c] die Loggerklasse und bei [c]2[/c] die relevanten Informationen.

In deinem Beispiel, aber nicht in dem des TOs:

----------------------------------------------
ste         = java.lang.Thread.getStackTrace(Unknown Source)
ClassName   = java.lang.Thread
FileName    = null
LineNumber  = -1
MethodeName = getStackTrace
----------------------------------------------
ste         = com.javaforum.test.ShowClassname.main(ShowClassname.java:20)
ClassName   = com.javaforum.test.ShowClassname
FileName    = ShowClassname.java
LineNumber  = 20
MethodeName = main

 

[Tomate_Salat]

Achso ja, ich bin davon ausgegangen, dass der TO es in einer Form verwenden will, wie in meiner Methode. Nach dem Beispiel hattest du dann natürlich recht.

 

[Andi_CH]

Das Thema ist wohl soeben gestorben :-(

Erst mal Dampf ablassen:

Es ist zum Kotzen. Verd... warum haben die Javaentwickler Vererbung nicht auch im statischen Umfeld korrekt implementiert ???:L

Ich wollte das alles in der Vaterklasse implementieren und dann auf der Subklasse aufrufen

Das Schei.... Java merkt das nicht und liefert mir den Namen der Vaterklasse.

EDIT: Stimmt nicht alles! Siehe weiter unten.

 

[Tomate_Salat]

Verstehe ich jz nicht so ganz. Meinst sowas in der Art:

class SLogger
{
	private StringBuilder logs=new StringBuilder();
	
	public void printMe()
	{
		System.out.println(logs.toString());
	}
	
	public void info()
	{
		logs.append(this.getClass() + "\n");
	}
}

class MyLogger extends SLogger
{
	
}

?

SLogger logger=new MyLogger();
logger.info();

Antwort:

class inf.test.MyLogger

ansonsten erklärs mal genauer, da findet sich doch bestimmt ein weg.

 

[Andi_CH]

Mea culpa - mein Frustausbruch war wohl verfrüht

public class ShowClassname {
	public static String getClassName() {
		StackTraceElement[] steArr = Thread.currentThread().getStackTrace();
		return steArr[steArr.length-1].getClassName();
	}
}

public class ShowClassnameSubclass extends ShowClassname {

	public static void main(String[] args) {
		System.out.println(getClassName());
	}
}

und da kommt ganz schön brav:

com.javaforum.test.ShowClassnameSubclass