从入门到精通：彻底理解并实践Logback日志框架——原理解析与实战教程之二（轻松易懂版）

Logback日志框架

"Logback"是一个开源的日志组件，它的设计者也是"Log4j"的作者。相比于"Log4j"，它拥有更好的特性，因此成为了一个取代"Log4j"的优秀的日志框架。如果您正寻找一款优秀的日志组件，那么"Logback"将是一个不错的选择。

slf4j和logback的关系

用SLF4J来写记录日志的代码，而不能用logback去写日志。如果需要切换其他的日志框架比如log4j，只需要更改依赖就好了。

slf4j

slf4j组件提供了一个统一的日志对象访问接口，而log4j和logback等日志组件实现了该接口中的标准规定。下面是使用该组件的详细实现步骤：

1. 使用LoggerFactory.getLogger(App.class)方法获取一个Logger对象。

2. 调用getILoggerFactory()方法获取具体的LoggerFactory实现类，如Log4j。

3. LoggerFactory的bind()方法会调用findPossibleStaticLoggerBinderPathSet()方法来查找Slf4j是否找到了具体的日志组件。如果找到了，则会返回具体的对象，可以进行日志的记录。如果没有找到，则会提示没有找到相关的类。

4. 获取到具体对象后（例如Log4j LoggerFactory），调用getLogger()方法获取一个特定的日志对象，即可以输出日志。

Slf4j的核心代码

通过LoggerFactory去拿slf4j提供的一个Logger接口的具体实现。

getLogger方法

slf4j中获取Logger实例的一个重载方法。它接受一个由Class对象描述的类，返回一个对应的Logger实例。

Logger logger = LoggerFactory.getLogger(Object.class);   

public static Logger getLogger(Class clazz) {
    Logger logger = getLogger(clazz.getName());
    if (DETECT_LOGGER_NAME_MISMATCH) {
        Class autoComputedCallingClass = Util.getCallingClass();
        if (autoComputedCallingClass != null && nonMatchingClasses(clazz, autoComputedCallingClass)) {
            Util.report(String.format("Detected logger name mismatch. Given name: \"%s\"; computed name: \"%s\".", logger.getName(),
                            autoComputedCallingClass.getName()));
            Util.report("See " + LOGGER_NAME_MISMATCH_URL + " for an explanation");
        }
    }
    return logger;
}

函数中的第一行代码调用了getLogger(String name)方法，该方法是一个重载方法，接受一个字符串作为参数代表Logger实例的名称。实际上，getLogger(Class clazz)方法中本质上完成的任务和getLogger(String name)方法相同：都是用来返回一个与特定名称相关联的Logger实例。

接下来，函数会检测应用程序中，是否存在Logger实例名称与类名称不匹配的情况。如果有这种情况，函数会打印出来一些警告信息，并提供一个网站地址以查看更多的解释。这种情况有时会出现，通常是因为Logger实例没有被正确地命名导致。

最后，函数返回本次调用得到的Logger实例。

LoggerFactory的bind()方法

bind方法用来实现slf4j的静态绑定的。它的主要功能是实现对slf4j实现的绑定和初始化。总之，这个函数的主要目的是在应用程序启动时完成slf4j的静态绑定，保证日志记录功能能够正常工作。

private final static void bind() {
    try {
        SetstaticLoggerBinderPathSet = null;
        if (!isAndroid()) {
            staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
            reportMultipleBindingAmbiguity(staticLoggerBinderPathSet);
        }
        // the next line does the binding
        StaticLoggerBinder.getSingleton();
        INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION;
        reportActualBinding(staticLoggerBinderPathSet);
        fixSubstituteLoggers();
        replayEvents();
        // release all resources in SUBST_FACTORY
        SUBST_FACTORY.clear();
    } catch (NoClassDefFoundError ncde) {
        String msg = ncde.getMessage();
        if (messageContainsOrgSlf4jImplStaticLoggerBinder(msg)) {
            INITIALIZATION_STATE = NOP_FALLBACK_INITIALIZATION;
            Util.report("Failed to load class \"org.slf4j.impl.StaticLoggerBinder\".");
            Util.report("Defaulting to no-operation (NOP) logger implementation");
            Util.report("See " + NO_STATICLOGGERBINDER_URL + " for further details.");
        } else {
            failedBinding(ncde);
            throw ncde;
        }
    } catch (java.lang.NoSuchMethodError nsme) {
        String msg = nsme.getMessage();
        if (msg != null && msg.contains("org.slf4j.impl.StaticLoggerBinder.getSingleton()")) {
            INITIALIZATION_STATE = FAILED_INITIALIZATION;
            Util.report("slf4j-api 1.6.x (or later) is incompatible with this binding.");
            Util.report("Your binding is version 1.5.5 or earlier.");
            Util.report("Upgrade your binding to version 1.6.x.");
        }
        throw nsme;
    } catch (Exception e) {
        failedBinding(e);
        throw new IllegalStateException("Unexpected initialization failure", e);
    }
}

函数中核心的部分是StaticLoggerBinder.getSingleton()，它调用了org.slf4j.impl.StaticLoggerBinder这个类的getSingleton()方法，这个方法返回了一个org.slf4j.ILoggerFactory。这个ILoggerFactory可以被用来构造slf4j的Logger实例。

在函数的前面，我们可以看到一系列的步骤来查找可能存在的StaticLoggerBinder路径集合。之后，我们会检查这些路径，以确保只有一个StaticLoggerBinder实现被绑定到类路径上。如果有多个静态绑定的文件存在，就会报告一个MultipleBindingAmbiguity的异常。

在绑定完成后，函数会执行一些资源清理和事件重放的操作，以确保程序的正确性。如果在初始化过程中出现了任何异常，函数会记录相关信息，并抛出一个运行时异常以通知调用者。

static SetfindPossibleStaticLoggerBinderPathSet() {
    // use Set instead of list in order to deal with bug #138
    // LinkedHashSet appropriate here because it preserves insertion order
    // during iteration
    SetstaticLoggerBinderPathSet = new LinkedHashSet();
    try {
        ClassLoader loggerFactoryClassLoader = LoggerFactory.class.getClassLoader();
        Enumerationpaths;
        if (loggerFactoryClassLoader == null) {
            paths = ClassLoader.getSystemResources(STATIC_LOGGER_BINDER_PATH);
        } else {
            paths = loggerFactoryClassLoader.getResources(STATIC_LOGGER_BINDER_PATH);
        }
        while (paths.hasMoreElements()) {
            URL path = paths.nextElement();
            staticLoggerBinderPathSet.add(path);
        }
    } catch (IOException ioe) {
        Util.report("Error getting resources from path", ioe);
    }
    return staticLoggerBinderPathSet;
}

在调用getLogger()方法时，实际上会在classpath下查找STATIC_LOGGER_BINDER_PATH这个值。对于所有的slf4j实现，它们的jar包路径下都一定会存在"org/slf4j/impl/StaticLoggerBinder.class"，这个路径是非常重要的，它指明了找到slf4j实现所必需的文件。

因此，可以说这个地方是整个slf4j的核心。对于任何使用slf4j的开发人员来说，都需要了解和掌握这个类路径，并确保它在项目的classpath下存在。只有这样，才能够正确地访问和使用所有的slf4j实现。

slf4j logback配置

pom.xml添加logback依赖。

<dependency>
	<groupId>org.slf4j</groupId>
	<artifactId>slf4j-api</artifactId>
	<version>1.7.25</version>
</dependency>
<dependency>
	<groupId>ch.qos.logback</groupId>
	<artifactId>logback-classic</artifactId>
	<version>1.2.3</version>
</dependency>
<dependency>
	<groupId>ch.qos.logback</groupId>
	<artifactId>logback-core</artifactId>
	<version>1.2.3</version>
</dependency>

log4j和logback的关系

log4j和logback就是两个受欢迎的日志框架，同时logback同样是由log4j的作者设计完成的，拥有更好的特性，用来取代log4j的一个日志框架。而slf4j是java的一个日志门面，实现了日志框架一些通用的api，log4j和logback是具体的日志框架,他们可以单独的使用，也可以绑定slf4j一起使用。

Logback的配置文件

配置文件读取顺序

logback通常使用logback.xml进行配置，在启动时，logback会按照以下顺序加载配置文件：

1. 如果程序启动时指定了logback.configurationFile属性，则使用该属性指定的配置文件。例如：java -Dlogback.configurationFile=/path/to/mylogback.xml Test，这样执行Test类的时候就会加载/path/to/mylogback.xml配置。

2. 查找classpath下的logback.groovy文件。

3. 查找classpath下的logback-test.xml文件。

4. 查找classpath下的logback.xml文件。

5. 如果所有的文件都不存在，则使用BasicConfigurator自动配置，将日志记录输出到控制台。

Logback配置详解

配置logback-spring.xml

resources下配置的spring-logback.xml

<?xml version="1.0" encoding="UTF-8" ?>
<configuration scan="true" scanPeriod="60 seconds" debug="false">

    <!-- 动态日志级别 -->
    <jmxConfigurator/>

    <!-- 定义日志文件 输出位置 -->
    <property name="log.home_dir" value="/usr/local/springboot/log"/>
    <property name="log.app_name" value="http-demo"/>
    <!-- 日志最大的历史 30天 -->
    <property name="log.maxHistory" value="30"/>
    <property name="log.level" value="debug"/>
    <property name="log.maxSize" value="5MB" />

    <!-- ConsoleAppender 控制台输出日志 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>
                <!-- 设置日志输出格式 -->
                %d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] [%thread] %logger - %msg%n
            </pattern>
        </encoder>
    </appender>

    <!-- ERROR级别日志 -->
    <!-- 滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件 RollingFileAppender -->
    <appender name="ERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 过滤器，只记录WARN级别的日志 -->
        <!-- 果日志级别等于配置级别，过滤器会根据onMath 和 onMismatch接收或拒绝日志。 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 设置过滤级别 -->
            <level>ERROR</level>
            <!-- 用于配置符合过滤条件的操作 -->
            <onMatch>ACCEPT</onMatch>
            <!-- 用于配置不符合过滤条件的操作 -->
            <onMismatch>DENY</onMismatch>
        </filter>
        <!-- 最常用的滚动策略，它根据时间来制定滚动策略.既负责滚动也负责触发滚动 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!--日志输出位置 可相对、和绝对路径 -->
            <fileNamePattern>
                ${log.home_dir}/error/%d{yyyy-MM-dd}/${log.app_name}-%i.log
            </fileNamePattern>
            <!-- 可选节点，控制保留的归档文件的最大数量，超出数量就删除旧文件,假设设置每个月滚动，且<maxHistory>是6，
            则只保存最近6个月的文件，删除之前的旧文件。注意，删除旧文件是，那些为了归档而创建的目录也会被删除 -->
            <maxHistory>${log.maxHistory}</maxHistory>
            <!--日志文件最大的大小-->
            <MaxFileSize>${log.maxSize}</MaxFileSize>
        </rollingPolicy>
        <encoder>
            <pattern>
                <!-- 设置日志输出格式 -->
                %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
            </pattern>
        </encoder>
    </appender>

    <!-- INFO级别日志 appender -->
    <appender name="INFO" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>INFO</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${log.home_dir}/info/%d{yyyy-MM-dd}/${log.app_name}-%i.log</fileNamePattern>
            <maxHistory>${log.maxHistory}</maxHistory>
            <MaxFileSize>${log.maxSize}</MaxFileSize>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] %logger - %msg%n</pattern>
        </encoder>
    </appender>


    <!-- DEBUG级别日志 appender -->
    <appender name="DEBUG" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>DEBUG</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${log.home_dir}/debug/%d{yyyy-MM-dd}/${log.app_name}-%i.log</fileNamePattern>
            <maxHistory>${log.maxHistory}</maxHistory>
            <MaxFileSize>${log.maxSize}</MaxFileSize>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] %logger - %msg%n</pattern>
        </encoder>
    </appender>

    <!--设置一个向上传递的appender,所有级别的日志都会输出-->
    <appender name="app" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${log.home_dir}/app/%d{yyyy-MM-dd}/${log.app_name}-%i.log</fileNamePattern>
            <maxHistory>${log.maxHistory}</maxHistory>
            <MaxFileSize>${log.maxSize}</MaxFileSize>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] %logger - %msg%n</pattern>
        </encoder>
    </appender>

    <!--org.springframework.web包下的类的日志输出-->
    <logger name="org.springframework.web" additivity="false" level="WARN">
        <appender-ref ref="WARN"/>
    </logger>
    <!--com.zgd包下的类的日志输出-->
    <logger name="com.zgd" additivity="false" level="DEBUG" >
        <appender-ref ref="app" />
        <appender-ref ref="ERROR" />
        <!--打印控制台-->
        <appender-ref ref="CONSOLE" />
    </logger>

    <!-- root级别   DEBUG -->
    <root>
        <!-- 打印debug级别日志及以上级别日志 -->
        <level value="${log.level}"/>
        <!-- 控制台输出 -->
        <appender-ref ref="CONSOLE"/>
        <!-- 不管什么包下的日志都输出文件 -->
        <!--<appender-ref ref="ERROR"/>-->
    </root>
</configuration>

1. 级别：从高到低 OFF、FATAL、ERROR、WARN、INFO、DEBUG、TRACE、ALL。
2. 日志输出规则：根据当前ROOT级别，日志输出时，只有当前级别高于ROOT级别时才会输出。
3. 每个配置的filter用来过滤掉输出文件里面低级别的日志信息。
4. 当scan属性设置为true时，配置文件如果发生改变，将会被重新加载。默认值为true。
5. scanPeriod属性用于设置监测配置文件是否有修改的时间间隔。如果没有给出时间单位，将默认单位为毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。
6. debug属性用于打印出logback内部日志信息，实时查看logback运行状态。默认值为false。

slf4j log4j logback的联系

log4j是一个流行的日志框架，而logback则是由log4j的作者设计的一个日志框架，它有更多的特性，被认为是log4j的替代品。slf4j是Java的一个日志门面，提供了一些通用的API，可以用于实现不同的具体日志框架，log4j和logback都可以独立使用，也可以与slf4j配合使用。

1. 如果应用只导入“slf4j-api.jar日志门面”，没有导入slf4j实现，则所有记录日志的方法都无效，不会进行日志记录，这称为“SLF4J unbound”。

2. 如果导入了“slf4j-api.jar日志门面”及logback-classic日志实现的jar包，则调用SLF4J后，底层会使用logback来实现记录日志，这称为“SLF4J bound to logback-classic”。

3. 如果导入了“slf4j-api.jar日志门面”及log4j日志实现的jar包，并在中间导入一个适配包“slf4j-log412.jar”，则应用调用SLF4J记录日志时，会先使用适配包，最终使用log4j实现进行记录日志，这称为“SLF4J bound to log4j”。

使用SLF4J无法进行完整的日志记录操作，SLF4J只是一个外观。因此，通常情况下，与log4j或logback一起使用，以实现最大兼容性，并便于切换日志系统。