Java-日志管理

JUL(内置)

  • 基本使用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    		 
    package com.coderitl.test;

    import org.junit.jupiter.api.Test;

    import java.util.logging.Level;
    import java.util.logging.Logger;

    public class JUTDemo {
        @Test
        public void testJUL() {
            // 获取日志记录器对象 => 需要一个唯一标识(一般以当前类的全限定名称)
            Logger logger = Logger.getLogger("com.coderitl.test.JUTDemo");
            // 日志输出
            logger.info("日志记录输出");
            // 通用方法进行日志记录
            logger.log(Level.INFO, "info msg");
            // 通用占位符 方式输出变量
            String userName = "coder-itl";
            // 占位符索引要存在
            logger.log(Level.INFO, "用户信息: {0}", userName);
            logger.log(Level.INFO, "用户信息: {0}", new Object[]{userName});
        }
    }

  • 自定义日志级别

    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
    		 
    @Test
        public void testJULLevelConfig() throws IOException {
            // 获取日志记录器对象
            Logger logger = Logger.getLogger("com.coderitl.test.JUTDemo");
            // 关闭系统默认配置
            logger.setUseParentHandlers(false);

            // 自定义配置日志级别
            // 创建 ConsoleHandler 对象 => 控制台输出
            ConsoleHandler consoleHandler = new ConsoleHandler();
            // 创建简单格式转换对象
            SimpleFormatter simpleFormatter = new SimpleFormatter();
            // 进行关联
            consoleHandler.setFormatter(simpleFormatter);
            logger.addHandler(consoleHandler);
            // 配置具体日志级别
            logger.setLevel(Level.ALL);
            consoleHandler.setLevel(Level.ALL);
            // 文件输出
            FileHandler fileHandler = new FileHandler("E:\\log-demo\\logs\\jul.log");
            // 进行关联
            fileHandler.setFormatter(simpleFormatter);
            logger.addHandler(fileHandler);
            logger.severe("severe");
            logger.warning("warning");
            // jul 默认日志级别(低于 info 的日志信息不会显示)
            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
    13
    14
    15
    16
    17
    18
    19
    20
    21
    		 
    @Test
        public void testJUL_ConfigProperties() throws IOException {
            // 读取配置文件
            InputStream ins = JUTDemo.class.getClassLoader().getResourceAsStream("logging.properties");
            // 创建 logManager
            LogManager logManager = LogManager.getLogManager();
            // 通过
            logManager.readConfiguration(ins);

            // 获取日志记录器对象
            Logger logger = Logger.getLogger("com.coderitl.test");
            // 日志级别
            logger.severe("severe");
            logger.warning("warning");
            // jul 默认日志级别(低于 info 的日志信息不会显示)
            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
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    		 
    # RootLogger 顶级父元素默认的处理器为: ConsoleHandler
    handlers=java.util.logging.ConsoleHandler
    # RootLogger 级父元素默认的日志级别为: ALL
    .level=ALL
    # 自定义 Logger 使用
    com.coderitl.test.handlers=java.util.logging.ConsoleHandler
    com.coderitl.test.level=CONFIG
    # 关闭默认配置
    com.coderitl.test.useParentHandlers=false
    # 向日志文件输出的 handler 对象
    # 指定日志文件路径 /logs/java0.log
    java.util.logging.FileHandler.pattern=/logs/java%u.log
    # 指定日志文件内容大小
    java.util.logging.FileHandler.limit=50000
    # 指定日志文件数量
    java.util.logging.FileHandler.count=1
    # 指定 handler 对象日志消息格式对象
    java.util.logging.FileHandler.formatter=java.util.simpleFormatter
    # 指定以追加方式添加日志内容
    java.util.logging.FileHandler.append=true

    # 向控制台输出的 handler 对象
    # 指定 handler 对象的日志级别
    java.util.logging.ConsoleHandler.level=ALL
    # 指定 handler 对象地消息格式对象
    java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter
    # 指定 handler 对象的字符集(有点小问题)
    java.util.logging.SimpleFormatter.format=%4$s: %5$s [$l$tc]%n

LOG4J

  • 添加依赖

    1
    2
    3
    4
    5
    		 
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>

  • 基本使用

    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
    		 
    package com.coderitl.test;

    import org.apache.log4j.BasicConfigurator;
    import org.junit.jupiter.api.Test;
    import org.apache.log4j.Logger;

    public class Log4JTest {
        @Test
        public void testLog4J() {
            // 初始化配置信息,在入门案例中暂不使用配置文件
            BasicConfigurator.configure();
            // 获取日志记录器对象
            Logger logger = Logger.getLogger(Log4JTest.class);
            // 日志记录输出
            logger.info("log4j info...............");
            // 日志级别
            logger.fatal("fatal..."); // 严重错误,一般会造成影响系统崩溃并终止运行
            
            // 常用 4 个
            logger.error("error..."); // 错误信息,不会影响系统运行
            logger.warn("warn..."); // 警告信息,可能会发生问题
            logger.info("info..."); // 运行信息,数据库连接,网络连接, IO 操作等等
            logger.debug("debug..."); // 调式信息,一般在开发中使用,记录程序变量参数传递消息等等
            
            logger.trace("trace..."); // 追踪信息,记录程序所有的流程信息
        }
    }

  • 加载配置文件使用

    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
    		 
    # classpath:/log4j.properties:
    # Global logging configuration
    # 设置日志输出级别以及输出目的地，可以设置多个输出目的地，开发环境下，日志级别要设置成DEBUG或者ERROR
    # 前面写日志级别，逗号后面写输出目的地：我自己下面设置的目的地相对应，以逗号分开
    # log4j.rootLogger = [level],appenderName1,appenderName2,…
    log4j.rootLogger=DEBUG,CONSOLE,LOGFILE
    log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
    # 输出到控制台
    log4j.appender.CONSOLE.Target=System.out
    # 指定控制台输出日志级别
    log4j.appender.CONSOLE.Threshold=DEBUG
    # 默认值是 true, 表示是否立即输出
    log4j.appender.CONSOLE.ImmediateFlush=true
    # 设置编码方式
    log4j.appender.CONSOLE.Encoding=UTF-8
    # 日志输出布局
    log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
    # 如果日志输出布局为PatternLayout 自定义级别，需要使用ConversionPattern指定输出格式
    log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %5p (%c:%L) - %m%n
    log4j.appender.LOGFILE=org.apache.log4j.FileAppender
    # 指定输出文件路径
    #log4j.appender.LOGFILE.File =F://Intellij idea/logs/error.log
    log4j.appender.LOGFILE.File=./logs/error.log 
    #日志输出到文件，默认为true
    log4j.appender.LOGFILE.Append=true
    # 指定输出日志级别
    log4j.appender.LOGFILE.Threshold=ERROR
    # 是否立即输出，默认值是 true,
    log4j.appender.LOGFILE.ImmediateFlush=true
    # 设置编码方式
    log4j.appender.LOGFILE.Encoding=UTF-8
    # 日志输出布局
    log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
    # 如果日志输出布局为PatternLayout 自定义级别，需要使用ConversionPattern指定输出格式
    log4j.appender.LOGFILE.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

SLF4J

  • 依赖添加

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    		 
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.36</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-simple</artifactId>
        <version>1.7.36</version>
    </dependency>

  • 测试使用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    		 
    package com.coderitl.test;

    import org.junit.jupiter.api.Test;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;

    public class Slf4jTest {
        public static final Logger LOGGER = LoggerFactory.getLogger(Slf4jTest.class);

        @Test
        public void testSlf4j() {
            // 日志级别
            LOGGER.error("error");
            LOGGER.warn("error");
            LOGGER.info("info");
            LOGGER.debug("debug");
            LOGGER.trace("trace");
            // 参数输出
            String username = "coder-itl";
            LOGGER.info("用户信息: {}", username);
        }
    }