java.util.logging.Logger不'；不尊重java.util.logging.Level？_Java_Logging

java.util.logging.Logger不'；不尊重java.util.logging.Level？

java logging

java.util.logging.Logger不'；不尊重java.util.logging.Level？,java,logging,Java,Logging,在纯Java SE 6环境中： Logger l = Logger.getLogger("nameless"); l.setLevel(Level.ALL); l.fine("somemessage"); Eclipse控制台中没有显示任何内容。l、信息（“”）和上面的工作正常，但任何低于正常的工作似乎都不正常。可能有什么问题？ TIA.即使记录器级别设置为ALL，ConsoleHandler（记录器上的默认处理程序）仍具有默认的信息级别。这来自JAVA_HOME/jre/lib中的defa

在纯Java SE 6环境中：

Logger l = Logger.getLogger("nameless");
l.setLevel(Level.ALL);
l.fine("somemessage");

Eclipse控制台中没有显示任何内容。l、信息（“”）和上面的工作正常，但任何低于正常的工作似乎都不正常。可能有什么问题？

TIA.

即使记录器级别设置为ALL，ConsoleHandler（记录器上的默认处理程序）仍具有默认的信息级别。这来自JAVA_HOME/jre/lib中的default logging.properties，而不是遍历所有处理程序并设置日志级别，我更喜欢只设置控制台处理程序的级别：

//get the top Logger
Logger topLogger = java.util.logging.Logger.getLogger("");

// Handler for console (reuse it if it already exists)
Handler consoleHandler = null;
//see if there is already a console handler
for (Handler handler : topLogger.getHandlers()) {
    if (handler instanceof ConsoleHandler) {
        //found the console handler
        consoleHandler = handler;
        break;
    }
}


if (consoleHandler == null) {
    //there was no console handler found, create a new one
    consoleHandler = new ConsoleHandler();
    topLogger.addHandler(consoleHandler);
}
//set the console handler to fine:
consoleHandler.setLevel(java.util.logging.Level.FINEST);

我工作场所的一位独立人士发现以下方法可行：

public class Foo {
    private final static Logger logger = Logger.getLogger(Foo.class.getName());
    public static final void main(String[] args) {
        ConsoleHandler ch = new ConsoleHandler();
        ch.setLevel(Level.FINEST);
        Foo.logger.addHandler(ch);
        Foo.logger.setLevel(Level.FINEST);
        Foo.logger.finest("test");
    }
}

如果您只是将根或处理程序设置为finest（独占），那么它就不起作用。当我将两者都设置为

FINEST

时，它就会工作。他的解释是：

记录器及其处理程序都有日志级别…过滤的顺序是记录器，然后是处理程序。这意味着它首先检查日志消息是否通过记录器过滤器，然后将消息发送到各个处理程序进行过滤

他用以下例子进一步解释了这一点：

Logger myLogger

的级别为

FINEST

，而单个

ConsoleHandler myHandler

的级别为

INFO

```
myLogger.fine（“foo”）
```
一条消息使其通过记录器的过滤器，但被处理程序的过滤器阻止…没有输出
```
myLogger.info（“foo”）
```
通过两个过滤器，并输出
```
foo
```

现在

Logger myLogger

的级别为

INFO

，一个

ConsoleHandler myHandler

的级别为

FINEST

```
myLogger.fine（“foo”）
```
a消息被记录器的筛选器停止，并且从未到达处理程序。。。没有输出
```
myLogger.info（“foo”）
```
通过两个过滤器，并输出
```
foo
```

现在

Logger myLogger

的级别为

FINEST

和单个

ConsoleHandler myHandler

的级别为

FINEST

```
myLogger.fine（“foo”）
```
通过两个过滤器，并输出“
```
foo
```
”
```
myLogger.info（“foo”）
```
通过两个过滤器，并输出
```
foo
```

// Set same level all loggers and handlers up to the parent level
// OFF,SEVERE,WARNING,INFO,CONFIG,FINE,FINER,FINEST,ALL
Logger logger = Logger.getLogger(this.getClass().getPackage().getName());
//Level level = Level.parse("FINEST");
Level level = logger.getLevel();
Logger tempLogger = logger;
while(tempLogger != null) {
   tempLogger.setLevel(level);
   for(Handler handler : tempLogger.getHandlers())
      handler.setLevel(level);
   tempLogger = tempLogger.getParent();
}

import java.io.PrintWriter;
import java.io.StringWriter;
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.logging.ConsoleHandler;
import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

public class Log {

    private static final Logger logger = Logger.getGlobal();

    private static Level logLevel = Level.INFO;
    static {
        // Remove all the default handlers (usually just one console handler)
        Logger rootLogger = Logger.getLogger("");
        Handler[] rootHandlers = rootLogger.getHandlers();
        for (Handler handler : rootHandlers) {
            rootLogger.removeHandler(handler);
        }

        // Add our own handler
        ConsoleHandler handler = new ConsoleHandler();
        handler.setLevel(logLevel);
        handler.setFormatter(new LogFormatter());
        logger.addHandler(handler);
        logger.setLevel(logLevel);
    }

    public static class LogFormatter extends Formatter {
        @Override
        public String format(LogRecord record) {
            String stackTrace = "";
            Throwable thrown = record.getThrown();
            if (thrown != null) {
                StringWriter stacktraceWriter = new StringWriter();
                try (PrintWriter writer = new PrintWriter(stacktraceWriter)) {
                    thrown.printStackTrace(writer);
                }
                stackTrace = stacktraceWriter.toString();
            }
            return ZonedDateTime.ofInstant(Instant.ofEpochMilli(record.getMillis()), ZoneId.of("UTC")).format(DateTimeFormatter.ISO_ZONED_DATE_TIME) + "\t" + record.getLevel()
                    + "\t" + record.getMessage() + "\n" + stackTrace;
        }
    }

    private static final String classname = Log.class.getName();

    private static String callerRef() {
        StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
        if (stackTraceElements.length < 4) {
            return "";
        } else {
            int i = 1;
            for (; i < stackTraceElements.length; i++) {
                if (stackTraceElements[i].getClassName().equals(classname)) {
                    break;
                }
            }
            for (; i < stackTraceElements.length; i++) {
                if (!stackTraceElements[i].getClassName().equals(classname)) {
                    break;
                }
            }
            if (i < stackTraceElements.length) {
                return stackTraceElements[i].toString();
            } else {
                return "[in unknown method]";
            }
        }
    }

    public static void setLogLevel(Level newLogLevel) {
        logLevel = newLogLevel;
        for (Handler handler : logger.getHandlers()) {
            handler.setLevel(newLogLevel);
        }
        Log.logger.setLevel(newLogLevel);
    }

    public static int getLevelNum() {
        return logLevel.intValue();
    }

    public static int getLevelNum(Level level) {
        return level.intValue();
    }

    public static void fine(String msg) {
        logger.log(Level.FINE, msg);
    }

    public static void info(String msg) {
        logger.log(Level.INFO, msg);
    }

    public static void warning(String msg) {
        logger.log(Level.WARNING, msg + "\t " + callerRef());
    }

    public static void error(String msg) {
        logger.log(Level.SEVERE, msg + "\t " + callerRef());
    }

    public static void exception(String msg, Throwable cause) {
        logger.log(Level.SEVERE, msg + "\t " + callerRef(), cause);
    }

}

导入java.io.PrintWriter；
导入java.io.StringWriter；
导入java.time.Instant；
导入java.time.ZoneId；
导入java.time.ZonedDateTime；
导入java.time.format.DateTimeFormatter；
导入java.util.logging.ConsoleHandler；
导入java.util.logging.Formatter；
导入java.util.logging.Handler；
导入java.util.logging.Level；
导入java.util.logging.LogRecord；
导入java.util.logging.Logger；
公共类日志{
私有静态最终记录器Logger=Logger.getGlobal（）；
私有静态级别logLevel=Level.INFO；
静止的{
//删除所有默认处理程序（通常只有一个控制台处理程序）
Logger rootLogger=Logger.getLogger（“”）；
Handler[]rootHandlers=rootLogger.getHandlers（）；
for（处理程序：根处理程序）{
removeHandler（handler）；
}
//添加我们自己的处理程序
ConsoleHandler handler=新的ConsoleHandler（）；
handler.setLevel（logLevel）；
setFormatter（新的LogFormatter（））；
addHandler（handler）；
logger.setLevel（logLevel）；
}
公共静态类LogFormatter扩展格式化程序{
@凌驾
公共字符串格式（日志记录）{
字符串stackTrace=“”；
抛出的Throwable=record.getThrown（）；
如果（抛出！=null）{
StringWriter stacktraceWriter=新StringWriter（）；
try（PrintWriter=新的PrintWriter（stacktraceWriter））{
printStackTrace（writer）；
}
stackTrace=stacktraceWriter.toString（）；
}
返回ZonedDateTime.ofInstant（Instant.ofEpochMilli（record.getMillis（）），ZoneId.of（“UTC”））.format（DateTimeFormatter.ISO_ZONED_DATE_TIME）+“\t”+record.getLevel（）
+“\t”+record.getMessage（）+“\n”+stackTrace；
}
}
私有静态最终字符串classname=Log.class.getName（）；
私有静态字符串callerRef（）{
StackTraceElement[]stackTraceElements=Thread.currentThread（）.getStackTrace（）；
if（stackTraceElements.length<4）{
返回“”；
}否则{
int i=1；
对于（；iimport java.io.PrintWriter;
import java.io.StringWriter;
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.logging.ConsoleHandler;
import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

public class Log {

    private static final Logger logger = Logger.getGlobal();

    private static Level logLevel = Level.INFO;
    static {
        // Remove all the default handlers (usually just one console handler)
        Logger rootLogger = Logger.getLogger("");
        Handler[] rootHandlers = rootLogger.getHandlers();
        for (Handler handler : rootHandlers) {
            rootLogger.removeHandler(handler);
        }

        // Add our own handler
        ConsoleHandler handler = new ConsoleHandler();
        handler.setLevel(logLevel);
        handler.setFormatter(new LogFormatter());
        logger.addHandler(handler);
        logger.setLevel(logLevel);
    }

    public static class LogFormatter extends Formatter {
        @Override
        public String format(LogRecord record) {
            String stackTrace = "";
            Throwable thrown = record.getThrown();
            if (thrown != null) {
                StringWriter stacktraceWriter = new StringWriter();
                try (PrintWriter writer = new PrintWriter(stacktraceWriter)) {
                    thrown.printStackTrace(writer);
                }
                stackTrace = stacktraceWriter.toString();
            }
            return ZonedDateTime.ofInstant(Instant.ofEpochMilli(record.getMillis()), ZoneId.of("UTC")).format(DateTimeFormatter.ISO_ZONED_DATE_TIME) + "\t" + record.getLevel()
                    + "\t" + record.getMessage() + "\n" + stackTrace;
        }
    }

    private static final String classname = Log.class.getName();

    private static String callerRef() {
        StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
        if (stackTraceElements.length < 4) {
            return "";
        } else {
            int i = 1;
            for (; i < stackTraceElements.length; i++) {
                if (stackTraceElements[i].getClassName().equals(classname)) {
                    break;
                }
            }
            for (; i < stackTraceElements.length; i++) {
                if (!stackTraceElements[i].getClassName().equals(classname)) {
                    break;
                }
            }
            if (i < stackTraceElements.length) {
                return stackTraceElements[i].toString();
            } else {
                return "[in unknown method]";
            }
        }
    }

    public static void setLogLevel(Level newLogLevel) {
        logLevel = newLogLevel;
        for (Handler handler : logger.getHandlers()) {
            handler.setLevel(newLogLevel);
        }
        Log.logger.setLevel(newLogLevel);
    }

    public static int getLevelNum() {
        return logLevel.intValue();
    }

    public static int getLevelNum(Level level) {
        return level.intValue();
    }

    public static void fine(String msg) {
        logger.log(Level.FINE, msg);
    }

    public static void info(String msg) {
        logger.log(Level.INFO, msg);
    }

    public static void warning(String msg) {
        logger.log(Level.WARNING, msg + "\t " + callerRef());
    }

    public static void error(String msg) {
        logger.log(Level.SEVERE, msg + "\t " + callerRef());
    }

    public static void exception(String msg, Throwable cause) {
        logger.log(Level.SEVERE, msg + "\t " + callerRef(), cause);
    }

}