如何将java.util.logging.Logger覆盖到我的私有记录器中？

Question

I have code fetched from jar that uses java.util.logging.Logger .

Jar contains about 1000 logger usages and each class start from:

private static final Logger LOG = Logger.getLogger(SomeClass.class.getName());

I want to handle all logs there, means, to point them to my Logger usage and not to java.util.logging.Logger .

Therefore I wrote my own logger.

So instead:

LOG.log(Level.SEVERE, "Error sleeping", e);

I can write:

 MyLogger.toLog(TLogLevel.WFS_ERROR, "Monkey", "Error sleeping", e );

The problem is I need run over all java files and replace with mine.

Messy way, hmm

Does anyone know how can by easy way to convert java.util.logging.Logger to com.boo.MyLogger ?

Thanks,

Answer 1

The SLF4J project has a jul-to-slf4j bridge that can be used to redirect java.util.logging.Logger calls to SLF4J. You could use that (by making your MyLogger implement the interface defined by SLF4J).

Note that, however, unlike all other logging libraries, jul is hard-wired into the Java class libraries and cannot be bridged without a performance penalty.

Also, I don't know what you are doing with MyLogger, but usually there is no need to write your own. There are plenty of logging implementations to choose from, and they can be configured in many different ways. And even if you do have to write your own Logger implementation , you should use an existing interface (such as SLF4J which seems to most popular these days).

Answer 2

Take a look at SLF4J :

The Simple Logging Facade for Java or (SLF4J) serves as a simple facade or abstraction for various logging frameworks, eg java.util.logging, log4j and logback, allowing the end user to plug in the desired logging framework at deployment time.

Using that you could then also use logback (same author) to log to a common logging framework using the various bridges already available. Or, write your own, but either way you would not have to worry about replacing all that code...

Answer 3

Oracle's Java 7 Logger is configurable, its implementation is simply:

public static Logger getLogger(String name) {
    // This method is intentionally not a wrapper around a call
    // to getLogger(name, resourceBundleName). If it were then
    // this sequence:
    //
    //     getLogger("Foo", "resourceBundleForFoo");
    //     getLogger("Foo");
    //
    // would throw an IllegalArgumentException in the second call
    // because the wrapper would result in an attempt to replace
    // the existing "resourceBundleForFoo" with null.
    LogManager manager = LogManager.getLogManager();
    return manager.demandLogger(name);
}

So you can also via code set a logging level; besides declarative.

LogManager.getLogManager().getLogger(Logger.GLOBAL_LOGGER_NAME).setLevel(Level.INFO);

Lars Vogel has a nice page, also with its own Logger class.

All put together is quite workable, but maybe sometimes somewhat hard to understand.