Java: How to get a class object of the current class from a static context?

Question

I have a logging function that takes the calling object as a parameter. I then call getClass().getSimpleName() on it so that I can easily get the class name to add to my log entry for easy reference. The problem is that when I call my log function from a static method, I can't pass in "this". My log function looks something like this:

public static void log(Object o, String msg){
  do_log(o.getClass().getSimpleName()+" "+msg);
}
public void do_something(){
  log(this, "Some message");
}

But let's say I want to log from a static function:

public static void do_something_static(){
  log(this, "Some message from static");
}

Obviously do_something_static() won't work because it is static and "this" is not in a static context. How can I get around this? And can I do it without using reflection (since I understand there is a lot of overhead involved and it might affect performance since I log a LOT of data)

I know I can probably hard-code the current class into the call somehow, but I'm sure that when I move the function to another class, I will forget to update the hard-coded reference and it will no longer be correct.

Thanks!

Answer 1

You should hard code the class into the call in the short term. If you think you will need this in a variety of places in your project, as it is static, you should encapsulate it and have it take the class as a param.

public static void do_something_static(Class callingClass){
  log(callingClass, "Some message from static");
}

Answer 2

Well, if you really don't want to hardcode something like ClassName.class, then you can try to infer the class by traversing the stacktrace. Fortunately, someone already did it : ). Also, consider using a logger that allows you to log something without specifying the calling object.

Answer 3

Alter method log to:

public static void log(Class c, String msg){
  do_log(c.getSimpleName()+" "+msg);
}

and if do_something_static is in class MyClassWithStatics then do_something_static would become:

public static void do_something_static(){
  log(MyClassWithStatics.class, "Some message from static");
}

Answer 4

querying the stacktrace maybe worty for your problem. You have 3 possible approachs.

Exception#getStackTrace()

Just create an exception instance and get the first frame:

static String className() {
    return new RuntimeException().getStackTrace()[0].getClassName();
}

Thread

Using Thread is even easier:

static String className2() {
    return Thread.currentThread().getStackTrace()[1].getClassName();
}

these two approachs have the disadvantage that you cannot reuse them. So you may want to define an Helper class for that:

class Helper {

    public static String getClassName() {
        return Thread.currentThread().getStackTrace()[2].getClassName();
    }
}

now you can obtain your class name programmatically, without hardcoding the class name:

public static void log(Object o, String msg){
    do_log(Helper.getCClassName() + "  " + msg);
}

Answer 5

Instead of "this" use "MyClass.class" and let your log method treat class objects without getClass().

But instead of doing this yourself, consider letting the log framework do it.

Answer 6

You could add "Class" as first parameter and overload the log method:

public class SomeClass {
    // Usage test:
    public static void main( String [] args ) {
        log( SomeClass.class, "Hola" );
        log( new java.util.Date(), "Hola" );
    }

    // Object version would call Class method... 
    public static void log( Object o , String msg ) {
        log( o.getClass(), msg );
    }
    public static void log( Class c ,  String message ) {
        System.out.println( c.getSimpleName() + " " + message );
    }
}

Output:

$ java SomeClass
SomeClass Hola
Date Hola

But it feels just bad to have the calling class passed as the first argument. Here's where object oriented model comes into play as opposite of "procedural" style.

You could get the calling class using the stacktrace, but as you metioned, there would be an overhead if you call it thousands of times.

But if you create is as class variable, then there would be only one instance for class if you happen to have 1,000 classes using this utility, you would have at most 1,000 calls.

Something like this would be better ( subtle variation of this other answer) :

public class LogUtility {

    private final String loggingFrom;

    public static LogUtility getLogger() {
        StackTraceElement [] s = new RuntimeException().getStackTrace();
        return new LogUtility( s[1].getClassName() );
    }

    private LogUtility( String loggingClassName ) {
        this.loggingFrom = "("+loggingClassName+") ";
    }

    public void log( String message ) {
        System.out.println( loggingFrom + message );
    }
}

Usage test:

class UsageClass {
    private static final LogUtility logger = LogUtility.getLogger();

    public static void main( String [] args ) {

        UsageClass usageClass = new UsageClass();

        usageClass.methodOne();
        usageClass.methodTwo();
        usageClass.methodThree();

    }
    private void methodOne() {
        logger.log("One");
    }
    private void methodTwo() {
        logger.log("Two");
    }
    private void methodThree() {
        logger.log("Three");
    }
}

OUtput

$ java UsageClass
(UsageClass) One
(UsageClass) Two
(UsageClass) Three

Notice the declaration:

....
class UsageClass {
    // This is invoked only once. When the class is first loaded.
    private static final LogUtility logger = LogUtility.getLogger();
....

That way, it doesn't matter if you use the "logger" from objectA, objectB, objectC or from a class method ( like main ) they all would have one instance of the logger.

Answer 7

Replace your static functions with non-static ones. Instead of

Utils.do_something(...)

do

new Utils().do_something(...)