Java日志框架-JUL

JUL详解

JUL全程 Java Util Logging，它是java原生的日志框架，使用时不需要另外引用第三方的类库，相对其他的框架使用方便，学习简单，主要是使用在小型应用中。

Logger：被称为记录器，应用程序通过获取Logger对象，抵用其API来发布日志信息。Logger通常被认为是访问日志系统的入口程序。
Handler：处理器，每个Logger都会关联一个或者是一组Handler，Logger会将日志交给关联的Handler去做处理，由Handler负责将日志做记录。Handler具体实现了日志的输出位置，比如可以输出到控制台或者是文件中等等。
Filter：过滤器，根据需要定制哪些信息会被记录，哪些信息会被略过。
Formatter：格式化组件，它负责对日志中的数据和信息进行转换和格式化，所以它决定了我们输出日志最终的形式。
Level：日志的输出级别，每条日志消息都有一个关联的级别。我们根据输出级别的设置，用来展现最终所呈现的日志信息。根据不同的需求，去设置不同的级别。

基本使用

logger.getLogger(String name) 根据名字获取logger对象，如果该名字的logger存在则直接返回若不存在则创建新的logger，这个新的logger会使用它父logger的设置，若它父logger没有指定则默认RootLogger

Logger logger = Logger.getLogger("com.codexie");
        //取消默认设置
        logger.setUseParentHandlers(false);
        //设置handlers
        try {
            FileHandler fileHandler = new FileHandler("logger.log");
            SimpleFormatter formatter = new SimpleFormatter();
            ConsoleHandler consoleHandler = new ConsoleHandler();

            fileHandler.setFormatter(formatter);
            fileHandler.setLevel(Level.ALL);
            consoleHandler.setFormatter(new SimpleFormatter());
            consoleHandler.setLevel(Level.ALL);

            logger.addHandler(fileHandler);
            logger.addHandler(consoleHandler);

            logger.setLevel(Level.ALL);

            logger.fine("file");
            logger.config("config");
            logger.info("info");
            logger.warning("warning");
            logger.severe("severe");

        } catch (IOException e) {
            e.printStackTrace();
        }

日志的级别

日志的级别（通过源码查看，非常简单）

          SEVERE : 错误 --- 最高级的日志级别
          WARNING : 警告
          INFO : （默认级别）消息
          CONFIG : 配置
          FINE : 详细信息（少）
          FINER : 详细信息（中）
          FINEST : 详细信息 （多） --- 最低级的日志级别

        两个特殊的级别
           OFF 可用来关闭日志记录
           ALL 启用所有消息的日志记录

        对于日志的级别，我们重点关注的是new对象的时候的第二个参数
        是一个数值
        OFF Integer.MAX_VALUE 整型最大值

        SEVERE 1000
        WARNING 900

        ...
        ...

        FINEST 300


        ALL Integer.MIN_VALUE 整型最小值

        这个数值的意义在于，如果我们设置的日志的级别是INFO -- 800
        那么最终展现的日志信息，必须是数值大于800的所有的日志信息
        最终展现的就是
        SEVERE
        WARNING
        INFO

注意：单单设置logger的level是不够的，必须要设置handler的级别才行

public void test03(){

        /*

            自定义日志的级别

         */
        //日志记录器
        Logger logger = Logger.getLogger("com.codexie");

        //将默认的日志打印方式关闭掉
        //参数设置为false，我们打印日志的方式就不会按照父logger默认的方式去进行操作
        logger.setUseParentHandlers(false);

        //处理器Handler
        //在此我们使用的是控制台日志处理器，取得处理器对象
        ConsoleHandler handler = new ConsoleHandler();
        //创建日志格式化组件对象
        SimpleFormatter formatter = new SimpleFormatter();

        //在处理器中设置输出格式
        handler.setFormatter(formatter);
        //在记录器中添加处理器
        logger.addHandler(handler);

        //设置日志的打印级别
        //此处必须将日志记录器和处理器的级别进行统一的设置，才会达到日志显示相应级别的效果
        //logger.setLevel(Level.CONFIG);
        //handler.setLevel(Level.CONFIG);

        logger.setLevel(Level.ALL);
        handler.setLevel(Level.ALL);

        logger.severe("severe信息");
        logger.warning("warning信息");
        logger.info("info信息");
        logger.config("config信息");
        logger.fine("fine信息");
        logger.finer("finer信息");
        logger.finest("finest信息");
 }

持久化操作

 public void test04() throws IOException {

        /*

            将日志输出到具体的磁盘文件中
            这样做相当于是做了日志的持久化操作

         */
        Logger logger = Logger.getLogger("com.codexie");
        logger.setUseParentHandlers(false);

        //文件日志处理器
        FileHandler handler = new FileHandler("D:\\test\\myLogTest.log");
        SimpleFormatter formatter = new SimpleFormatter();
        handler.setFormatter(formatter);
        logger.addHandler(handler);

        //也可以同时在控制台和文件中进行打印
        ConsoleHandler handler2 = new ConsoleHandler();
        handler2.setFormatter(formatter);
        logger.addHandler(handler2); //可以在记录器中同时添加多个处理器

        logger.setLevel(Level.ALL);
        handler.setLevel(Level.ALL);
        handler2.setLevel(Level.CONFIG);

        logger.severe("severe信息");
        logger.warning("warning信息");
        logger.info("info信息");
        logger.config("config信息");
        logger.fine("fine信息");
        logger.finer("finer信息");
        logger.finest("finest信息");


        /*

            总结：
                用户使用Logger来进行日志的记录，Logger可以持有多个处理器Handler
                （日志的记录使用的是Logger，日志的输出使用的是Handler）
                添加了哪些handler对象，就相当于需要根据所添加的handler
                将日志输出到指定的位置上，例如控制台、文件..

         */


    }

logger的父子关系

public void test05(){

        /*

            Logger之间的父子关系
                JUL中Logger之间是存在"父子"关系的
                值得注意的是，这种父子关系不是我们普遍认为的类之间的继承关系
                关系是通过树状结构存储的

                JUL在初始化时会创建一个顶层RootLogger作为所有Logger的父Logger
                查看源码：
                    owner.rootLogger = owner.new RootLogger();
                    RootLogger是LogManager的内部类
                    java.util.logging.LogManager$RootLogger
                    默认的名称为 空串

                以上的RootLogger对象作为树状结构的根节点存在的
                将来自定义的父子关系通过路径来进行关联
                父子关系，同时也是节点之间的挂载关系
                owner.addLogger(owner.rootLogger);
                LoggerContext cx = getUserContext(); //LoggerContext一种用来保存节点的Map关系

                private LogNode               node; //节点

         */

        /*

            从下面创建的两个logger对象看来
            我们可以认为logger1是logger2的父亲

         */

        //父亲是RootLogger，名称默认是一个空的字符串
        //RootLogger可以被称之为所有logger对象的顶层logger
        Logger logger1 = Logger.getLogger("com.bjpowernode.jul.test");

        Logger logger2 = Logger.getLogger("com.bjpowernode.jul.test.JULTest");

        //System.out.println(logger2.getParent()==logger1); //true

        System.out.println("logger1的父Logger引用为:"
                +logger1.getParent()+"; 名称为"+logger1.getName()+"; 父亲的名称为"+logger1.getParent().getName());


        System.out.println("logger2的父Logger引用为:"
                +logger2.getParent()+"; 名称为"+logger2.getName()+"; 父亲的名称为"+logger2.getParent().getName());


        /*

            父亲所做的设置，也能够同时作用于儿子
            对logger1做日志打印相关的设置，然后我们使用logger2进行日志的打印

         */
        //父亲做设置
        logger1.setUseParentHandlers(false);
        ConsoleHandler handler = new ConsoleHandler();
        SimpleFormatter formatter = new SimpleFormatter();
        handler.setFormatter(formatter);
        logger1.addHandler(handler);
        handler.setLevel(Level.ALL);
        logger1.setLevel(Level.ALL);

        //儿子做打印
        logger2.severe("severe信息");
        logger2.warning("warning信息");
        logger2.info("info信息");
        logger2.config("config信息");
        logger2.fine("fine信息");
        logger2.finer("finer信息");
        logger2.finest("finest信息");
    }

自定义属性文件

以上所有的配置相关的操作，都是以java硬编码的形式进行的
我们可以使用更加清晰，更加专业的一种做法，就是使用配置文件
如果我们没有自己添加配置文件，则会使用系统默认的配置文件
这个配置文件：
owner.readPrimordialConfiguration();
readConfiguration();
java.home --> 找到jre文件夹 --> lib --> logging.properties

#RootLogger的处理器，在获取RootLogger对象时进行的设置
#默认情况下，下述配置的时控制台的处理器，只能往控制台上进行输出操作
#如果想要添加其他的处理器，在当前处理器类后面通过逗号的形式分隔，可以添加多个处理器
handlers= java.util.logging.ConsoleHandler

#RootLogger的日志级别
.level= INFO

#文件处理器的设置
#输出文件路径
java.util.logging.FileHandler.pattern = %h/java%u.log
java.util.logging.FileHandler.level = ALL
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
#设置日志为追加而不是覆盖
java.util.logging.FileHandler.append = true
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter

# Limit the message that are printed on the console to INFO and above.
java.util.logging.ConsoleHandler.level = ALL
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

#自定义logger
com.codexie.handlers=java.util.logging.ConsoleHandler,java.util.logging.FileHandler
com.codexie.level=ALL
com.codexie.useParentHandlers=false