Using Log4j efficiently

Question

Hi,
I've been using Log4j, and I found it a little troublesome to declare an instance variable everywhere and pass the class name to it; like this:
public class UsesLogger {
     Logger logger = Logger.getLogger(this.class);
     public void log() {
          logger.debug("bla bla");
}So I thought I could create a wrapper class to encapsulate the logger. For instance:
public class MyLogger {
     public static void log(Class clazz, String message) {
          Logger logger = Logger.getLogger(clazz);
          logger.debug(message);
}But I also didn't like passing the class object every time I want to log a message. So the following came to my mind:
public class MyLogger {
     private static Exception ex = new Exception();
     public static void log(String message) {
          ex.fillInStackTrace();
          StackTraceElement[] ste = ex.getStackTrace();
          Logger logger = Logger.getLogger(ste[1].getClassName());
          //I even can add the method name to the message using ste[1].getMethodName()
          logger.debug(message);
}So the other classes do the following:
public class UsesLogger() {
     public void aMethod() {
          MyLogger.log("inside aMethod");
}My question is, is this approach efficient? especially that the ex.fillInStackTrace() method is synchronized, so it might be a bit costly.
Any ideas?
P.S: I'm not sure if this is the right thread to post in.

Answer 1

> > What is troublesome to you about this?
>
I'm not really sure, but I didn't like the idea of
repeating any piece of code anywhere.
That's a bit dogmatic, in my opinion. I think DRY is a good principle to follow, but declaring a Logger for a particular class isn't what I'd consider repeating code. If a class needs an instance of a Logger, I think it's perfectly appropriate to declare one (or have one injected -- that's for duffymo and the rest of the Spring zealots ;o)...
> In this case: including the Logger class and defining its variable
in every class that needs to log anything. That's why
I thought of an alternative to centralize the access
to the logger using my own utility class.
So my question remains: is this approach efficient?
I know these types of answers are unsatisfying, but it really depends on what criteria you're using to measure efficiency. In this case, I'd say not really. Your utility class is just adding another layer to the logging functionality. If you think you'll be changing logging frameworks often, it might be beneficial from a design standpoint to abstract out the logging, but I'd be surprised if you'd actually change the underlying logging implementation enough to warrant the new layer. I believe the impact is negligible to nonexistent from an application performance standpoint, but you could always measure it if you wanted.
But there are other options such as AOP, that may be able to provide you with "cross-cutting" logging functionality you're looking for without sullying your class definitions with logging code.
Cheers!
~