Kirin博客

合作

 

大横幅1
大横幅2
到期时间：永久 到期时间：推广
小横幅3 小横幅4
  2. 当前位置：网站首页 > 值得一看

logback详解及入门案例

Bee• 时间：2023-12-22• • 阅读 177 

1. logback

日志的作用

  • 记录系统和接口的使用情况，比如请求日志
  • 记录和分析用户的行为，比如网站访问日志
  • 调试程序，和控制台的作用类似，但是控制台中的内容并不会保存到文件中，而日志可以长期保存。
  • 帮助我们排查和定位错误。比如在系统抛出异常时，将异常信息记录到日志，可以事后复盘。
  • 通过分析日志还能够优化代码逻辑、提升系统性能、稳定性等。

1.1. logback介绍

Logback继承自log4j。Logback的架构非常的通用，适用于不同的使用场景。

通过上图可以看到logback和Log4j都是slf4j规范的具体实现，我们在程序中直接调用的API其实都是slf4j的api，底层则是真正的日志实现组件—logback或者log4j。

Logback 构建在三个主要的类上：Logger，Appender 和 Layout。这三个不同类型的组件一起作用能够让开发者根据消息的类型以及日志的级别来打印日志。

Logger作为日志的记录器，把它关联到应用的对应的context后，主要用于存放日志对象，也可以定义日志类型、级别。各个logger 都被关联到一个 LoggerContext，LoggerContext负责制造logger，也负责以树结构排列各 logger。

Appender主要用于指定日志输出的目的地，目的地可以是控制台、文件、 数据库等。

Layout 负责把事件转换成字符串，输出格式化的日志信息。

logback的maven坐标：

<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.12</version>
</dependency>

1.2. logback层级

在 logback中每一个 logger 都依附在 LoggerContext 上，它负责产生 logger，并且通过一个树状的层级结构来进行管理。

一个 Logger 被当作为一个实体，它们的命名是大小写敏感的，并且遵循以下规则：

如果一个logger的名字加上一个**.**作为另一个logger名字的前缀，那么该logger就是另一个logger的祖先。如果一个logger与另一个logger之间没有其它的logger，则该logger就是另一个logger的父级。

举例：
名为com.zbbmeta的logger是名为com.zbbmeta.service的logger的父级
名为com的logger是名为com.zbbmeta的logger的父级，是名为com.zbbmetat.service的logger的祖先

在logback中有一个root logger，它是logger层次结构的最高层，它是一个特殊的logger，因为它是每一个层次结构的一部分。

1.3. logback日志输出等级

logback的日志输出等级分为：TRACE, DEBUG, INFO, WARN, ERROR。

如果一个给定的logger没有指定一个日志输出等级，那么它就会继承离它最近的一个祖先的层级。

为了确保所有的logger都有一个日志输出等级，root logger会有一个默认输出等级 — DEBUG。

1.4 logback初始化步骤

  1. logback会在类路径下寻找名为logback-test.xml的文件
  2. 如果没有找到，logback会继续寻找名为logback.groovy的文件
  3. 如果没有找到，logback会继续寻找名为logback.xml的文件
  4. 如果没有找到，将会在类路径下寻找文件META-INFO/services/ch.qos.logback.classic.spi.Configurator，该文件的内容为实现了Configurator接口的实现类的全限定类名
  5. 如果以上都没有成功，logback会通过BasicConfigurator为自己进行配置，并且日志将会全部在控制台打印出来

最后一步的目的是为了保证在所有的配置文件都没有被找到的情况下，提供一个默认的配置。

2. logback入门案例

2.1. 案例一

本案例是一个logback简单应用，并且不提供配置文件而使用其提供的默认配置。

第一步：创建maven工程logback-demo并配置pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zbbmeta</groupId>
    <artifactId>logback-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

</project>

第二步：编写单元测试

package com.zbbmeta.logback;

import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.core.util.StatusPrinter;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 测试logback日志组件的使用
 */
public class LogbackTest {
    //简单使用
    @Test
    public void test1(){
        //通过工厂对象获得一个logger日志记录器对象
        Logger logger = LoggerFactory.getLogger("com.zbbmeta.test");
        //当前logger对象的日志输出级别为debug，从root logger继承来的
        //使用trace级别记录日志
        logger.trace("trace...");
        logger.debug("debug...");
        logger.info("info...");
        logger.warn("warn...");
        logger.error("error...");
    }

    //打印日志内部状态
    @Test
    public void test2(){
        //通过工厂对象获得一个logger日志记录器对象
        Logger logger = LoggerFactory.getLogger("com.zbbmeta.test");
        //当前logger对象的日志输出级别为debug，从root logger继承来的
        //使用trace级别记录日志
        logger.trace("trace...");
        logger.debug("debug...");
        logger.info("info...");
        logger.warn("warn...");
        logger.error("error...");

        // 打印内部的状态
        LoggerContext lc = (LoggerContext)LoggerFactory.getILoggerFactory();
        StatusPrinter.print(lc);
//        说明找文件步骤-->logback-test.xml-->logback.xml-->configuration
       /* |-INFO in ch.qos.logback.classic.LoggerContext[default] - Could NOT find resource [logback-test.xml]
       |-INFO in ch.qos.logback.classic.LoggerContext[default] - Could NOT find resource [logback.xml]
        |-INFO in ch.qos.logback.classic.BasicConfigurator@691a7f8f - Setting up default configuration.*/
    }

    /*
     * 日志输出级别：ERROR > WARN > INFO > DEBUG > TRACE
     * */

    //测试默认的日志输出级别
    @Test
    public void test3(){
        Logger logger = LoggerFactory.getLogger("com.zbbmeta.logback.HelloWorld");
        logger.error("error ...");
        logger.warn("warn ...");
        logger.info("info ...");
        logger.debug("debug ...");
        //因为默认的输出级别为debug，所以这一条日志不会输出
        logger.trace("trace ...");
    }

    //设置日志输出等级
    @Test
    public void test4(){
        ch.qos.logback.classic.Logger logger = (ch.qos.logback.classic.Logger)LoggerFactory.getLogger("com.zbbmeta.logback.HelloWorld");
        logger.setLevel(Level.DEBUG);//设置当前日志记录器对象的日志输出级别

        logger.error("error ...");
        logger.warn("warn ...");
        logger.info("info ...");
        logger.debug("debug ...");
        //因为默认的输出级别为debug，所以这一条日志不会输出
        logger.trace("trace ...");
    }

    //测试Logger的继承
    @Test
    public void test5(){
        ch.qos.logback.classic.Logger logger = (ch.qos.logback.classic.Logger)LoggerFactory.getLogger("com.zbbmeta");
        logger.setLevel(Level.TRACE);//设置当前日志记录器对象的日志输出级别

        //当前记录器对象是上面记录器对象的子级，从父级继承输出等级---INFO
        Logger logger1 = LoggerFactory.getLogger("com.zbbmeta.test");
        logger1.error("error ...");
        logger1.warn("warn ...");
        logger1.info("info ...");
        logger1.debug("debug ...");
        logger1.trace("trace ...");
    }

    //Logger获取，根据同一个名称获得的logger都是同一个实例
    @Test
    public void test6(){
        Logger logger1 = LoggerFactory.getLogger("com.zbbmeta.test");
        Logger logger2 = LoggerFactory.getLogger("com.zbbmeta.test");
        System.out.println(logger1 == logger2);
    }

    //参数化日志
    @Test
    public void test7(){
        Logger logger = LoggerFactory.getLogger("com.zbbmeta");
        String value = "world";
        logger.info("参数值为:" + value);
        logger.debug("hello {}","world");
    }
}

2.2 案例二

本案例是logback中Spring Boot项目中的应用。

第一步：创建maven工程springboot-logback-demo并配置pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.7.15</version>
    </parent>
    <groupId>com.zbbmeta</groupId>
    <artifactId>springboot-logback-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
        </dependency>
    </dependencies>
</project>

第二步：在resources下编写logback配置文件logback-base.xml和logback-spring.xml

logback-base.xml:作为基础配置

<?xml version="1.0" encoding="UTF-8"?>
<included>
    <contextName>logback</contextName>
    <!--
  name的值是变量的名称，value的值时变量定义的值
  定义变量后，可以使“${}”来使用变量
 -->
    <property name="log.path" value="logs" />

    <!-- 彩色日志 -->
    <!-- 彩色日志依赖的渲染类 -->
    <conversionRule
            conversionWord="clr"
            converterClass="org.springframework.boot.logging.logback.ColorConverter" />
    <conversionRule
            conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
    <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
    <!-- 彩色日志格式 -->
    <property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>

    <!--输出到控制台-->
    <appender name="LOG_CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
            <!-- 设置字符集 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!--输出到文件-->
    <appender name="LOG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/logback.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 每天日志归档路径以及格式 -->
            <fileNamePattern>${log.path}/info/log-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
    </appender>
</included>

logback-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!--引入其他配置文件-->
    <include resource="logback-base.xml" />
    <!--
    <logger>用来设置某一个包或者具体的某一个类的日志打印级别、
    以及指定<appender>。<logger>仅有一个name属性，
    一个可选的level和一个可选的addtivity属性。
    name:用来指定受此logger约束的某一个包或者具体的某一个类。
    level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
          如果未设置此属性，那么当前logger将会继承上级的级别。
    addtivity:是否向上级logger传递打印信息。默认是true。
     -->

    <!--开发环境-->
    <springProfile name="dev">
        <logger name="com.zbbmeta.controller" additivity="false" level="debug">
            <appender-ref ref="LOG_CONSOLE"/>
        </logger>
    </springProfile>
    <!--生产环境-->
    <springProfile name="pro">
        <logger name="com.zbbmeta.controller" additivity="false" level="info">
            <appender-ref ref="LOG_FILE"/>
        </logger>
    </springProfile>
    <!--
    root节点是必选节点，用来指定最基础的日志输出级别，只有一个level属性
    level:设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF 默认是DEBUG
    可以包含零个或多个元素，标识这个appender将会添加到这个logger。
    -->
    <root level="info">
        <appender-ref ref="LOG_CONSOLE" />
        <appender-ref ref="LOG_FILE" />
    </root>
</configuration>

第三步：编写application.yml

server:
  port: 8999

#logging:
#  #在Spring Boot项目中默认加载类路径下的logback-spring.xml文件
#  config: classpath:logback.xml

logging:
  #在Spring Boot项目中默认加载类路径下的logback-spring.xml文件
  config: classpath:logback-spring.xml

spring:
  profiles:
    active: dev

第四步：创建TutorialController

package com.zbbmeta.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.*;

import java.util.Objects;

/**
 * @author springboot
 * @description: TODO
 */

@RestController
@RequestMapping("/api")
public class TutorialController {

    private static final Logger log = LoggerFactory.getLogger(TutorialController.class);

    /**
     * 根据ID查询Tutorial
     * @param id
     * @return
     */
    @GetMapping("/tutorials/{id}")
    public void getTutorialById(@PathVariable("id") long id) {
        log.trace("trace...");
        log.debug("debug...");
        log.info("info...");
        log.warn("warn...");
        log.error("error...");

    }

}

第五步：创建启动类

package com.zbbmeta;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author springboot
 * @description: TODO
 */
@SpringBootApplication
public class LogbackDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(LogbackDemoApplication.class,args);
    }
}

启动项目，访问地址：http://localhost:8999/api/tutorials/1

可以看到控制台已经开始输出日志信息。

修改application.yml文件中的开发模式为pro，重启项目这日志输出到了文件中。

Java SpringBoot logback 日志
本文最后更新于2023-12-22，已超过 3个月没有更新，如果文章内容或图片资源失效，请留言反馈，我们会及时处理，谢谢！
获取更多资讯请加入交流群

    协助本站SEO优化一下，谢谢！
    关键词不能为空
版权说明

本文地址：http://kirinbk.cn/post-2083.html
免责声明：本站文章仅用于科普及教育用途,远离犯罪！

什么是DevOps和NoOps
« 上一篇
Java8 reduce操作详解
下一篇 »

相关推荐

发表评论

呲牙 jie 开心 doge 坏笑 爱心 傲慢 抱拳 闭嘴 擦汗 发呆 鼓掌 害羞 憨笑 抠鼻 耍酷 泪奔 冷汗 流汗 难过 撇嘴 亲亲 色 喷血 调皮 偷笑 托腮 委屈 我最美 无奈 小纠结 笑哭 斜眼笑 阴险 疑问 晕

联系我们

在线咨询：点击这里给我发消息

QQ交流群：KirinBlog

工作日：8：00-23：00，节假日休息

扫码关注