logger(二)logback简介及其实现原理

男娘i 2023-08-17 15:42 104阅读 0赞

### 一、logback简介 ###

logback是log4j创始人写的，性能比log4j要好，目前主要分为3个模块

1.  logback-core:核心代码模块
2.  logback-classic:log4j的一个改良版本，同时实现了`slf4j`的接口，这样你如果之后要切换其他日志组件也是一件很容易的事
3.  logback-access:访问模块与Servlet容器集成提供通过Http来访问日志的功能

### 二、logback.xml配置 ###

<?xml version="1.0" encoding="UTF-8"?>
    
    
    <configuration debug="true" scan="true" scanPeriod="1 seconds">
        <contextName>logback</contextName>
        
        <property name="app.name" value="logback_test"/>
        
        <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
            
            
            <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
                <level>DEBUG</level>
            </filter>
            
            
            <encoder>
                <pattern>%d [%thread] %-5level %logger{36} [%file : %line] - %msg%n</pattern>
            </encoder>
        </appender>
    
        <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">
            
            
            
            <file>${scheduler.manager.server.home}/logs/${app.name}.log</file>
            
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                
                <fileNamePattern>${scheduler.manager.server.home}/logs/${app.name}.%d{yyyy-MM-dd.HH}.log.gz
                </fileNamePattern>
                
                <maxHistory>60</maxHistory>
                
                <totalSizeCap>20GB</totalSizeCap>
            </rollingPolicy>
            <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
                
                <maxFileSize>100MB</maxFileSize>
            </triggeringPolicy>
            
            <encoder>
                <pattern>%d [%thread] %-5level %logger{36} [%file : %line] - %msg%n</pattern>
            </encoder>
        </appender>
    
        
        <root level="info">
            
            <appender-ref ref="stdout"/>
            <appender-ref ref="file"/>
        </root>
        
        
        <logger name="com.example.logback" level="warn"/>
    
        
        
        
        
        <logger name="mytest" level="info" additivity="false">
            <appender-ref ref="stdout"/>
        </logger>
        
        
        
        <logger name="mytest2" level="info" additivity="false"/>
    </configuration>

### 三、实现原理 ###

#### 1、获取LoggerFactory ####

slf4j委托具体实现框架的StaticLoggerBinder来返回一个ILoggerFactory，从而对接到具体实现框架上，我们看下这个类(省略了部分代码)

public class StaticLoggerBinder implements LoggerFactoryBinder {
    
      private static StaticLoggerBinder SINGLETON = new StaticLoggerBinder();static {
        SINGLETON.init();
      }public static StaticLoggerBinder getSingleton() {
        return SINGLETON;
      }/**
       * Package access for testing purposes.
       */
      void init() {
        try {
          try {
            new ContextInitializer(defaultLoggerContext).autoConfig();
          } catch (JoranException je) {
            Util.report("Failed to auto configure default logger context", je);
          }
          // logback-292
          if(!StatusUtil.contextHasStatusListener(defaultLoggerContext)) {
            StatusPrinter.printInCaseOfErrorsOrWarnings(defaultLoggerContext);
          }
          contextSelectorBinder.init(defaultLoggerContext, KEY);
          initialized = true;
        } catch (Throwable t) {
          // we should never get here
          Util.report("Failed to instantiate [" + LoggerContext.class.getName()
              + "]", t);
        }
      }
      public ILoggerFactory getLoggerFactory() {
        if (!initialized) {
          return defaultLoggerContext;
        }
    
        if (contextSelectorBinder.getContextSelector() == null) {
          throw new IllegalStateException(
              "contextSelector cannot be null. See also " + NULL_CS_URL);
        }
        return contextSelectorBinder.getContextSelector().getLoggerContext();
      }
    }

可以看到

*  1、通过getSingleton()获取该类的单例
 *  2、static块来保证初始化调用init()方法
 *  3、在init方法中，委托ContextInitializer类对LoggerContext进行初始化。这里如果找到了任一配置文件，就会根据配置文件去初始化LoggerContext，如果没找到，会使用默认配置。
 *  4、然后初始化ContextSelectorStaticBinder，在这个类内部new一个DefaultContextSelector，并把第一步中配置完毕的LoggerContext传给DefaultContextSelector
 *  5、调用getLoggerFactory()方法，直接返回3中配置的LoggerContext，或者委托DefaultContextSelector类返回LoggerContext

这里可以看出所有的配置均保存在LoggerContext这个类中，只要获取到了该类，就能得到log的所有配置，我们的logger就保存在该类的Map<String, Logger> loggerCache中，key为logger的name.

#### 2、获取logger ####

public final Logger getLogger(final String name) {
    
            if (name == null) {
                throw new IllegalArgumentException("name argument cannot be null");
            }
    
            // 如果请求的是ROOT Logger，那么就直接返回root
            if (Logger.ROOT_LOGGER_NAME.equalsIgnoreCase(name)) {
                return root;
            }
    
            int i = 0;
            Logger logger = root;
    
            // 请求的Logger是否已经创建过了，如果已经创建过，就直接从loggerCache中返回
            Logger childLogger = (Logger) loggerCache.get(name);
            // if we have the child, then let us return it without wasting time
            if (childLogger != null) {
                return childLogger;
            }
    
            // if the desired logger does not exist, them create all the loggers
            // in between as well (if they don't already exist)
            String childName;
            while (true) {
                int h = LoggerNameUtil.getSeparatorIndexOf(name, i);
                if (h == -1) {
                    childName = name;
                } else {
                    childName = name.substring(0, h);
                }
                i = h + 1;
                synchronized (logger) {
                    childLogger = logger.getChildByName(childName);
                    if (childLogger == null) {
                        //创建Logger实例
                        childLogger = logger.createChildByName(childName);
                        loggerCache.put(childName, childLogger);
                        incSize();
                    }
                }
                logger = childLogger;
                if (h == -1) {
                    return childLogger;
                }
            }
        }

3、logger.info()记录日志

slf4j定义了Logger接口记录日志的方法是info()、warn()、debug()等，这些方法只是入口，logback是这样实现这些方法的

public void info(String msg) {  
        filterAndLog_0_Or3Plus(FQCN, null, Level.INFO, msg, null, null);  
      }

当客户端代码调用Logger.info()时，实际上会进入filterAndLog\_0\_Or3Plus方法，Logger类中还有很多名字很相似的方法，比如filterAndLog\_1、filterAndLog\_2。

/** 
       * The next methods are not merged into one because of the time we gain by not 
       * creating a new Object[] with the params. This reduces the cost of not 
       * logging by about 20 nanoseconds. 
       */  
      
      private final void filterAndLog_0_Or3Plus(final String localFQCN,  
          final Marker marker, final Level level, final String msg,  
          final Object[] params, final Throwable t) {  
      
        final FilterReply decision = loggerContext.getTurboFilterChainDecision_0_3OrMore(marker, this, level, msg,  params, t);  
        if (decision == FilterReply.NEUTRAL) {  
          if (effectiveLevelInt > level.levelInt) {  
            return;  
          }  
        } else if (decision == FilterReply.DENY) {  
          return;  
        }  
      
        buildLoggingEventAndAppend(localFQCN, marker, level, msg, params, t);  
      }

该方法首先要请求TurboFilter来判断是否允许记录这次日志信息。TurboFilter是快速筛选的组件，筛选发生在LoggingEvent创建之前，这种设计也是为了提高性能   
  
如果经过过滤，确定要记录这条日志信息，则进入buildLoggingEventAndAppend方法

private void buildLoggingEventAndAppend(final String localFQCN,  
          final Marker marker, final Level level, final String msg,  
          final Object[] params, final Throwable t) {  
        LoggingEvent le = new LoggingEvent(localFQCN, this, level, msg, t, params);  
        le.setMarker(marker);  
        callAppenders(le);  
      }

在这个方法里，首先创建了LoggingEvent对象，然后调用callAppenders()方法，要求该Logger关联的所有Appenders来记录日志   
  
LoggingEvent对象是承载了日志信息的类，最后输出的日志信息，就来源于这个事件对象

/** 
       * Invoke all the appenders of this logger. 
       *  
       * @param event 
       *          The event to log 
       */  
      public void callAppenders(ILoggingEvent event) {  
        int writes = 0;  
        for (Logger l = this; l != null; l = l.parent) {  
          writes += l.appendLoopOnAppenders(event);  
          if (!l.additive) {  
            break;  
          }  
        }  
        // No appenders in hierarchy  
        if (writes == 0) {  
          loggerContext.noAppenderDefinedWarning(this);  
        }  
      }

经过前面的Filter过滤、日志级别匹配、创建LoggerEvent对象，终于进入了记录日志的方法。该方法会调用此Logger关联的所有Appender，而且还会调用所有父Logger关联的Appender，直到遇到父Logger的additive属性设置为false为止，这也是为什么如果子Logger和父Logger都关联了同样的Appender，则日志信息会重复记录的原因

private int appendLoopOnAppenders(ILoggingEvent event) {  
        if (aai != null) {  
          return aai.appendLoopOnAppenders(event);  
        } else {  
          return 0;  
        }  
      }

实际上调用的AppenderAttachableImpl的appendLoopOnAppenders()方法

/** 
       * Call the <code>doAppend</code> method on all attached appenders. 
       */  
      public int appendLoopOnAppenders(E e) {  
        int size = 0;  
        r.lock();  
        try {  
          for (Appender<E> appender : appenderList) {  
            appender.doAppend(e);  
            size++;  
          }  
        } finally {  
          r.unlock();  
        }  
        return size;  
      }

到这里，为了记录一条日志信息，长长的调用链终于告一段落了，通过调用Appender的doAppend(LoggingEvent e)方法，委托Appender来最终记录日志

UnsynchronizedAppenderBase里面的doAppend()方法，它主要是记录了Status状态，然后检查Appender上的Filter是否满足过滤条件，最后再调用实现子类的appender()方法。很眼熟是吗，这里用到了一个设计模式——模板方法

public void doAppend(E eventObject) {  
        // WARNING: The guard check MUST be the first statement in the  
        // doAppend() method.  
            
        // prevent re-entry.  
        if (Boolean.TRUE.equals(guard.get())) {  
          return;  
        }  
      
        try {  
          guard.set(Boolean.TRUE);  
      
          if (!this.started) {  
            if (statusRepeatCount++ < ALLOWED_REPEATS) {  
              addStatus(new WarnStatus(  
                  "Attempted to append to non started appender [" + name + "].",  
                  this));  
            }  
            return;  
          }  
      
          if (getFilterChainDecision(eventObject) == FilterReply.DENY) {  
            return;  
          }  
      
          // ok, we now invoke derived class' implementation of append  
          this.append(eventObject);  
      
        } catch (Exception e) {  
          if (exceptionCount++ < ALLOWED_REPEATS) {  
            addError("Appender [" + name + "] failed to append.", e);  
          }  
        } finally {  
          guard.set(Boolean.FALSE);  
        }  
      }  
      
      abstract protected void append(E eventObject);

上面的代码非常简单，就不用说了，我们就直接看看实现类的append()方法是怎么实现的，这里我们选择OutputStreamAppender实现类

@Override  
      protected void append(E eventObject) {  
        if (!isStarted()) {  
          return;  
        }  
      
        subAppend(eventObject);  
      }

首先检查一下这个Appender是否已经启动，如果没启动就直接返回，如果已经启动，则又进入一个subAppend()方法

RollingFileAppender覆盖了subAppend()方法，实现了翻滚策略

@Override
        protected void subAppend(E event) {
            // The roll-over check must precede actual writing. This is the
            // only correct behavior for time driven triggers.
    
            // We need to synchronize on triggeringPolicy so that only one rollover
            // occurs at a time
            synchronized (triggeringPolicy) {
                if (triggeringPolicy.isTriggeringEvent(currentlyActiveFile, event)) {
                    rollover();
                }
            }
    
            super.subAppend(event);
        }

进入super.subAppend(event);

protected void subAppend(E event) {
            if (!isStarted()) {
                return;
            }
            try {
                // this step avoids LBCLASSIC-139
                if (event instanceof DeferredProcessingAware) {
                    ((DeferredProcessingAware) event).prepareForDeferredProcessing();
                }
                // the synchronization prevents the OutputStream from being closed while we
                // are writing. It also prevents multiple threads from entering the same
                // converter. Converters assume that they are in a synchronized block.
                // lock.lock();
    
                byte[] byteArray = this.encoder.encode(event);
                writeBytes(byteArray);
    
            } catch (IOException ioe) {
                // as soon as an exception occurs, move to non-started state
                // and add a single ErrorStatus to the SM.
                this.started = false;
                addStatus(new ErrorStatus("IO failure in appender", this, ioe));
            }
        }

通过this.encoder.encode(event)方法格式化需要记录的日志，然后通过writeBytes(byteArray)写入日志。

### 四、通过代码动态生成logger对象 ###

public class LoggerHolder {
    
        public static Logger getLogger(String name) {
            LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
            //如果未创建该logger
            if (loggerContext.exists(name) == null) {
                return buildLogger(name);
            }
            //如果已经创建，则返回
            return loggerContext.getLogger(name);
        }
    
        private static Logger buildLogger(String name) {
    
            LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
            Logger logger = loggerContext.getLogger(name);
            //配置rollingFileAppender
            RollingFileAppender rollingFileAppender = new RollingFileAppender();
            rollingFileAppender.setName(name);
            //配置rollingPolicy
            TimeBasedRollingPolicy rollingPolicy = new TimeBasedRollingPolicy();
            rollingPolicy.setFileNamePattern("/data/pjf/" + name + "/" + name + ".%d{yyyyMMdd}.log");
            rollingFileAppender.setRollingPolicy(rollingPolicy);
            //配置encoder
            PatternLayoutEncoder encoder = new PatternLayoutEncoder();
            encoder.setCharset(UTF_8);
            encoder.setPattern("%msg%n");
            rollingFileAppender.setEncoder(encoder);
            //配置logger
            logger.addAppender(rollingFileAppender);
            logger.setAdditive(false);
            logger.setLevel(Level.INFO);
            return logger;
        }
    }

具体参考：写的很详细，

##### [读logback源码系列文章（一）——对接slf4j][logback_slf4j] #####

##### [读logback源码系列文章（二）——提供ILoggerFactory][logback_ILoggerFactory] #####

##### [读logback源码系列文章（三）——创建Logger][logback_Logger] #####

##### [读logback源码系列文章（四）——记录日志][logback] #####

##### [读logback源码系列文章（五）——Appender][logback_Appender] #####

##### [读logback源码系列文章（六）——ContextInitializer][logback_ContextInitializer] #####

##### [读logback源码系列文章（七）——配置的实际工作类Action][logback_Action] #####

##### [读logback源码系列文章（八）——记录日志的实际工作类Encoder][logback_Encoder] #####

转载于:https://www.cnblogs.com/pjfmeng/p/11274436.html

[logback_slf4j]: https://kyfxbl.iteye.com/blog/1160028
[logback_ILoggerFactory]: https://kyfxbl.iteye.com/blog/1167959
[logback_Logger]: https://kyfxbl.iteye.com/blog/1168004
[logback]: https://kyfxbl.iteye.com/blog/1170283
[logback_Appender]: https://kyfxbl.iteye.com/blog/1173788
[logback_ContextInitializer]: https://kyfxbl.iteye.com/blog/1188099
[logback_Action]: https://kyfxbl.iteye.com/blog/1190128
[logback_Encoder]: https://kyfxbl.iteye.com/blog/1198760