01、JUL日志(JDK自带日志框架，包含源码分析)

最新推荐文章于 2024-07-02 10:15:38 发布
最新推荐文章于 2024-07-02 10:15:38 发布
阅读量4.1k 收藏 5
点赞数 1
分类专栏： # 日志框架 文章标签： 日志框架 JUL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cl939974883/article/details/114860381
版权

文章目录

前言

在平时跟着教程做项目时，对于日志处理往往都是直接引入jar包，添加一个配置文件，对于日志的概念是十分模糊的，在寒假这段时间阅读书籍《Java核心技术》中的日志章节时，感觉并不是特别能够理解，接着就去b站搜了搜相关学习视频，搜到了黑马教程：黑马程序员java日志框架教程，全面深入学习多种java日志框架，花了半个月时间跟着视频学习并结合阅读其他博主的文章输出了多篇博客，也算是入了个门。

JUL是JDK自带的一个日志，对于日志的学习可以先从JUL入手，会有利于之后学习其他的日志框架。

所有博客文件目录索引(包含日志框架系列学习)：博客目录索引(持续更新)


一、JUL架构介绍

1.1、认识不同组件

image-20210225225731904

  • Logger与Handler都可设置过滤器Filter。

日志靠几个组件完成：

  • Loggers(日志记录器)：Logger通常是应用程序访问日志系统的入口程序，负责捕捉事件并将其发送给何时的Appender，其关联着一组Handler。
  • Appenders(输出源)：也称为Handlers，负责从Logger中取出日志消息，并使用Layouts(即Formatters)来格式化信息，然后将消息发送出去。一个logger可以有多个Handlers。可通过抽象类Handler下的具体实现类来决定输出位置，可输出多个位置。(控制台、文件或其他日志收集系统)
  • Layouts(布局器)：称为Formatters，负责对日志事件中的数据进行转换和格式化，通过使用抽象类Formatter下的指定实例来决定输出格式。
  • Filters：过滤器，根据需要来定制哪些日志会被记录或放过。

日志输出大致流程：

  1. 首先获取到Logger实例(默认日志等级为INFO)，该实例初始化会自动配置一个rootlogger(即它的父logger)，这个rootlogger中会有一个Consolehandler（用于将输出到屏幕）。
  2. 当使用Logger实例来调用方法输出日志时，首先会比对Logger本身的日志等级以及其过滤器。
  3. 接着会依次执行Logger实例中的handlers集合中的handler的publish()方法来输出日志信息，再此之前会与handler的日志等级作比较以及handler的filter过滤器。(若无handlers则跳过)
  4. 接着会根据Logger中的useParentHandlers布尔值来判断是否执行rootlogger中的handlers，操作如同3一样。

注意：Logger、Handler都有自己对应的日志level等级，初始默认都为INFO(800)。上面的流程初始阶段了解即可，对于详细的执行流程可见最后总结。


1.2、Logger

image-20210226230624352

Logger：是一个独立的类，它有一个子类为RootLogger（是LogManager类的内部类）

包含方法：

  • static Logger getLogger(String name)：获取一个Logger实例，其有参构造器为私有的。
  • void log(Level level, String msg)：用于打印日志信息，第一个参数为日志等级，第二个参数为日志信息。
  • void info(String msg)：打印Level.INFO级别的日志，实际上也是调用的log()方法。对应类似方法还有void warning(String msg)以及其他几个级别日志方法，更加方便打印日志。
  • void setUseParentHandlers(boolean useParentHandlers)：不使用默认自带的父类的handler。
  • void setLevel(Level newLevel)：设置日志等级。(默认为INFO)
  • void addHandler(Handler handler)：添加指定类型handler到handlers集合中。
  • void setFilter(Filter newFilter)：设置过滤器。

1.3、Handler

Handler：是一个抽象类，其中包含了set/get方法。可设置对应的Formatter、Filter，并自身带有对应的日志等级。

image-20210225232243613

相关实现类：用于输出到不同位置

  • StreamHandler：将日志通过OutputStream输出。
    • FileHandler：对应的OutputStream对象是FileOutputStream，能够将日志输出到文件。
    • ConsoleHandler：对应的OutputStream对象是System.err，会将日志输出到控制台。
    • SocketHandler：对应的OutputStream对象是Socket.getOutputStream()，会将日志输出到网络套接字。
  • MemoryHandler：将日志输出到一个内存缓冲区。

相关方法如下：

image-20210225232611663

  • synchronized void setLevel(Level newLevel)：设置Handler的日志等级。
  • synchronized void setFilter(Filter newFilter)：设置对应过滤器。
  • synchronized void setFormatter(Formatter newFormatter)：设置对应的格式化输出器。
  • synchronized void setEncoding(String encoding)：设置输出时的字符编码。
  • ErrorManager getErrorManager()：返回错误处理器，errorManager用来处理日志记录过程中发生的异常信息。
  • synchronized void publish(LogRecord record)：用于输出日志。

二、输出日志信息

JUL：JDK自带的日志实现依赖。

输出Info级别日志的三种方式：

@Test
public void test01(){
    //方式一：通过Logger.getLogger()方法获取日志记录对象
    //有参构造是全限定名
    Logger logger = Logger.getLogger("xyz.changlu.LogTest");
    logger.info("hello jul");

    //方式二：通用方法进行日志输出
    logger.log(Level.INFO,"自定义level为INFO，报错");

    //方式三：通过占位符方式
    String methodName = "test01";
    int msg = 2;
    logger.log(Level.INFO,"方法名{0},次数为{1}",new Object[]{methodName,msg});
}
  • 方式一的logger.info()内部实际上也是调用的log()方法(传INFO参数即可)。
  • log()方法第一个参数可以指定任意级别，后面msg则是输出到控制台信息的内容；重载方法也可以通过占位符方式填入指定要输出的信息。

image-20210225210205358

  • 第一行信息自带日期时间，包名及方法都是自动获取输出的；第二行的信息：后则是我们输入的msg。

三、自定义日志级别配置

3.1、认识Level类

Level：是一个枚举类(jdk1.5以前自定义枚举类)。

该类中包含七个不同等级的枚举实例，等级从高到低如下：

  • SEVERE：造成了程序的终止，可以使用该等级来记录。(value:1000)
  • WARNING：记录程序发生的一些问题，但问题不会造成程序终止。(value:900)
  • INFO：消息记录，记录数据库的连接信息，IO的传递信息等等。(value:800)
  • CONFIG：配置信息，加载了配置文件，读取配置的一些参数。(value:700)
  • 下面的三个都是用来Debug日志记录的消息，记录程序运行的状态跟执行的流程，参数的传递信息。这三者value级别的大小不同，FINE低一些，FINEST高一些，这三个开发中拿一个即可
    • FINE：(value:500)
    • FINER：(value:400)
    • FINEST：(value:300)
  • ALL：所有日志级别都能执行。(value：Integer.MIN_VALUE)
  • OFF：所有日志都不能执行。(value：Integer.MAX_VALUE)

源码实例：

image-20210225224753016

  • value是枚举实例在构造时填入的参数，决定了该Level实例的等级。

3.2、输出不同等级日志

上面枚举实例对应的value起到什么作用呢？

  • 用于当前logger实例的日志等级value值与调用log()方法输出指定日志级别的value值对比，有限制日志输出的作用。

我们看下面的例子：同时输出7个不同等级的日志

@Test
public void test01(){
    Logger logger = Logger.getLogger("xyz.changlu.test01");
    logger.severe("severe");
    logger.warning("warning");
    logger.info("info");
    logger.config("config");
    logger.fine("fine");
    logger.finer("finer");
    logger.finest("finest");
}

image-20210225213103607

  • 可以看到只有severe、warning、info等级能够输出msg信息。

那么为什么只输出了前三个等级的日志呢？我们看Logger源码：

//这里调用的是Logger类的log()
public void log(Level level, String msg) {
    if (!isLoggable(level)) {//首先会判断是否大于当前logger的等级，一旦小于返回isLoggable()返回false，则会执行return结束方法
        return;
    }
    //传入进来的level符合现有等级，那么就会执行下去通过handler进行输出信息
    LogRecord lr = new LogRecord(level, msg);
    doLog(lr);
}

public boolean isLoggable(Level level) {
    //这里levelValue是现有logger实例中的日志等级默认为INFO(800)，一旦小于800或等于Integer.MAX_VALUE(Level.OFF实例值)返回false
    if (level.intValue() < levelValue || levelValue == offValue) {
        return false;
    }
    return true;
}

能够看到在调用log()方法会去与自己本身的日志等级比较(初始默认为INFO)，所以只会输出INFO等级及以上。

我们可通过使用void setLevel(Level newLevel)来设置当前Logger的日志等级：

@Test
public void test01(){
    Logger logger = Logger.getLogger("xyz.changlu.test01");
    logger.setLevel(Level.WARNING);
    logger.severe("severe");
    logger.warning("warning");
    logger.info("info");
    logger.config("config");
    logger.fine("fine");
    logger.finer("finer");
    logger.finest("finest");
}

image-20210225231512933

  • 果然生效了，当设置Logger的当前日志等级为WARNING时，有对应效果。

那我们接着设置低级别的呢，如logger.setLevel(Level.CONFIG);，结果却并没有输出config的日志信息。其实原因是因为在进行日志输出时，并不仅仅会比对Logger本身的日志等级还会比其Handler的日志等级(初始默认也为INFO)。

若是我们想要输出所有日志等级的日志信息呢？

  • 将logger实例以及其handler的日志等级都设置为ALL即可。
public void test01(){
    Logger logger = Logger.getLogger("xyz.changlu.test01");
    //不执行rootlogger中的handlers
    logger.setUseParentHandlers(false);

    //自定义handler
    ConsoleHandler ch = new ConsoleHandler();
    ch.setFormatter(new SimpleFormatter());
    //将实例logger与对应handler都设置自定义的日志等级
    ch.setLevel(Level.ALL);
    logger.setLevel(Level.ALL);
    //将handler添加到logger的handlers集合中
    logger.addHandler(ch);

    //输出不同等级的日志
    logger.severe("severe");
    logger.warning("warning");
    logger.info("info");
    logger.config("config");
    logger.fine("fine");
    logger.finer("finer");
    logger.finest("finest");
}
  • 获得的logger实例中会有一个rootlogger，我们不自定义handler时，使用log()输出到控制台信息就是通过rootlogger中的ConsoleHandler输出的。
  • 第4行：我们使用该方法，传入false表示不执行rootlogger的handlers。
  • 第7行-13行：自定义handler并设置对应的转换器，接着将handler添加到logger中。其中有两个关键操作是设置自定义handler的日志等级以及设置logger实例的日志等级为Level.ALL。ALL对应的值为Integer.MIN_VALUE，所以所有级别的日志都能够输出显示。

3.2、自定义日志级别(console与文件输出)

@Test
public void test01() throws IOException {
    //输出日志到调试窗口
    Logger logger = Logger.getLogger("xyz.changlu.test01");
    //不将记录发送到父类处理器中
    logger.setUseParentHandlers(false);
    
    //1、定义窗口处理器ConsoleHandler
    ConsoleHandler ch = new ConsoleHandler();
    ch.setFormatter(new SimpleFormatter());//ConsoleHandler设置简单格式化输出器
    //2、定义文件处理器
    FileHandler fh = new FileHandler("jul.log");//指定路径(这里就是工程目录下)
    fh.setFormatter(new SimpleFormatter());
    //logger器中添加两个handler
    logger.addHandler(ch);
    logger.addHandler(fh);

    //输出的所有等级的日志信息到对应handler指定的区域(窗口以及文件)
    logger.severe("severe");
    logger.warning("warning");
    logger.info("info");
    logger.config("config");
    logger.fine("fine");
    logger.finer("finer");
    logger.finest("finest");
}
  • 第4、6行：通过Logger静态方法getLogger()会获取到一个Logger实例，它有个rootlogger，并自带handlers(ConsoleHandler，其使用的SimpleFormatter转换器)，由于不使用rootlogger中的handlers，所以我们调用setUseParentHandlers(false)方法传入参数false表示不执行rootlogger的handlers(防止重复打印)。
  • 第9、12行：就是设置不同的handler(输出到窗口、文件)，并将对应的转换器放置到hander中。
  • 第15、16行：将多个handler依次放置到logger实例中，一旦执行log()方法就会执行其所有的handler。

image-20210225235441297

image-20210225235457002


四、Logger的子父类关系

4.1、认识根Logger

探究初始创建Logger与根Logger的关系

JUL中的Logger之间存在子父类关系，当我们初始化一个Logger时，会默认创建一个rootlogger(一般情况下，除非下面①)

①直接创建一个rootlogger(name=""就是)：

①我们先创建一个顶层Logger(即name="")：

    @Test
    public void test01(){
        //传入空字符串获取Logger实例
        Logger logger2 = Logger.getLogger("");
        System.out.println(logger2);
        System.out.println(logger2.getParent());//打印其父类Logger
    }

image-20210226233921260

  • 当传入的name为""时，就会默认获取一个RootLogger实例，即为根Logger，因为是最顶层的了，所以就没有父Logger了。

②我们接着传入包名来获取Logger实例

@Test
public void test01(){
    Logger logger = Logger.getLogger("xyz.changlu");
    System.out.println(logger+"，name="+logger.getName());
    System.out.println(logger.getParent()+"，name="+logger.getParent().getName());
}

image-20210226234526741

  • 可以看到当我们创建一个name为"xyz.changlu"的Logger实例时，其父类则是根Logger，其name=""。

③创建有层级关系的Logger实例：

@Test
public void test01(){
    Logger logger = Logger.getLogger("xyz.changlu");
    //传入name为xyz.changlu的上级包名为xyz的Logger实例
    Logger logger2 = Logger.getLogger("xyz");
    System.out.println("logger="+logger+"，name="+logger.getName());
    System.out.println("logger2="+logger.getParent()+"，name="+logger.getParent().getName());
    System.out.println(logger.getParent() == logger2);
    System.out.println("logger2的根looger="+logger2.getParent()+"，name="+logger2.getParent().getName());
}

image-20210226235105724

  • 注意当我们创建了logger的上级Logger实例(name为xyz)时，该实例的上级Logger默认会变为logger2的实例了，此时Logger2的父类则为根Logger了。（可以注意到当定义了有层级相关的Logger时会自动继承相关关系，也与包的层级有关）

总结：

  1. 当我们初始化一个Logger实例时(name!=""情况下)，会默认自带一个rootlogger实例，可通过getParent()获取到，其name=""。
  2. 当我们初始化一个Logger实例时，设置其name=""会直接获得一个rootlogger实例，此时就没有父Logger了。
  3. 当我们定义多个Logger实例时他们的name具有层级关系，例如：xyz.changlu、xyz，那么他们会自动建立关联，name=xyz.changlu的Logger实例其父Logger则为刚刚定义的name=xyz的Logger实例，name=xyz的父Logger则为根Logger。

查看rootlogger中的handler、formatter、level等级

@Test
public void test01(){
    Logger logger = Logger.getLogger("xyz.changlu");
    Logger parent = logger.getParent();//为根Logger实例
    System.out.println("rootLogger："+parent);
    System.out.println("rootlogger的name："+parent.getName());
    System.out.println("rootlogger的filter："+parent.getFilter());
    System.out.println("rootlogger的level："+parent.getLevel());
    System.out.println("handler："+parent.getHandlers()[0]);
    System.out.println("handler的Formatter："+parent.getHandlers()[0].getFormatter());
    System.out.println("handler的level："+parent.getHandlers()[0].getLevel());
    System.out.println("handler的filter："+parent.getHandlers()[0].getFilter());
}

image-20210227001038348 +

  • 获得rootlogger还有一种方式：Logger.getLogger("") 空字符串即可。
  • 可以看到rootlogger的level与该logger的handler的level都为INFO；Handler为ConsoleHandler，Formatter为SimpleFormatter。

此时对于logger算是有一些了解了，不过还不够继续往下看。


4.2、Logger的info(msg)执行流程*

这里默认name=xyz.changlu的logger实例，其父Logger为rootlogger

@Test
public void test01(){
    Logger logger = Logger.getLogger("xyz.changlu");
    logger.info("报错啦");
}

过程如下：

  1. 比较该logger实例的level是否高于INFO。(这里由于logger本身初始化并没有设定级别，所以使用的是rootlogger的日志级别)。
  2. 发现>=INFO，则继续，接着调用logger的Filter实例的isLoggable()，若没有添加，就不进行过滤。
  3. 接着开始依次调用logger的handlers(即handler集合)，由于初始化没有指定handler，就不进行日志输出。
  4. 判断useParentHandlersboolean参数是否为true，默认为true，接着调用rootlogger的handler实例的publish()方法。
  5. 在rootlogger的handler的publish()方法中判断该handler的级别是否>=INFO，由于默认为INFO，大于继续执行。
  6. 接着调用rootlogger的handler的isLoggable()进行过滤，没有则不过滤。
  7. 使用rootlogger的ConsoleHandler的getFormatter().format(LogRecord)进行格式化(默认为SimpleFormatter)。
  8. 最终调用write()将格式化后数据输出到控制台。

注意注意：在抛到上层的logger时并不会判断该logger的level，仅仅是handlers的level。

针对于Logger与handler规范：

一个Logger对应1个Level，对应0个或1个Filter，对应0个或多个Handler，对应0个或1个ParentLogger 。
一个Handler对应1个Level，对应0个或1个Filter，对应1个Formatter。

通过上面说明，我们来看下面例子，请说出打印的内容有些什么：

public class LogTest {
    private static final Logger logger1 = Logger.getLogger("");
    private static final Logger logger2 = Logger.getLogger("cn");
    private static final Logger logger3 = Logger.getLogger("cn.codecrazy");
    static {
        logger2.addHandler(new ConsoleHandler());
        logger3.addHandler(new ConsoleHandler());
        logger2.setLevel(Level.WARNING);
        logger3.setLevel(Level.INFO);
    }

    public static void main(String[] args) {
        System.out.println(logger2.getLevel());
        System.out.println(logger2.getHandlers()[0].getLevel());
        logger1.info("logger1");
        logger2.info("logger2");
        logger3.info("logger3");
    }
}

image-20210228234003684

  • 若是创建一个ConsoleHandler，其会自动初始化一个INFO的日志等级(剧透一下是因为读取了默认的配置文件设置的等级)。

介绍整个流程：首先定义了三个日志实例，互相包含层级关系，在static代码块中将logger2中的日志等级设置为WARNING，并且添加了一个ConsoleHandler(该handler会自动赋予自己的一个INFO日志等级)；接着给logger3中的日志等级设置为INFO，并也添加了一个ConsoleHandler。

开始进入main()方法，之前设置了logger2的等级，第一行则输出WARNING，logger2中的handler就是刚刚的consolehandler，默认等级为INFO。接着开始INFO打印输出，

①首先是第15行，对logger1进行日志输出(其等级为INFO)，由于该logger实例是rootlogger其handler默认日志等级都为INFO，所以直接打印。

②接着是16行，首先会比对logger2中的日志等级(由于代码块中设置为WARNING)，所以直接方法过程中直接return了，没有打印。

③接着是17行，首先会比对logger3的日志等级，本身为INFO，所以通过，接着会遍历logger3的handlers，其中consolehandler日志等级默认为INFO通过，所以在loggers中打印了第一次；接着会调用执行父logger(即为logger2)中的handlers，比对其handler的日志等级为INFO，所以再次通过打印第二次；最后再次调用父logger(这次为rootlogger)的handlers，由于是consolehandler，所以日志等级还是INFO，所以再次打印。

所以logger1打印了1次，logger3打印了3次。

本部分参考案例来源： Java Logging之JUL系列——Logger Hierarchy


4.3、设置日志等级

logger实例本身设置高的日志等级,logger尝试打印

@Test
public void test01(){
    Logger logger = Logger.getLogger("xyz.changlu");
    Logger parent = logger.getParent();//rootlogger
    //logger实例本身设置日志等级
    logger.setLevel(Level.WARNING);
    System.out.println(parent.getLevel());
    System.out.println(logger.getLevel());
    logger.info("cl报错啦");
}

image-20210227004605993

  • 该logger在进行日志等级判定时就会判定<INFO,所以无打印。

rootlogger设置WARNING等级，logger来打印日志

@Test
public void test01(){
    Logger logger = Logger.getLogger("xyz.changlu");
    Logger parent = logger.getParent();//rootlogger
    //logger实例本身设置日志等级
    parent.setLevel(Level.WARNING);
    logger.info("cl报错啦");
}

image-20210227004645036

当rootlogger设置等级时则会影响到其子logger的level等级。


五、日志的配置文件

5.1、初探源码(读取配置文件部分,前)*

当我们使用Logger.getLogger("")来获取一个Logger实例时，会默认在根Logger中添加一个Conslehandler(带有SimpleFormatter转换器)。

  • 对于rootlogger默认添加的handler以及formatter实际上是通过一个配置文件来进行配置的，其配置文件是JDK自带的，名称为logging.properteis。

接下来我们来看源码中的内容，根据数字的顺序：只针对于读取配置文件

private static final Logger logger1 = Logger.getLogger("");//调用该方法开始读源码

public class Logger {
    
    //1、getLogger()获取实例的方法
	@CallerSensitive
    public static Logger getLogger(String name) {、
        return demandLogger(name, null, Reflection.getCallerClass());//去到2
    }
    
    //2、demandLogger()：日志记录器
    private static Logger demandLogger(String name, String resourceBundleName, Class<?> caller) {
        LogManager manager = LogManager.getLogManager();//去到3
        ....
        //该方法会创建logger实例的操作，包含其中的handlers(根据配置文件是否有反射创建实例)以及level等...，其level若没有会去拿到父类的level
        return manager.demandLogger(name, resourceBundleName, caller);//返回logger实例对象
    }
}

public class LogManager {
    
    private static final LogManager manager;//该类是一个单例实例
    
    //3、获取到LogManager的单例属性
    public static LogManager getLogManager() {
        if (manager != null) {
            manager.ensureLogManagerInitialized();//去往4
        }
        return manager;
    }
    
    //4、进行LogManager读取配置文件与初始化操作
    final void ensureLogManagerInitialized() {
        final LogManager owner = this;
        if (initializationDone || owner != manager) {
            return;
        }
        synchronized(this) {
            final boolean isRecursiveInitialization = (initializedCalled == true);
            assert initializedCalled || !initializationDone
            if (isRecursiveInitialization || initializationDone) {
                return;
            }
            initializedCalled = true;
            try {
                AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    @Override
                    public Object run() {
                        assert rootLogger == null;
                        assert initializedCalled && !initializationDone;
                        //注意这里
                        owner.readPrimordialConfiguration();//去往5
						
                        //own就是logManager实例，对rootLogger进行初始化
                        owner.rootLogger = owner.new RootLogger();
                        //add方法中会实例化LoggerContext，其中包含了一个hashtable实例，键为logger名称，LoggerWeakRef引用(属性有name、LogNode、parentRef,分别为名称、节点以及父节点引用，logNode存储一个完整的logger信息)
                        owner.addLogger(owner.rootLogger);
                        if (!owner.rootLogger.isLevelInitialized()) {
                            owner.rootLogger.setLevel(defaultLevel);
                        }
                        //这里是获取一个logger实例(为了向下兼容1.7的)
                        final Logger global = Logger.global;
                        owner.addLogger(global);
                        return null;
                    }
                });
            } finally {
                initializationDone = true;
            }
        }
    }
    
    //5、读取原始配置文件
    private void readPrimordialConfiguration() {
        if (!readPrimordialConfiguration) {
            synchronized (this) {
                if (!readPrimordialConfiguration) {
                    if (System.out == null) {
                        return;
                    }
                    readPrimordialConfiguration = true;

                    try {
                        AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {
                                @Override
                                public Void run() throws Exception {
                                    //继续调用读取配置文件方法(很重要的地方)
                                    readConfiguration();//去往6

                                    // Platform loggers begin to delegate to java.util.logging.Logger
                                    sun.util.logging.PlatformLogger.redirectPlatformLoggers();
                                    return null;
                                }
                            });
                    } catch (Exception ex) {
                        assert false : "Exception raised while reading logging configuration: " + ex;
                    }
                }
            }
        }
    }
    
    //6、读取配置文件(本部分最关键地方)
    public void readConfiguration() throws IOException, SecurityException {
        checkPermission();

        //自定义配置类，负责完成配置信息的初始化。
        //这里cname就是对应的配置类名称，方便下面通过类加载来加载对应类进行配置信息。
        String cname = System.getProperty("java.util.logging.config.class");
        if (cname != null) {
            try {
                try {
                    Class<?> clz = ClassLoader.getSystemClassLoader().loadClass(cname);
                    clz.newInstance();
                    return;
                } catch (ClassNotFoundException ex) {
                    Class<?> clz = Thread.currentThread().getContextClassLoader().loadClass(cname);
                    clz.newInstance();
                    return;
                }
            } catch (Exception ex) {
                System.err.println("Logging configuration class \"" + cname + "\" failed");
                System.err.println("" + ex);
                // keep going and useful config file.
            }
        }
        
        //自定义配置文件
		//获取System里Properties实例中的键
        String fname = System.getProperty("java.util.logging.config.file");
        //若是没有获取到，fname为null，则会读取jdk目录中官方的logging.properties
        if (fname == null) {
            //获取jdk中的配置文件路径
            //获取系统参数，Java 安装目录，我的是C:\Program Files\Java\jdk1.8.0_201\jre
            fname = System.getProperty("java.home");
            //若没有对应参数，则会报错
            if (fname == null) {
                throw new Error("Can't find java.home ??");
            }
            //此时f路径为：C:\Program Files\Java\jdk1.8.0_201\jre\lib
            File f = new File(fname, "lib");
            //在添加一个子目录：C:\Program Files\Java\jdk1.8.0_201\jre\lib\logging.properties
            f = new File(f, "logging.properties");
            fname = f.getCanonicalPath();
        }
        //使用文件输入流来读取该配置文件：logging.properties
        try (final InputStream in = new FileInputStream(fname)) {
            //添加缓冲流，加快读取速度
            final BufferedInputStream bin = new BufferedInputStream(in);
            //读取之前读取的配置文件输入流
            readConfiguration(bin);
        }
    }
    
    //7、读取文件输入流操作
    public void readConfiguration(InputStream ins) throws IOException, SecurityException {
        checkPermission();
        reset();
		
        //该props是一个properties实例，这里将参数中的输入流放置到其中，为之后键值对读取做准备。
        props.load(ins);
        ...
    }
}
  • 上面的源码分析暂时只到配置文件为止，不再往下深入更细节的内容，我们只要知道，在不进行自定义配置文件时，会自动读取jre/lib目录中的logging.properties到一个输入流中，再调用LoggerManager实例(单例)的readConfiguration(bin);，bin则为对应的配置文件输入流。
  • 第122行：fname指的就是对应配置文件的路径，这里为：C:\Program Files\Java\jdk1.8.0_201\jre\lib\logging.properties。

若是我们不进行自定义配置类或自定义配置文件，那么就会自动读取jre/lib目录下官方提供的配置文件！

源码看完了，我们就去看一下这个logging.properties里面的内容吧：

image-20210301171911899

  • 确实有logging.properties配置文件。

清理了注释后内容如下：

# RootLogger 顶级父元素指定的默认处理器 ConsoleHandler,可添加多个用,隔开
handlers= java.util.logging.ConsoleHandler

# RootLogger 顶级父元素默认的日志级别为INFO
.level= INFO

# 若是上面handlers中多加了一个FileHandler就生效8-11行配置
java.util.logging.FileHandler.pattern = %h/java%u.log  # ①%h表示当前用户目录路径，我的为C:\Users\93997；②%u对  # 应下面的count，范围为[0,count)
java.util.logging.FileHandler.limit = 50000  # 输出日志文件限制大小（50000字节）
java.util.logging.FileHandler.count = 1      # 定义上面%h的范围
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter  # 设置FileHandler中的转换器为    # XMLFormatter (XML格式)

# 对应上面handlers中的ConsoleHandler进行配置
java.util.logging.ConsoleHandler.level = INFO  # handler的日志等级为INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter # 该handler转换器为        # SimpleForamtter

# 特殊logger日志的默认等级，当设置name为com.xyz.foo的logger实例，其日志等级为SEVERE
com.xyz.foo.level = SEVERE  #

所以我们刚开始获取一个logger实例会自带一个handler及formatter，与这个配置文件关系很大。


5.2、自定义配置文件

首先要定义一个自定义配置文件，接着通过调用方法或在java命令中添加参数(目的就是让LogManager的单例加载到该配置文件)，对于配置文件我们可以借鉴jre/lib下的logging.properties，在其基础上进行自定义配置。

名字可以随意如：xxx.properteis，后缀应当使用properteis，因为源码中读取配置文件的输入流使用的Properties的load()方法。

我们来自定义一个吧，还是logging.properties，放置的位置若是Maven项目的话放置在resource目录下；若是普通java工程放置在src目录下即可：

# ①额外增加了一个FileHandler，用于输出到文件中
handlers= java.util.logging.ConsoleHandler,java.util.logging.FileHandler
# ②默认日志等级为ALL(那么)
.level= ALL

# ④在.log文件上层多添加了一个logs目录
java.util.logging.FileHandler.pattern = %h/logs/java%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
# ⑤转换器更改为简单转换
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter

# ③设置handler的日志等级为ALL
java.util.logging.ConsoleHandler.level = ALL
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

com.xyz.foo.level = SEVERE
  • 增添内容如上数字标记部分。

因为创建的是Maven工程，所以放在resources目录中：

image-20210301183746077


方式如下：

方式一：使用System.setProperties()来配置文件

System.setProperty("java.util.logging.config.file",
        "C:\\Users\\93997\\Desktop\\工程文件\\logdemo\\src\\main\\resources\\logging.properties");

解析：我们之前看源码时，针对于自定义配置文件是通过System.getProperty()来获取对应的文件路径的，所以我们在main()方法前添加对应的配置文件路径之后调用Logger.getLogger()方法就会加载我们的自定义配置文件。


方式二：在执行字节码时添加命令参数

image-20210301190810718

  • -D java.util.logging.config.file="C:\Users\93997\Desktop\projectexers\logdemo\src\main\resources\logging.properties"，值应当为详细路径。

添加该命令之后，运行程序则会自动添加到系统参数中。


方式三：使用LogManager的单例实例调用readConfiguration()方法读取配置文件输入流

@Test
public void test01() throws IOException {
    //1、通过系统类加载器的getResourceAsStream()来加载配置文件，返回输入流
    InputStream is = LogTest.class.getClassLoader().getResourceAsStream("logging.properties");
    //2、使用LogManager的单例来读取该配置文件(与源码读取官方logging.properties方法类似)
    LogManager.getLogManager().readConfiguration(is);

    //测试
    Logger logger = Logger.getLogger("xyz.changlu");
    logger.severe("severe");
    logger.warning("warning");
    logger.info("info");
    logger.config("config");
    logger.fine("fine");
    logger.finer("finer");
    logger.finest("finest");
}
  • 这种方式与源码中的使用文件流读取配置文件类似，源码使用的是FileInputStream来读取配置文件，最后都是使用的LogManager实例(该实例是单例)的对应方法加载输入流。

image-20210301195930320

image-20210301200126663

  • 配置文件中%h表示的是当前用户目录路径。

OK，三种方式都可以进行自定义配置文件，其实也可以使用配置类进行来进行自定义配置，这里就不作描述。

5.3、深入日志配置文件

配置文件详解(含源码)*

之前介绍了JDK默认的配置文件logging.properties，其中内容其实并不完整，本部分来完善相关的日志配置文件，并再去窥探源码看看在程序中是如何读取到配置文件中的配置信息的：

# 1、handlers集合介绍
# 1.1、handlers(无层级关系默认为RootLogger的handlers)：是一个集合可设置多个handler
handlers = java.util.logging.ConsoleHandler,java.util.logging.FileHandler
# 默认为RootLogger的日志等级
.level= ALL
# 1.2、该handlers(包含层级关系，若程序中logger的name为xyz.changlu则默认为其添加handlers)：
#                          相当于对获取的logger实例添加自定义handlers集合
xyz.changlu.handlers = java.util.logging.FileHandler
# name为xyz.changlu的logger的日志等级
xyz.changlu.level = ALL
# name为xyz.changlu的logger忽略父日志设置
xyz.changlu.useParentHandlers = false

# 2、处理器设置
# 2.1、ConsoleHandler(控制台处理器)：设置等级为ALL
java.util.logging.ConsoleHandler.level = ALL
# 设置输出日志格式使用SimpleFormatter
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
# 设置指定的编码格式
java.util.logging.ConsoleHandler.encoding = UTF-8
# 2.2、FileHandler(文件处理器)：设置日志等级为ALL
java.util.logging.FileHandler.level = ALL
# 设置输出日志文件路径：%h表示家目录  %u与下面count有关(范围为[0,count))
java.util.logging.FileHandler.pattern = %h/logs/java%u.log
# 输出日志文件限制大小（50000字节）
java.util.logging.FileHandler.limit = 50000
# 输出日志文件限制个数
java.util.logging.FileHandler.count = 1
# 设置输出日志格式使用SimpleFormatter
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
# 输出的日志内容是否追加到文件
java.util.logging.FileHandler.append = true

# 3、指定转换器的日志格式
# 3.1、指定SimpleFormatter的转换形式 该format输入内容为 如WARNING: warning message [Tue Mar 22 13:11:31 PDT 2011]  对比以前少了指定调用方法
java.util.logging.SimpleFormatter.format = "%4$s: %5$s [%1$tc]%n"

# 设置name=com.xyz.foo的logger实例的日志等级(可省略不看)
com.xyz.foo.level = SEVERE
  • 对于RootLogger的日志等级、指定handlers集合以及为自定义logger设置handlers以及日志等级；
  • 针对于不同处理器进行设置日志等级，其中FileHandler设置较多，包含日志等级、路径、文件大小、日志文件限制个数、转换各时期、是否追加。
  • 对于SimpleFormatter也可进行转换格式设置，设置formatter参数。

该配置文件又补充了不少内容，那么补充的依据是在哪里呢？我们去源码中一探究竟：

首先看下ConsoleHandler类：其在初始化构造器时就进行了一系列的操作

public class ConsoleHandler extends StreamHandler {
	//1、无参构造
	public ConsoleHandler() {
        sealed = false;
        configure();//进行配置 去到2
        setOutputStream(System.err);
        sealed = true;
    }
    
    //2、进行配置操作
    private void configure() {
        LogManager manager = LogManager.getLogManager();//在此之间该LogManager的单例已经加载了自定义配置文件或官方提供的配置文件
        //cname就是获取本身的类名，为java.util.logging.ConsoleHandler
        String cname = getClass().getName();
		//重要！！！！
        //setLevel()中的方法意思是，首先会去该LogManager实例的getProperty()方法获取对应的值(实际上就是使用properties实例获取键值对中的值)，若是没有获取到就使用第二个参数默认设置为INFO
        setLevel(manager.getLevelProperty(cname +".level", Level.INFO));
        //针对于Filter若是从properteis中找不到对应的键值对，则默认设置filter为null
        setFilter(manager.getFilterProperty(cname +".filter", null));
        //若是找不到键值对，则默认设置转换器为SimpleFormatter
        setFormatter(manager.getFormatterProperty(cname +".formatter", new SimpleFormatter()));
        try {
            //同理，之类若是没有设置编码格式，则会设置为null
            setEncoding(manager.getStringProperty(cname +".encoding", null));
        } catch (Exception ex) {
            try {
                setEncoding(null);
            } catch (Exception ex2) {
                // doing a setEncoding with null should always work.
                // assert false;
            }
        }
    }
}
  • 实际上就是配置文件中对应的java.util.logging.ConsoleHandler.xxx的值，所以我们要记住了当我们进行自定义配置文件之后若是对对应handler进行了设置，那么在之后初始化handler实例也会受到影响！！！

相对于FileHandler也同样如此，我直接放相应代码即可：

//同样无参构造中调用了configure()方法
private void configure()() {
    LogManager manager = LogManager.getLogManager();

    //cname = java.util.logging.FileHandler
    String cname = getClass().getName();

    //若是LogManager实例中的properties实例若是读取不到指定键值对java.util.logging.FileHandler.pattern，默认路径为%h/java%u.log
    pattern = manager.getStringProperty(cname + ".pattern", "%h/java%u.log");
    //若是读取不到java.util.logging.FileHandler.limit，默认为0
    limit = manager.getIntProperty(cname + ".limit", 0);
    if (limit < 0) {
        limit = 0;
    }
    //读取不到默认为1 (对应%u)
    count = manager.getIntProperty(cname + ".count", 1);
    if (count <= 0) {
        count = 1;
    }
    //append是是否追加的意思，默认若是没有配置文件为false，每次向文件写日志时就会进行覆盖，所以一般会设置为true
    append = manager.getBooleanProperty(cname + ".append", false);
    //对于FileHandler，若是没有自定义配置，会设置日志等级为ALL
    setLevel(manager.getLevelProperty(cname + ".level", Level.ALL));
    //对于过滤器，无自定义配置时默认为null
    setFilter(manager.getFilterProperty(cname + ".filter", null));
    //对于转换器，无自定义配置时默认为XMLFormatter(就是以XML形式保存，一般不这样)
    setFormatter(manager.getFormatterProperty(cname + ".formatter", new XMLFormatter()));
    try {
        //对于编码，无自定义配置时默认为null
        setEncoding(manager.getStringProperty(cname +".encoding", null));
    } catch (Exception ex) {
        try {
            setEncoding(null);
        } catch (Exception ex2) {
        }
    }
}
  • ok，可以看到FileHandler与ConsoleHandler的默认配置还有有差别的。对于日志等级FileHandler为ALL，而console为INFO；对于转换器formatter，FileHandler默认设置为XMLFormatter，console默认设置为SimpleFormatter。

最后看下转换器SimpleFormatter类：

public class SimpleFormatter extends Formatter {
	//这里是调用一个方法获取的，和之前的有些不一样，我们深入看一下  见1
	private static final String format = LoggingSupport.getSimpleFormat()
}

//看一下LoggingSupport，粗略看下即可
public class LoggingSupport {
    
    //1、LoggingSupport的静态方法
    public static String getSimpleFormat() {
        return getSimpleFormat(true);//见2
    }
    
    //2、注意这个方法中的操作与之前的就大致相同了！！！
    static String getSimpleFormat(boolean var0) {
        String var1 = (String)AccessController.doPrivileged(new PrivilegedAction<String>() {
            public String run() {
                //这里是尝试获取System类中props是否有该键值对，默认是没有的，返回null
                return System.getProperty("java.util.logging.SimpleFormatter.format");
            }
        });
        //注意这里：若是参数var0为true&系统变量中没有读取到var1&代理类不为null(该代理类是static实例)
        //实际上这里调用代理类的getProperty()方法就是调用的LogManager.getLogManager().getProperty(key);
        //其实也就是之前LogManager读取的配置文件流！！！若是我们自定义了就会取到对应的值，没有的话返回null
        if (var0 && proxy != null && var1 == null) {
            var1 = proxy.getProperty("java.util.logging.SimpleFormatter.format");
        }

        //若var1不为null，表示从自定义配置文件中读取到了
        if (var1 != null) {
            try {
                //格式化时会加上调用该方法的日期
                String.format(var1, new Date(), "", "", "", "", "");
            } catch (IllegalArgumentException var3) {
                var1 = "%1$tb %1$td, %1$tY %1$tl:%1$tM:%1$tS %1$Tp %2$s%n%4$s: %5$s%6$s%n";
            }
        } else {
            //自定义配置文件没有配置时采用该格式
            var1 = "%1$tb %1$td, %1$tY %1$tl:%1$tM:%1$tS %1$Tp %2$s%n%4$s: %5$s%6$s%n";
        }
        return var1;
    }
}

我们这边再看下proxy实例是怎么获取到的，以及调用的getProperty()到底是什么：

image-20210302005349986

最后对于该format的设置可以见源码中的注释，有是包含详细例子：

image-20210302005608157

  • 三个方框里的是使用对应format打印出的例子。
  • 三个示例贴在这里：%4$s: %5$s [%1$tc]%n、%1$tc %2$s%n%4$s: %5$s%6$s%n、%1$tb %1$td, %1$tY %1$tl:%1$tM:%1$tS %1$Tp %2$s%n%4$s: %5$s%n。其中符号含义可见源码或者api文档。

小案例

要求：在自定义配置文件中指定name=xyz.changlu的logger实例(日志等级为ALL)包含一个FileHandler(限制大小为50000字节，文件数1个，路径指定D盘的los目录中，日志等级为ALL)，该FileHandler对应一个SimpleFormatter(打印两行信息的格式)，并且支持追加。

答：自定义配置文件如下：

# 指定name为xyz.changlu的handlers集合中添加FileHandler
xyz.changlu.handlers = java.util.logging.FileHandler
# 该logger日志等级为ALL
xyz.changlu.level = ALL
# 表示不使用父元素的handlers集合(这里可不加)
xyz.changlu.useParentHandlers = false

# FileHandler的日志等级为ALL、路径、限制大小、数量、指定转换器、以及是否追加
java.util.logging.FileHandler.level = ALL
java.util.logging.FileHandler.pattern = D:/logs/java%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
java.util.logging.FileHandler.append = true

# SimpleFormatter中转换格式为堆栈方法
java.util.logging.SimpleFormatter.format = "%1$tc %2$s%n%4$s: %5$s%6$s%n"
  • 这里我们没有指定rootlogger的handler，那么初始时自动创建的对应rootlogger的handlers则不会存在。

注意点：logs目录我们应当提前创建好，否则会报错。(若logs目录没有，则会出现找不到文件的异常)

我们来验证一下结果：

@Test
public void test02() throws IOException {
    //读取配置文件输入流
    InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("logging.properties");
    //让LogManager来读取输入流
    LogManager.getLogManager().readConfiguration(is);
    
    //前两步骤做好之后再进行日志测试
    Logger logger = Logger.getLogger("xyz.changlu");
    logger.severe("severe");
    logger.warning("warning");
    logger.info("info");
    logger.config("config");
    logger.fine("fine");
    logger.finer("finer");
    logger.finest("finest");
}

image-20210302171734651

  • 屏幕前确实没有输出任何信息。

image-20210302175050091

  • 成功打印到指定文件目录下的对应文件中。

5.4、深入源码(日志执行流程,后)*

之前5.1看的源码是关于配置文件相关的，这里的话来看一看日志执行的流程：

//getlogger()方法读取了配置文件(前面5.1部分看的源码)
Logger logger = Logger.getLogger("xyz.changlu");
//本部分来看一下logger实例调用servere()方法中的执行过程
logger.severe("severe");

接下来跟着一起看下去吧：

public class Logger {
    
    //1、该方法实际就是调用的log()方法，其第一个参数就是指定日志等级，很明显这里就是封装了一下变得更简洁
    public void severe(String msg) {
        log(Level.SEVERE, msg);//见2
    }
    
    //2、传入日志等级，以及日志要打印的msg参数
    public void log(Level level, String msg) {
        //重要①(比较自身logger实例的level)，若是返回false，则该日志直接结束不进行下去
        if (!isLoggable(level)) {//见3
            return;
        }
        //将日志等级以及msg日志描述参数封装到LogRecord实例中
        LogRecord lr = new LogRecord(level, msg);
        doLog(lr);//见4
    }
    
    //3、对日志等级进行比较
    public boolean isLoggable(Level level) {
        //实例本身日志等级比当前要打印的日志等级大或者实例本身日志等级为最大情况下返回false
      if (level.intValue() < levelValue || levelValue == offValue) {//offValue的value为Integer.MAX_VALUE
            return false;
      }
      return true;
    }
    
    //4、传入封装好日志等级以及msg的lr
    private void doLog(LogRecord lr) {
        lr.setLoggerName(name);
        final LoggerBundle lb = getEffectiveLoggerBundle();
        final ResourceBundle  bundle = lb.userBundle;
        final String ebname = lb.resourceBundleName;
        if (ebname != null && bundle != null) {
            lr.setResourceBundleName(ebname);
            lr.setResourceBundle(bundle);
        }
        //上面先省略，继续看该方法
        log(lr);//见5
    }
    
    //5、该方法是执行过程中很重要的一部分
    public void log(LogRecord record) {
        //这里再次比较logger实例的日志等级以及本次日志打印的日志等级(有疑惑之前不是已经比较过了嘛)
        if (!isLoggable(record.getLevel())) {
            return;
        }
        //重要②，这里filter是本logger实例的filter过滤器
        Filter theFilter = filter;
        //重要②，若过滤器为不为null同时该过滤器的方法执行返回为false时直接结束方法
        if (theFilter != null && !theFilter.isLoggable(record)) {
            return;
        }
        
        //获取本身logger实例
        Logger logger = this;
        //接着开始执行logger实例中的handlers了
        while (logger != null) {
            //在Logger(String name)中设置isSystemLogger为true了，将原本使用List存储的handlers转为一个数组形式
            final Handler[] loggerHandlers = isSystemLogger
                ? logger.accessCheckedHandlers()
                : logger.getHandlers();
			//重要③：遍历handlers数组
            for (Handler handler : loggerHandlers) {
                //重要④：这一步实际上就是使用handler进行输出日志msg信息
                handler.publish(record);//去6
            }

            //若是useParentHandlers为true将该布尔值给一个临时变量
            final boolean useParentHdls = isSystemLogger
                ? logger.useParentHandlers
                : logger.getUseParentHandlers();
			//若是useParentHdls为false(表示不获取其父handler)，那么就不会往下执行，整个log()方法结束
            if (!useParentHdls) {
                break;
            }
			//获取到上级logger(若是没有定义多个有层级关系的logger，则为rootlogger)
            //重新执行比对一遍logger的handlers集合中的日志等级及过滤器
            logger = isSystemLogger ? logger.parent : logger.getParent();
        }
    }
    
}

//假定当前的handler为ConsoleHandler(几个handler执行过程大致相同)
public class ConsoleHandler extends StreamHandler {
    
    //6、输出方法
    @Override
    public void publish(LogRecord record) {
        //调用的是父类StreamHandler的publish()方法
        super.publish(record);//去7
        //刷新字符流
        flush();
    }
}

//Handler的父类StreamHandler
public class StreamHandler extends Handler {
    
    //7、StreamHandler的publish()方法
    @Override
    public synchronized void publish(LogRecord record) {
        //重要⑤：比对指定handler的日志等级与logger实例的日志等级
        if (!isLoggable(record)) {//去8
            return;
        }
        //若是前面都顺利通过来到这里
        String msg;
        try {
            //使用logger实例指定的转换器进行格式转换
            msg = getFormatter().format(record);
        } catch (Exception ex) {
            reportError(null, ex, ErrorManager.FORMAT_FAILURE);
            return;
        }

        try {
            if (!doneHeader) {
                writer.write(getFormatter().getHead(this));
                doneHeader = true;
            }
            //最终打印出日志信息(根据handler决定去处)
            writer.write(msg);
        } catch (Exception ex) {
            reportError(null, ex, ErrorManager.WRITE_FAILURE);
        }
    }
    
    //8、这里有判断record与输出流是否为null
    @Override
    public boolean isLoggable(LogRecord record) {
        if (writer == null || record == null) {
            return false;
        }
        return super.isLoggable(record);//去9 (Handler类中的方法)
    }
}

//StreamHandler的父类Handler
public abstract class Handler {
    
    private static final int offValue = Level.OFF.intValue();
    
    //9、这里才是真正比较handler的日志等级与logger实例的日志等级
    public boolean isLoggable(LogRecord record) {
        //levelValue默认为ALL，若是读取官方配置文件按配置文件的日志等级为INFO(这里默认读取官方配置为文件)
        final int levelValue = getLevel().intValue();
        //若是logger实例的日志等级为小于INFO或当前levelValue为Integer.MAX_VALUE，则结束方法回退到7
        if (record.getLevel().intValue() < levelValue || levelValue == offValue) {
            return false;
        }
        //若是日志等级通过，在调用执行handler的filter过滤器进行比对
        final Filter filter = getFilter();
        if (filter == null) {
            //若是无过滤器直接通过
            return true;
        }
        //指定filter方法返回filter的结果
        return filter.isLoggable(record);
    }
  • 其实主要关键的看第3、5、7、9方法，最主要的是第5方法(核心调用)

这部分源码的执行过程以及之前读取配置文件放在下个部分统一总结，好好理清一下思路。


六、总结

五章节前后源码总结*

读取配置文件部分总结

当调用Logger.getLogger()获取logger实例时，该方法中间进行了读取配置文件的操作：

  1. 读取自定义配置类。首先会去看System类中是否包含java.util.logging.config.class对应键值对的值，若是有会对该配置类进行实例化，直接结束配置读取。
  2. 读取自定义配置文件。会去看有没有java.util.logging.config.file对应的配置文件路径，有的话赋值到String fname中。
  3. 读取官方默认的配置文件(/jre/lib/logging.properties)。若是fame没有说明没有对应的配置文件路径，就会默认去找到java配置的路径，获取到完整路径同样赋值到String fname中。
    • 无论执行2或3步骤都是得到的一个fname全路径地址，使用FileInputStream将对应配置文件转为输入流，再统一使用LogManager中的properties实例的load()方法加载该输入流。

若不自定义配置文件以及配置类时，会默认读取官方的配置文件：

  • 该方法生成实例logger包含内容如下：
    • level=INFO(默认是使用的rootlogger的日志等级)
    • parent=rootlogger(根logger)，其属性如下：
      • handlers只含ConsoleHandler。
      • level=INFO。
  • ConsoleHandler属性设置：level=INFO，formatter=SimpleFormatter
  • FileHandler属性设置：pattern=%h/java%u.log，limit=50000，count = 1，formatter=XMLFormatter。

注意：当对应的handler、formatter初始化时会根据配置文件中的属性进行设置的。


执行流程总结

当logger实例调用severe(msg)或其他等级方法或log(level,msg)时，就会执行该流程：

  1. 首先比对的是logger实例的level，参数传入的level一定要比其>=才可继续执行。
  2. 执行logger实例的中filter过滤器，若是无过滤器或该过滤器方法返回false继续执行。
  3. 开始遍历logger实例中的handlers数组(list转数组)。
    • 每一个handler都有重要的两步，①传入参数level比对该handler的level，只有>=才可继续执行；②执行该handler中的fiter，若为null或执行fliter返回false继续执行。两步都通过就会进行输出日志(根据handler输出指向)。
  4. 接着判断logger实例的useParentHandlers这个布尔参数，若是为true，则获取到父级logger，遍历父级logger的handlers，与第3步相同。

默认情况下logger实例的level为INFO，rootlogger的level为INFO(其中handler的等级为INFO)。


参考资料

视频：2020年Java进阶教程，全面学习多种java日志框架

[1]. Java日志——JUL（java.util.logging）的使用及原理

[2]. 日志处理器——Java日志 解决了我setUseParentHandlers(false)疑惑

[3]. Java Logging之JUL系列——Log Levels 这个博主出了jul一个系列，在java栏目中很有帮助

[4]. Java Logging之JUL系列——Handler

[5]. Java Logging之JUL系列——Logger Hierarchy Logger的层级关系

[6]. Java中getResourceAsStream的用法 用来读取日志配置文件

[7]. System.getProperty()-获取系统参数 System.getProperty()-获取系统参数

[8]. java.util.logging.LogManager 源码中java.util.logging.config.class以及java.util.logging.config.file对应用途

[9]. JUL(java.util.logging)java原生官方日志 使用与配置–解决jul不输出显示日志问题

[10]. java.util.logging使用笔记2 类中使用方法

[11]. 日志框架1—多种日志门面和日志实现初步了解


我是长路，感谢你的耐心阅读，如有问题请指出，我会听取建议并进行修正。
欢迎关注我的公众号：长路Java，其中会包含软件安装等其他一些资料，包含一些视频教程以及学习路径分享。
编程学习qq群：891507813 我们可以一起探讨学习
注明：转载可，需要附带上文章链接

长路 ㅤ   
关注
专栏目录
JDK自带的日志包简单应用
03-21
NULL 博文链接：https://samjavaeye.iteye.com/blog/938657
【JAVA日志框架】JUL，JDK原生日志框架详解。
Joker_ZJN的博客
12-17 4160
Java日志体系混乱？系列文章第一篇，五分钟，快速掌握JDK原生日志框架——JUL。
JUL 日志 （全面，详细）
最新发布
smilehjl
07-02 706
JUL全称Java util Logging是java原生的日志框架，使用时不需要另外引用第三方类库，相对其他日志框 架使用方便，学习简单，能够在小型应用中灵活使用。
Java自带日志工具java.util.logging.Logger
热门推荐
王浩的技术博客
12-24 1万+
java.util.logging.Logger是JDK自带的日志工具类，从1.4版本开始就已经有了。由于log4j等开源的日志组件，这个Logger并没有太多展现机会。但在一些测试性的代码中，JDK自带的Logger比log4j等更方便。 创建Logger对象 要使用JDK的日志功能，首先要取得java.util.logging.Logger实例，这可以通过Logger类的两个静态getLogger()方法来取得： static Logger getLogger(String name)
JDK原生日志库JUL
小高的博客
10-12 237
JUL全称Java.util.loging 其中的代码也主要位于该包之下 主要分为 LogMannager:
精尽Spring Boot源码分析 - 日志系统
qq_38082146的博客
07-08 227
概述 日志是一个系统必不可缺少的东西，记录了系统运行时的点点滴滴，便于我们了解自己系统的运行状态，在我们使用 Spring Boot 时，默认就已经提供了日志功能，使用Logback作为默认的日志框架。那么，接下来我们依赖来看看 Spring Boot 是如何初始化好日志系统的。 为什么 Spring Boot 默认的日志框架是Logbasck呢？ 因为在spring-boot-starter模块中引入spring-boot-starter-logging模块，该 Starter 引入...
Java各类日志组件分析汇总(1)
D1561691的博客
05-04 643
▐自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
一篇文章读懂Java日志框架
huzhengnanss的博客
02-21 687
一篇文章读懂Java日志框架,Log4j,Log4j2,Slf4j,Logback,JUL,LCL
Java日志体系-日志接口、日志实现与桥接器
CatchTimer的博客
01-17 842
基础的Java日志体系当前大体可以分为三个部分：日志接口、桥接器、日志框架具体实现。 日志接口与日志实现 Apache Commons Logging（JCL） JCL是Apache提供的一个通用日志API，可以让应用程序不再依赖于具体的日志实现工具。Apache commons-logging是JCL的标准实现。 commons-logging包中对其它一些日志工具，包括Log4J、Avalon LogKit、JUL等，进行了简单的包装，可以让应用程序在运行时，直接将JCL API打点的日志适配到对应.
SpringBoot 系列-日志详解
glmapper_2018
01-01 500
Spring Boot 使用 Commons Logging 进行所有内部日志记录，但保留底层日志实现。为 Java Util Logging、Log4J2 和 Logback 提供了默认配置。在每种情况下，loggers 都预先配置为使用 console 输出，并且也提供可选的文件输出。 默认情况下，如果使用 “starters”，则使用 Logback 进行日志记录。还包括适当的 Logbac...
JUL的简单日志实现
02-18
参考JUL的日志实现逻辑，仿照JUL实现日志记录功能，仅供学习使用
微软面试100题系列之高清完整版PDF文档[带目录+标签]by_July
09-20
本微软面试100题系列，共计11篇文章，300多道面试题，截取本blog索引性文章：程序员面试、算法研究、编程艺术、红黑树、数据挖掘5大系列集锦：http://blog.csdn.net/v_july_v/article/details/6543438，中的第一部分编辑而成，涵盖了数据结构、算法、海量数据处理等3大主题。 闲不多说，眼下九月正是校招，各种笔试，面试进行火热的时节，希望此份微软面试100题系列的PDF文档能给正在找工作的朋友助一臂之力！ 如果读者发现了本系列任何一题的答案有问题，错误，bug，恳请随时不吝指正，你可以直接评论在原文之下，也可以通过私信联系我。 祝诸君均能找到令自己满意的offer或工作，谢谢。July、二零一二年九月二十日
JAVA日志--JUL
weixin_44245778的博客
04-14 346
日志级别：OFF（关闭）-->SEVERE（严重）-->WARNING（警告）-->INFO（信息）-->CONFIG（配置）-->FINE（详细）-->FINER（较详细）-->FINEST（非常详细）-->ALL（打开） 日志级别从左到右一次递减，系统默认配置是INFO级别，表示INFO级别以上的才可以输出。OFF和ALL代表日志的最高和最低级...
JUL日志讲解
weixin_51992178的博客
08-22 305
每个`Logger`都有一个父日志打印器，我们可以通过`getParent()`来获取，得到的是`java.util.logging.LogManager$RootLogger`这个类，它默认使用的是ConsoleHandler，且日志级别为INFO，由于每一个日志打印器都会直接使用父类的处理器，因此我们之前需要关闭父类然后使用我们自己的处理器。级别低于默认级别的日志信息，无法输出到控制台，我们可以通过设置来修改日志的打印级别。日志处理器不仅仅只有控制台打印，我们也可以使用文件处理器来处理日志信息。
Java日志系统01 ---- JUL日志
m0_37655893的博客
02-15 522
JUL日志
JUL日志框架
路边烧卖
04-16 717
JUL日志框架 1、JUL 简单介绍 JUL全称Java util logging是Java原生的日志框架，使用时不需要另外引用第三方类库，相对其他日志框 架使用方便，学习简单，能够在小型应用中灵活使用。 在JUL中有以下组件： Loggers：被称为记录器，应用程序通过获取Logger对象，调用其API来来发布日志信息。Logger通常时应用程序访问日志系统的入口程序 Handlers：也被称为Appenders，每个Logger都会关联一组Handlers，Logger会将日志交给关联的Handler
使用java自带的日志管理_java日志管理
weixin_29615645的博客
02-16 393
1.相关概念日志统一框架(日志门面)：apache commons logging、slf4j日志实现框架(实现层)：JDK自带的logging(java.util.logging)、log4j、Java Util Logging、log4j2、logback.(1)JDK自带的logging(java.util.logging)用法：1 importjava.util.logging.Logge...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

长路 ㅤ   

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值