Java 日志框架~再学习

发表于 | 分类于 |

很重要，但又可以忽略，但又不得不提的东西。
这里面有很多的思想，如果你有设计模式基础，你应该看着会很舒服。
这里不再是简单的使用，而是有源码的解读，会对比各种日志（门面、实现）的优缺点，不同之处吧算是了。
.
“”””””””””””””
“”” 文章待整理 “””
“”””””””””””””
1、SpringBoot Controller 包打印日志：请求参数，返回值
2、SpringBoot 使用 AOP 来抽取日志
3、SpringBoot 日志问题整理总结
4、Java 执行 main 方法时关掉日志打印
5、【SpringBoot】①入门，配置，日志
.
2021-11-06 00:13:42
最近到的新公司，为了第一版的新功能上线，也是有在忙，今天已经是周六了。

日志的概念

2021-11-05 17:14:55

概述

日志文件是用于记录系统操作事件的文件集合，可分为事件日志和消息日志。具有处理历史数据、诊断问题的追踪以及理解系统的活动等重要作用。

在计算机中，日志文件是记录在操作系统或其他软件运行中发生的事件或在通信软件的不同用户之间的消息的文件。记录是保持日志的行为。在最简单的情况下，消息被写入单个日志文件。

日志的作用

  • 调试
    在Java项目调试时，查看栈信息可以方便地知道当前程序的运行状态， 输出的日志便于记录程序在之前的运行结果。如果你大量使用System.out或者System.err，这是一种最方便最有效的方法，但显得不够专业。

  • 错误定位
    不要以为项目能正确跑起来就可以高枕无忧，项目在运行一段时候后，可能由于数据问题，网络问题，内存问题等出现异常。这时日志可以帮助开发或者运维人员快速定位错误位置，提出解决方案。

  • 数据分析
    大数据的兴起，使得大量的日志分析成为可能，ELK也让日志分析门槛降低了很多。日志中蕴含了大量的用户数据，包括点击行为，兴趣偏好等，用户画像对于公司下一步的战略方向有一定指引作用。

接触过的日志

最简单的日志输出方式，我们每天都在使用：

1
System.out.println("这个数的结果是："+ num);

以及错误日志：

1
System.err.println("此处发生了异常");

此类代码在程序的执行过程中没有什么实质的作用，但是却能打印一些中间变量，辅助我们调试和错误的排查。

日志系统我们也见过：
在tomcat中
在这里插入图片描述

当我们的程序无法启动或者运行过程中产生问题，会有所记录，比如我的catalina.log中查看，发现确实有错误信息，这能帮我们迅速定位：
在这里插入图片描述
而我们的System.err只能做到控制台打印日志，所以我们需要更强大日志框架来处理：

主流日志框架

  • 日志实现（具体干活的）实现类：JUL（java util logging）、logback、
    log4j、log4j2

  • 日志门面（指定规则的）接口：JCL（Jakarta Commons Logging）、
    slf4j（ Simple Logging Facade for Java）

JUL日志框架

2021-11-05 17:21:23

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

在JUL中有以下组件，我们先做了解，慢慢学习：

  • Loggers：被称为记录器，应用程序通过获取Logger对象，调用其API来来发布日志信息。Logger 通常时应用程序访问日志系统的入口程序。

  • Appenders：也被称为Handlers，每个Logger都会关联一组 Handlers，Logger会将日志交给关联 Handlers处理，由Handlers负责将日志做记录。Handlers在此是一个抽象，其具体的实现决定了 日志记录的位置可以是控制台、文件、网络上的其他日志服务或操作系统日志等。

  • Layouts：也被称为Formatters，它负责对日志事件中的数据进行转换和格式化。Layouts决定了 数据在一条日志记录中的最终形式。

  • Level：每条日志消息都有一个关联的日志级别。该级别粗略指导了日志消息的重要性和紧迫，我 可以将Level和Loggers，Appenders做关联以便于我们过滤消息。

  • Filters：过滤器，根据需要定制哪些信息会被记录，哪些信息会被放过。

总结一下就是：
用户使用Logger来进行日志记录，Logger持有若干个Handler，日志的输出操作是由Handler完成的。
在Handler在输出日志前，会经过Filter的过滤，判断哪些日志级别过滤放行哪些拦截，Handler会将日志内容输出到指定位置（日志文件、控制台等）。Handler在输出日志时会使用Layout，将输出内容进行排版。

入门案例

1
2
3
4
5
6
public static void main(String[] args) {
    Logger logger = Logger.getLogger("myLogger");
    logger.info("信息");
    logger.warning("警告信息");
    logger.severe("严重信息");
}

在这里插入图片描述

日志的级别

jul中定义的日志级别，从上述例子中我们也看到使用info和warning打印出的日志有不同的前缀，通过给日志设置不同的级别可以清晰的从日志中区分出哪些是基本信息，哪些是调试信息，哪些是严重的异常。

java.util.logging.Level中定义了日志的级别：
1、SEVERE（最高值）
2、WARNING
3、INFO （默认级别）
4、CONFIG
5、FINE
6、FINER
7、FINEST（最低值）

再例如：我们查看tomcat的日志，能明显的看到不同级别的日志，其实tomcat默认使用的就是JUL：
在这里插入图片描述

还有两个特殊的级别：

  • OFF，可用来关闭日志记录。
  • ALL，启用所有消息的日志记录。

虽然我们测试了7个日志级别

1
2
3
4
5
6
7
8
9
10
11
@Test
public void testLogger() {
    Logger logger = Logger.getLogger(LoggerTest.class.getName());
    logger.severe("severe");
    logger.warning("warning");
    logger.info("info");
    logger.config("config");
    logger.fine("fine");
    logger.finer("finer");
    logger.finest("finest");
}

我们发现能够打印的只有三行，这是为什么呢？
在这里插入图片描述

我们找一下这个文件，下图是jdk11的日志配置文件：
在这里插入图片描述

或者在jdk1.8中：
在这里插入图片描述
在这里插入图片描述

就可以看到系统默认在控制台打印的日志级别了，系统配置我们暂且不动，一会我们独立创建配置文件完成修改。
但是我们可以简单的看看这个日志配置了哪些内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
.level= INFO
############################################################
# Handler specific properties.
# Describes specific configuration info for Handlers.
############################################################

# default file output is in user's home directory.
java.util.logging.FileHandler.pattern = %h/java%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1

# Default number of locks FileHandler can obtain synchronously.
# This specifies maximum number of attempts to obtain lock file by FileHandler
# implemented by incrementing the unique field %u as per FileHandler API documentation.
java.util.logging.FileHandler.maxLocks = 100
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter

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

在日志中我们发现了，貌似可以给这个日志对象添加各种handler就是处理器，比如ConsoleHandler专门处理控制台日志，FileHandler貌似可以处理文件，同时我们确实发现了他有这么一个方法：
在这里插入图片描述

日志配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
    @Test
    public void testLogConfig() throws Exception {
        // 1.创建日志记录器对象
        Logger logger = Logger.getLogger("com.taopanfeng.log.JULTest");
        // 一、自定义日志级别
        // a.关闭系统默认配置
        logger.setUseParentHandlers(false);
        // b.创建handler对象
        ConsoleHandler consoleHandler = new ConsoleHandler();
        // c.创建formatter对象
        SimpleFormatter simpleFormatter = new SimpleFormatter();
        // d.进行关联 consoleHandler.setFormatter(simpleFormatter);
        logger.addHandler(consoleHandler);
        // e.设置日志级别
        logger.setLevel(Level.ALL);
        consoleHandler.setLevel(Level.ALL);
        // 二、输出到日志文件
        FileHandler fileHandler = new FileHandler("d:/logs/jul.log");
        fileHandler.setFormatter(simpleFormatter);
        logger.addHandler(fileHandler);
        // 2.日志记录输出
        logger.severe("severe");
        logger.warning("warning");
        logger.info("info");
        logger.config("config");
        logger.fine("fine");
        logger.finer("finer");
        logger.finest("finest");
    }
/*
再次查看结果：
10月 21, 2021 11:50:01 上午 com.taopanfeng.entity.LoggerTest testConfig
严重: severe
10月 21, 2021 11:50:01 上午 com.taopanfeng.entity.LoggerTest testConfig
警告: warning
10月 21, 2021 11:50:01 上午 com.taopanfeng.entity.LoggerTest testConfig
信息: info
10月 21, 2021 11:50:01 上午 com.taopanfeng.entity.LoggerTest testConfig
配置: config
10月 21, 2021 11:50:01 上午 com.taopanfeng.entity.LoggerTest testConfig
详细: fine
10月 21, 2021 11:50:01 上午 com.taopanfeng.entity.LoggerTest testConfig
较详细: finer
10月 21, 2021 11:50:01 上午 com.taopanfeng.entity.LoggerTest testConfig
非常详细: finest

Process finished with exit code 0
*/

文件中也输出了正确的结果：
在这里插入图片描述

Logger之间的父子关系

JUL中Logger之间存在父子关系，这种父子关系通过树状结构存储，JUL在初始化时会创建一个顶层 RootLogger作为所有Logger父Logger，存储上作为树状结构的根节点。并父子关系通过名称来关联。默认子Logger会继承父Logger的属性。
在这里插入图片描述

所有的logger实例都是由LogManager统一管理，不妨我们点进getLogger方法：

1
2
3
4
5
6
7
8
9
10
11
private static Logger demandLogger(String name, String resourceBundleName, Class<?> caller) {
    LogManager manager = LogManager.getLogManager();
    if (!SystemLoggerHelper.disableCallerCheck) {
        if (isSystem(caller.getModule())) {
            return manager.demandSystemLogger(name, resourceBundleName, caller);
        }
    }
    return manager.demandLogger(name, resourceBundleName, caller);
    // ends up calling new Logger(name, resourceBundleName, caller)
    // iff the logger doesn't exist already
}

我们可以看到LogManager是单例的：

1
2
3
4
5
6
public static LogManager getLogManager() {
    if (manager != null) {
        manager.ensureLogManagerInitialized();
    }
    return manager;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
    @Test
    public void testLogParent() throws Exception {
        Logger logger1 = Logger.getLogger("com.taopanfeng.service");
        Logger logger2 = Logger.getLogger("com.taopanfeng");
        System.out.println("logger1 = " + logger1);
        System.out.println("logger1.getParent() = " + logger1.getParent());
        System.out.println("logger2 = " + logger2);
        System.out.println("logger2.getParent() = " + logger2.getParent());
        System.out.println(logger1.getParent() == logger2);
    }

/*
结果： 
logger1 = java.util.logging.Logger@2b4bac49
logger1.getParent() = java.util.logging.Logger@fd07cbb
logger2 = java.util.logging.Logger@fd07cbb
logger2.getParent() = java.util.logging.LogManager$RootLogger@3571b748
true
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
    @Test
    public void testLogParent() throws Exception {
        Logger logger1 = Logger.getLogger("com.taopanfeng.service");
        Logger logger2 = Logger.getLogger("com.taopanfeng");
        // 一、对logger2进行独立的配置
        // 1.关闭系统默认配置 logger2.setUseParentHandlers(false);
        // 2.创建handler对象
        ConsoleHandler consoleHandler = new ConsoleHandler();
        // 3.创建formatter对象
        SimpleFormatter simpleFormatter = new SimpleFormatter();
        // 4.进行关联
        consoleHandler.setFormatter(simpleFormatter);
        logger2.addHandler(consoleHandler);
        // 5.设置日志级别
        logger2.setLevel(Level.ALL);
        consoleHandler.setLevel(Level.ALL);
        // 测试logger1是否被logger2影响
        logger1.severe("severe");
        logger1.warning("warning");
        logger1.info("info");
        logger1.config("config");
        logger1.fine("fine");
        logger1.finer("finer");
        logger1.finest("finest");
    }


/*
10月 21, 2021 12:45:15 下午 com.taopanfeng.entity.LoggerTest testLogParent
严重: severe
10月 21, 2021 12:45:15 下午 com.taopanfeng.entity.LoggerTest testLogParent
警告: warning
10月 21, 2021 12:45:15 下午 com.taopanfeng.entity.LoggerTest testLogParent
信息: info
10月 21, 2021 12:45:15 下午 com.taopanfeng.entity.LoggerTest testLogParent
配置: config
10月 21, 2021 12:45:15 下午 com.taopanfeng.entity.LoggerTest testLogParent
详细: fine
10月 21, 2021 12:45:15 下午 com.taopanfeng.entity.LoggerTest testLogParent
较详细: finer
10月 21, 2021 12:45:15 下午 com.taopanfeng.entity.LoggerTest testLogParent
非常详细: finest

Process finished with exit code 0
*/

日志格式化

我们可以独立的实现日志格式化的Formatter，而不使用SimpleFormatter，我们可以做如下处理，最后返回的结果我们可以随意拼写：

1
2
3
4
5
6
7
8
9
10
Formatter myFormatter = new Formatter() {
    @Override
    public String format(LogRecord record) {
        return record.getLoggerName() + "."
                + record.getSourceMethodName() + " "
                + LocalDateTime.ofInstant(record.getInstant(), ZoneId.systemDefault()) + "\r\n"
                + record.getLevel() + ": "
                + record.getMessage() + "\r\n";
    }
};

结果为：
在这里插入图片描述

当然我们参考一下SimpleFormatter的该方法的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// format string for printing the log record
    static String getLoggingProperty(String name) {
        return LogManager.getLogManager().getProperty(name);
    }

    private final String format = SurrogateLogger.getSimpleFormat(SimpleFormatter::getL oggingProperty);
    ZonedDateTime zdt = ZonedDateTime.ofInstant(record.getInstant(), ZoneId.systemDefault());
    return String.format(format,
        zdt,
        source,
        record.getLoggerName(),
        record.getLevel().getLocalizedLevelName(),
        message,
        throwable);

这个写法貌似比我们的写法高级一点，所以我们必须好好学一下String的format方法了。

String的format方法

String类的format()方法用于创建格式化的字符串以及连接多个字符串对象。

format()方法有两种重载形式：

1
2
3
4
5
6
7
public static String format(String format, Object... args) {
    return new Formatter().format(format, args).toString();
}

public static String format(Locale l, String format, Object... args) {
    return new Formatter(l).format(format, args).toString();
}

在这个方法中我们可以定义字符串模板，然后使用类似填空的方式将模板格式化成我们想要的结果字符串：

1
String java = String.format("hello %s", "world");

得到的结果就是hello world，我们可以把第一个参数当做模板， %s当做填空题，后边的可变参数当做答案。

常用的转换符

当然不同数据类型需要不同转换符完成字符串的转换，以下是不同类型的转化符列表：
在这里插入图片描述

小例子：

1
2
System.out.printf("过年了，%s今年%d岁了，今天收了%f元的压岁 钱!", "小明",5,88.88);
// 结果：过年了，小明今年5岁了，今天收了88.880000元的压岁钱!

这要比拼写字符串简单多了。

特殊符号

接下来我们看几个特殊字符的常用搭配，可以实现一些高级功能：
在这里插入图片描述

1
2
System.out.printf("过年了，%s今年%03d岁了，今天收了%,f元的压 岁钱!", "小明",5,8888.88);
// 结果 过年了，小明今年005岁了，今天收了8,888.880000元的压岁 钱!

默认情况下，我们的可变参数是安装顺序依次替换，但是我想重复利用可变参数那该怎么处理呢？

1
2
3
4
5
// 我们可以采用 在转换符中加数字$完成匹配：
System.out.printf("%1$s %1$s %1$s","小明");

// 其中1$就代表第一个参数，那么2$就代表第二个参数了：
// 小明 小明 小明

日期处理

第一个例子中有说到 %tx x代表日期转换符 我也顺便列举下日期转换符
在这里插入图片描述

我们可以使用以下三个类去进行格式化，其中可能存在不支持的情况，比如LocalDateTime不支持c：

1
2
3
System.out.printf("%tc",new Date());
System.out.printf("%tc",ZonedDateTime.now());
System.out.printf("%tF",LocalDateTime.now());

此时我们使用debug查看，默认情况下的fomat，我们不妨来读一读：
在这里插入图片描述

1
2
10月 21, 2021 2:23:42 下午 com.taopanfeng.entity.LoggerTest testLogParent
警告: warning

配置文件

我们不妨看看一个文件处理器的源码是怎么读配置项的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
private void configure() {
    LogManager manager = LogManager.getLogManager();
    String cname = getClass().getName();
    pattern = manager.getStringProperty(cname + ".pattern", "%h/java%u.log");
    limit = manager.getLongProperty(cname + ".limit", 0);
    if (limit < 0) {
        limit = 0;
    }
    count = manager.getIntProperty(cname + ".count", 1);
    if (count <= 0) {
        count = 1;
    }
    append = manager.getBooleanProperty(cname + ".append", false);
    setLevel(manager.getLevelProperty(cname + ".level", Level.ALL));
    setFilter(manager.getFilterProperty(cname + ".filter", null));
    setFormatter(manager.getFormatterProperty(cname + ".formatter", new XMLFormatter()));
    // Initialize maxLocks from the logging.properties file.
    // If invalid/no property is provided 100 will be used as a default value.
    maxLocks = manager.getIntProperty(cname + ".maxLocks", MAX_LOCKS);
    if (maxLocks <= 0) {
        maxLocks = MAX_LOCKS;
    }
    try {
        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;
        }
    }
}

可以从以下源码中看到配置项：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class FileHandler extends StreamHandler {
    private MeteredStream meter;
    private boolean append;
    // 限制文件大小
    private long limit; // zero => no limit.
    // 控制日志文件的数量
    private int count;
    // 日志文件的格式化方式
    private String pattern;
    private String lockFileName;
    private FileChannel lockFileChannel;
    private File files[];
    private static final int MAX_LOCKS = 100;
    // 可以理解为同时可以有多少个线程打开文件，源码中有介绍
    private int maxLocks = MAX_LOCKS;
    private static final Set<String> locks = new HashSet<>();
}

我们已经知道系统默认的配置文件的位置，那我们能不能自定义呢？当然可以了，我们从jdk中赋值一个配置文件过来：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
.level= INFO

# default file output is in user's home directory.
java.util.logging.FileHandler.pattern = %h/java%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1

# Default number of locks FileHandler can obtain synchronously.
# This specifies maximum number of attempts to obtain lock file by FileHandler
# implemented by incrementing the unique field %u as per FileHandler API documentation.
java.util.logging.FileHandler.maxLocks = 100
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter

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

# java.util.logging.SimpleFormatter.format=%4$s: %5$s [%1$tc]%n
pattern = manager.getStringProperty(cname + ".pattern", "%h/java%u.log");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
static File generate(String pat, int count, int generation, int unique) throws IOException {
    Path path = Paths.get(pat);
    Path result = null;
    boolean sawg = false;
    boolean sawu = false;
    StringBuilder word = new StringBuilder();
    Path prev = null;
    for (Path elem : path) {
        if (prev != null) {
            prev = prev.resolveSibling(word.toString());
            result = result == null ? prev : result.resolve(prev);
        }
        String pattern = elem.toString();
        int ix = 0;
        word.setLength(0);
        while (ix < pattern.length()) {
            char ch = pattern.charAt(ix);
            ix++;
            char ch2 = 0;
            if (ix < pattern.length()) {
                ch2 = Character.toLowerCase(pattern.charAt(ix));
            }
            if (ch == '%') {
                if (ch2 == 't') {
                    String tmpDir = System.getProperty("java.io.tmpdir");
                    if (tmpDir == null) {
                        tmpDir = System.getProperty("user.home");
                    }
                    result = Paths.get(tmpDir);
                    ix++;
                    word.setLength(0);
                    continue;
                } else if (ch2 == 'h') {
                    result = Paths.get(System.getProperty("user.home"));
                    if (jdk.internal.misc.VM.isSetUID()) {
                        // Ok, we are in a set UID program. For safety's sake
                        // we disallow attempts to open files relative to %h.
                        throw new IOException("can't use %h in set UID program");
                    }
                    ix++;
                    word.setLength(0);
                    continue;
                } else if (ch2 == 'g') {
                    word = word.append(generation);
                    sawg = true;
                    ix++;
                    continue;
                } else if (ch2 == 'u') {
                    word = word.append(unique);
                    sawu = true;
                    ix++;
                    continue;
                } else if (ch2 == '%') {
                    word = word.append('%');
                    ix++;
                    continue;
                }
            }
            word = word.append(ch);
        }
        prev = elem;
    }
    if (count > 1 && !sawg) {
        word = word.append('.').append(generation);
    }
    if (unique > 0 && !sawu) {
        word = word.append('.').append(unique);
    }
    if (word.length() > 0) {
        String n = word.toString();
        Path p = prev == null ? Paths.get(n) : prev.resolveSibling(n);
        result = result == null ? p : result.resolve(p);
    } else if (result == null) {
        result = Paths.get("");
    }
    if (path.getRoot() == null) {
        return result.toFile();
    } else {
        return path.getRoot().resolve(result).toFile();
    }
}

我们将拷贝的文件稍作修改：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
.level= INFO

# default file output is in user's home directory.
java.util.logging.FileHandler.pattern = D:/log/java%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.maxLocks = 100
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter

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

# java.util.logging.SimpleFormatter.format=%4$s: %5$s [%1$tc]%n
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Test
public void testProperties() throws Exception {
    // 读取自定义配置文件
    InputStream in = JULTest.class.getClassLoader().getResourceAsStream("l ogging.properties");
    // 获取日志管理器对象
    LogManager logManager = LogManager.getLogManager();
    // 通过日志管理器加载配置文件
    logManager.readConfiguration(in);
    Logger logger = Logger.getLogger("com.taopanfeng.log.JULTest");
    logger.severe("severe");
    logger.warning("warning");
    logger.info("info");
    logger.config("config");
    logger.fine("fine");
    logger.finer("finer");
    logger.finest("finest");
}

配置文件：

1
2
3
4
5
6
7
8
9
10
11
12
handlers= java.util.logging.ConsoleHandler,java.util.logging.Fil eHandler
.level= INFO

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.maxLocks = 100
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter

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

在这里插入图片描述

文件中也出现了：
在这里插入图片描述

打开日志发现是xml，因为这里用的就是XMLFormatter：
在这里插入图片描述

上边我们配置了两个handler给根Logger，我们还可以给其他的Logger做独立的配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
handlers=java.util.logging.ConsoleHandler
.level=INFO

# 对这个logger独立配置
com.taopanfeng.handlers=java.util.logging.FileHandler
com.taopanfeng.level=ALL
com.taopanfeng.useParentHandlers=false

#修改了名字
java.util.logging.FileHandler.pattern=D:/logs/taopanfeng-java%u.log
java.util.logging.FileHandler.limit=50000
java.util.logging.FileHandler.count=1
java.util.logging.FileHandler.maxLocks=100
java.util.logging.FileHandler.formatter=
java.util.logging.SimpleFormatter

#文件使用追加方式
java.util.logging.FileHandler.append=true

#Limitthemessagethatareprintedontheconsoleto INFOandabove.
java.util.logging.ConsoleHandler.level=INFO
java.util.logging.ConsoleHandler.formatter=
java.util.logging.SimpleFormatter

#修改日志格式
java.util.logging.SimpleFormatter.format=%4$s:%5$s[%1$tc]%n

执行发现控制台没有内容，文件中有了，说明没有问题OK了：
在这里插入图片描述

日志出现以下内容：
在这里插入图片描述

LOG4J 日志框架

Log4j是Apache下的一款开源的日志框架。官方网站：http://logging.apache.org/log4j/1.2/，这是一款比较老的日志框架，目前新的log4j2做了很大的改动，仍然有一些项目在使用log4j。

入门案例

1、建立maven工程
2、添加依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<dependencies>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
    </dependency>
</dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler- plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <source>${maven.compiler.source}</source>
                <target>${maven.compiler.target}</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
    </plugins>
</build>

3、java代码

1
2
3
4
5
6
7
8
9
10
11
@Test
public void testLogger() {
    Logger logger = Logger.getLogger(Log4jTest.class); // 日志记录输出
    logger.info("hello log4j"); // 日志级别
    logger.fatal("fatal"); // 严重错误，一般会造成系统崩溃 和终止运行
    logger.error("error"); // 错误信息，但不会影响系统运行
    logger.warn("warn"); // 警告信息，可能会发生问题
    logger.info("info"); // 程序运行信息，数据库的连接、网 络、IO操作等
    logger.debug("debug"); // 调试信息，一般在开发阶段使 用，记录程序的变量、参数等
    logger.trace("trace"); // 追踪信息，记录程序的所有流程 信息
}

发现会有一些警告，JUL可以直接在控制台输出是因为他有默认的配置文件，而这个独立的第三方的日志框架却没有配置文件：

1
2
3
log4j:WARN No appenders could be found for logger (com.taopanfeng.entity.Log4jTest).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.

我们在执行代码之前，加上以下代码，他会初始化一个默认配置：

1
BasicConfigurator.configure();

结果：

1
2
3
4
5
6
0 [main] INFO com.taopanfeng.entity.Log4jTest - hello log4j
1 [main] FATAL com.taopanfeng.entity.Log4jTest - fatal
1 [main] ERROR com.taopanfeng.entity.Log4jTest - error
1 [main] WARN com.taopanfeng.entity.Log4jTest - warn
1 [main] INFO com.taopanfeng.entity.Log4jTest - info
1 [main] DEBUG com.taopanfeng.entity.Log4jTest - debug

从源码看，这一行代码给我们的RootLogger加入一个控制台的输出源，就和jul中的handler一样：

1
2
3
4
public static void configure() {
    Logger root = Logger.getRootLogger();
    root.addAppender(new ConsoleAppender(new PatternLayout("%r [%t] %p %c %x - %m%n")));
}

log4j定义了以下的日志的级别，和JUL的略有不同：
1、fatal 指出每个严重的错误事件将会导致应用程序的退出。
2、error 指出虽然发生错误事件，但仍然不影响系统的继续运行。
3、warn 表明会出现潜在的错误情形。
4、info 一般和在粗粒度级别上，强调应用程序的运行全程。
5、debug 一般用于细粒度级别上，对调试应用程序非常有帮助。
6、trace 是程序追踪，可以用于输出程序运行中的变量，显示执行的流程。

和JUL一样：还有两个特殊的级别：OFF，可用来关闭日志记录。 ALL，启用所有消息的日志记录。

一般情况下，我们只使用4个级别，优先级从高到低为 ERROR > WARN > INFO > DEBUG。

组件讲解

Log4J 主要由 Loggers (日志记录器)、Appenders（输出端）和Layout（日志格式化器）组成。其中 Loggers 控制日志的输出级别与日志是否输出；Appenders 指定日志的输出方式（输出到控制台、文件 等）；Layout 控制日志信息的输出格式。

Loggers

日志记录器：负责收集处理日志记录，实例的命名就是类“XX”的fullquailied name（类的全限定名）， Logger的名字大小写敏感，其命名有继承机制：例如：name为com.taopanfeng.service的logger会继承 name为com.taopanfeng的logger，和JUL一致。

Log4J中有一个特殊的logger叫做“root”，他是所有logger的根，也就意味着其他所有的logger都会直接 或者间接地继承自root。root logger可以用Logger.getRootLogger()方法获取。 JUL是不是也有一个名为.的根。

Appenders

Appender和JUL的Handler很像，用来指定日志输出到哪个地方，可以同时指定日志的输出目的地。Log4j 常用的输出目的地 有以下几种：
在这里插入图片描述

1
2
3
4
5
// 配置一个控制台输出源
ConsoleAppender consoleAppender = new ConsoleAppender();
consoleAppender.setName("taopanfeng");
consoleAppender.setWriter(new PrintWriter(System.out));
logger.addAppender(consoleAppender);

Layouts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Layout layout = new Layout() {
    @Override
    public String format(LoggingEvent loggingEvent) {
        return loggingEvent.getLoggerName() + " " + loggingEvent.getMessage() + "\r\n";
    }

    @Override
    public boolean ignoresThrowable() {
        return false;
    }

    @Override
    public void activateOptions() {
    }
};

有一些默认的实现类：

1
Layout layout = new SimpleLayout();

在这里插入图片描述

他的实现太简单了：

1
2
3
4
5
6
7
8
public String format(LoggingEvent event) {
    sbuf.setLength(0);
    sbuf.append(event.getLevel().toString());
    sbuf.append(" - ");
    sbuf.append(event.getRenderedMessage());
    sbuf.append(LINE_SEP);
    return sbuf.toString();
}

还有一个比较常用的Layout，就是PatternLayout这个实现类，能够根据特定的占位符进行转化，和JUL很像，但是又不一样，我们庖丁解牛研究一番，首先看他的构造器，构造器中如果传入一个pattern字符串，他会根据这个pattern创建一个链表，这个链表具体干什么咱们慢慢往后看：

1
2
3
4
public PatternLayout(String pattern) {
    this.pattern = pattern;
    head = createPatternParser((pattern == null) ? DEFAULT_CONVERSION_PATTERN : pattern).parse();
}

将步骤拆解开来看，首先创建了一个解析器：

1
2
3
protected PatternParser createPatternParser(String pattern) {
    return new PatternParser(pattern);
}

查看parse方法，这个方法比较复杂我们简化来看：

1
2
3
4
5
6
7
8
9
10
public PatternConverter parse() {
    char c;
    i = 0;
    while (i < patternLength) {
        //...此次省略了很多代码，但是可以从这个核心看出来
        c = pattern.charAt(i++);
        finalizeConverter(c);
    }
    return head;
}

而finalizeConverter做的工作大家就能看的很清楚了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
protected void finalizeConverter(char c) {
    PatternConverter pc = null;
    switch (c) {
        case 'c':
            pc = new CategoryPatternConverter(formattingInfo, extractPrecisionOption());
            //LogLog.debug("CATEGORY converter."); 
            //formattingInfo.dump();
            currentLiteral.setLength(0);
            break;
        //处理类名的转化器
        case 'C':
            pc = new ClassNamePatternConverter(formattingInfo, extractPrecisionOption());
            //LogLog.debug("CLASS_NAME converter."); 
            //formattingInfo.dump(); 
            currentLiteral.setLength(0);
            break;
        //处理时间的转化器
        case 'd':
            String dateFormatStr = AbsoluteTimeDateFormat.ISO8601_DATE_FORMAT;
            DateFormat df;
            //...
            pc = new DatePatternConverter(formattingInfo, df);
            currentLiteral.setLength(0);
            break;
        //输出日志时间发生的位置，包括类名、线程、及在代码中的行数
        case 'F':
            pc = new LocationPatternConverter(formattingInfo, FILE_LOCATION_CONVERTER);
            break;
        case 'l':
            pc = new LocationPatternConverter(formattingInfo, FULL_LOCATION_CONVERTER);
            currentLiteral.setLength(0);
            break;
        case 'L':
            pc = new LocationPatternConverter(formattingInfo, LINE_LOCATION_CONVERTER);
            currentLiteral.setLength(0);
            break;
        case 'm':
            pc = new BasicPatternConverter(formattingInfo, MESSAGE_CONVERTER);
            currentLiteral.setLength(0);
            break;
        case 'M':
            pc = new LocationPatternConverter(formattingInfo, METHOD_LOCATION_CONVERTER);
            currentLiteral.setLength(0);
            break;
        case 'p':
            pc = new BasicPatternConverter(formattingInfo, LEVEL_CONVERTER);
            currentLiteral.setLength(0);
            break;
        case 'r':
            pc = new BasicPatternConverter(formattingInfo, RELATIVE_TIME_CONVERTER);
            currentLiteral.setLength(0);
            break;
        case 't':
            pc = new BasicPatternConverter(formattingInfo, THREAD_CONVERTER);
            currentLiteral.setLength(0);
            break;
        case 'x':
            pc = new BasicPatternConverter(formattingInfo, NDC_CONVERTER);
            //LogLog.debug("NDC converter.");
            currentLiteral.setLength(0);
            break;
        case 'X':
            String xOpt = extractOption();
            pc = new MDCPatternConverter(formattingInfo, xOpt);
            currentLiteral.setLength(0);
            break;
        default:
            LogLog.error("Unexpected char [" + c + "] at position " + i + " in conversion patterrn.");
            pc = new LiteralPatternConverter(currentLiteral.toString());
            currentLiteral.setLength(0);
    }
    addConverter(pc);
}

下边就是一个典型的链表结构的构建了：

1
2
3
4
5
6
7
protected void addConverter(PatternConverter pc) {
    currentLiteral.setLength(0);
    // Add the pattern converter to the list.
    addToList(pc); // Next pattern is assumed to be a literal.
    state = LITERAL_STATE; // Reset formatting info
    formattingInfo.reset();