Question

I’m currently writing a big project in java, with numerous classes, some classes are quiet small, that simply represent objects with only few methods.
I have a logger set in my main class, and it works fine.
I want to be able to use only one logger (with one console appender) with all the classes.
I tried to pass a reference to the logger to the different classes, but it doesn’t look right.
besides, sometimes I’m running tests on the classes without running main, and thus the logger is not initialized for the other classes.

What’s the best approach to accomplish that, I mean, how to log from different classes to one log, with no hard dependency between the classes and with the ability to use the log independently with each class ?

Answer 1

If I understand correctly, what you have at the minute is:

public class Main {
    public static final Logger LOGGER = Logger.getLogger(Main.class);
}

public class AnotherClass {
    public void doSomething() {
        Main.LOGGER.debug("value=" + value);
    }
}

or, you pass references to a logger into the constructors of the class.

Firstly, you can use one global logger by simply using the same value passed to Logger.getLogger, like:

public class Main {
    private static final Logger LOGGER = Logger.getLogger("GLOBAL");
}

public class AnotherClass {
    private final Logger LOGGER = Logger.getLogger("GLOBAL");

    public void doSomething() {
        LOGGER.debug("value=" + value);
    }
}

This uses exactly the same logger, Logger.getLogger returns the same object in both calls. You no longer have a dependency between the classes, and this will work.

The other thing I gather from your comments is that you are configuring by hand (using BasicConfigurator.configure. Most of the time this isn’t necessary, and you should be doing your configuration by simply adding a log4j.properties or log4j.xml to your classpath. In Eclipse this is done by adding it to src/ (or src/main/resources if you’re using maven). If you’re using junit, then add it to the test/ source directory (or src/test/resources with maven). This is a much better long term way of configuring log4j, because you don’t have to pass information between classes.

Also, the recommended way to use loggers is to pass the class to the Logger.getLogger(). In this way you can filter your output based upon the class name, which is usually much more useful than just having one global logger:

public class Main {
    private static final Logger LOGGER = Logger.getLogger(Main.class);
    public static final main(String[] args) {
        LOGGER.debug("started");
    }
}

public class AnotherClass {
    private final Logger LOGGER = Logger.getLogger(this.getClass());

    public void doSomething() {
        LOGGER.debug("value=" + value);
    }
}

Then in the log4j.properties, you can configure a single appender to one file.

# Set root logger level to DEBUG and its only appender to A1.
log4j.rootLogger=DEBUG, A1

# A1 is set to be a ConsoleAppender.
log4j.appender.A1=org.apache.log4j.ConsoleAppender

# A1 uses PatternLayout.
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n

Finally, it is not necessary to declare all of your loggers as static. This only makes a noticeable difference if you are doing lots[*] of object creation. Declaring your loggers as non-static fields allows you to use Logger.getLogger(this.getClass()); in which case adding a logger to a class becomes a cut and paste of a single line. This slf4j page contains a good explanation of the pros and cons. So use non-static fields unless you have a very good reason not to.

Cameron is right when he say that you should try and use slf4j if possible, it has one killer feature, you can use multiple logging frameworks with it.

[*] and I mean lots.