【进阶】logback之 RollingFileAppender 的原理及避坑建议Applehope

野性酷女 2023-09-23 20:53 27阅读 0赞

### 一、cache vs buffer ###

在系统设计中通常会有 cache 及 buffer 的设计：

*  cache ：设备之间有速度差，高速设备访问低速设备会造成高速设备等待，导致使用率降低，为了减少低速设备对高速设备的影响，在两者之间加入 cache，通过加快访问速度，以提升高速设备的使用效率。
 *  buffer ：通俗来说就是化零为整，把少量多次变成多量少次；具体来说就是进行流量整形，把突发的大数量较小规模的 I/O 整理成平稳的小数量较大规模的 I/O，以减少响应次数

### 二、 FileAppender ###

#### 2.1 FileAppender 属于 buffer 级的方案 ####

*  FileAppender 内部有缓存 buffer，buffer 读写都加锁，从 buffer 写盘 与 log 写 buffer 会串行，产生 RT 变长的性能问题。

![format_png][]

#### 2.2 FileAppender 原理简析 ####

FileAppender 内部使用 BufferedOutputStream ， BufferedOutputStream 的 OutputStream 是 FileOutputStream； 通过 BufferedOutputStream 写文件的逻辑：

1.  调用 write 方法，因为缓存大小有限，所以能写缓存就写缓存；如果缓存容不下，就直接写入其内部的 OutputStream 中，即写文件。
    
    ![format_png 1][]
2.  如果希望缓存不满的情况下也能够立即写入到 OutputStream 中，那么久调用 flush 方法。

### 三、同步 RollingFileAppender 源码分析 ###

#### 3.1 继承关系 ####

RollingFileAppender 继承关系：RollingFileAppender -> FileAppender -> OutputStreamAppender -> UnsynchronizedAppenderBase，OutputStreamAppender 中的 append 方法调用了 subAppend 方法，subAppend 又调用了 writeOut 方法，writeOut 又调用了 LayoutWrappingEncoder 的 doEncode 方法，在 doEncode 方法中调用了 outputStream 的 write 方法，并且判断 immediateFlush 为 true 的话，则立即 flush

public class RollingFileAppender<E> extends FileAppender<E> { }
    public class FileAppender<E> extends OutputStreamAppender<E> { }
    public class OutputStreamAppender<E> extends UnsynchronizedAppenderBase<E> {
      @Override
      protected void append(E eventObject) {
        if (!isStarted()) {
          return;
        }
    
        subAppend(eventObject);
      }
      protected void subAppend(E event) {
        // 省略其他不重要的代码
          lock.lock();
          try {
            writeOut(event);
          } finally {
            lock.unlock();
          }
      }
      protected void writeOut(E event) throws IOException {
        // setLayout 方法中设置了 encoder = new LayoutWrappingEncoder<E>();
        this.encoder.doEncode(event);
      }
    }
    public class LayoutWrappingEncoder<E> extends EncoderBase<E> {
      public void doEncode(E event) throws IOException {
        String txt = layout.doLayout(event);
        outputStream.write(convertToBytes(txt));
        if (immediateFlush)
          outputStream.flush();
      }
    }
    复制代码

再看代码追查一下 outputStream 的真实类型，FileAppender 是直接将日志输出到文件中，初始化了一个 ResilientFileOutputStream，其内部使用的是带缓冲的 BufferedOutputStream，然后调用超类的 setOutputStream 方法设置输出流，最终调用 encoder.init 方法将输出流对象赋值给了 outputStream。

public class FileAppender<E> extends OutputStreamAppender<E> {
        public void openFile(String file_name) throws IOException {
            LogbackLock var2 = this.lock;
            synchronized(this.lock) {
                File file = new File(file_name);
                // 如果日志文件所在的文件夹还不存在，就创建之
                if(FileUtil.isParentDirectoryCreationRequired(file)) {
                    boolean resilientFos = FileUtil.createMissingParentDirectories(file);
                    if(!resilientFos) {
                        this.addError("Failed to create parent directories for [" + file.getAbsolutePath() + "]");
                    }
                }
    
                ResilientFileOutputStream resilientFos1 = new ResilientFileOutputStream(file, this.append);
                resilientFos1.setContext(this.context);
                // 调用父类的 setOutputStream 方法
                this.setOutputStream(resilientFos1);
            }
        }
    }
    
    public class ResilientFileOutputStream extends ResilientOutputStreamBase {
        private File file;
        private FileOutputStream fos;
    
        public ResilientFileOutputStream(File file, boolean append) throws FileNotFoundException {
            this.file = file;
            this.fos = new FileOutputStream(file, append);
            // OutputStream os 在超类 ResilientOutputStreamBase 里
            this.os = new BufferedOutputStream(this.fos);
            this.presumedClean = true;
        }
    }
    
    public class OutputStreamAppender<E> extends UnsynchronizedAppenderBase<E> {
      private OutputStream outputStream;
      protected Encoder<E> encoder;
      public void setOutputStream(OutputStream outputStream) {
        lock.lock();
        try {
          // close any previously opened output stream
          closeOutputStream();
          encoderInit();
        } finally {
          lock.unlock();
        }
      }
      // 将 outputStream 送入 encoder
      void encoderInit() {
        encoder.init(outputStream);
      }
    }
    复制代码

### 四、使用需注意 ###

1.  自动刷盘
    
     *  缓存满了（空间不足）直接写入 OutputStream
     *  缓存不满不刷盘，则会出现丢日志的现象
2.  手动刷盘
    
     *  手动定时调用 flush 方法，强制将缓存数据写入 OutputStream 中
     *  若定时手动写，要留意进程退出前 是否有日志尚在 buffer 中未落盘。即丢日志的现象
3.  分阶段控制刷盘策略
    
     *  启动阶段要保障每一个日志都要刷盘，否则启动报错日志，若在 buffer 未落盘将导致无有效信息来引导排错
     *  运行阶段则可按照满刷盘+定时刷盘的方式来执行

### 五、最后说一句 ###

我是石页兄，如果这篇文章对您有帮助，或者有所启发的话，欢迎关注笔者的微信公众号【 架构染色 】进行交流和学习。您的支持是我坚持写作最大的动力。

原文链接：https://juejin.cn/post/7183152831677857847  
来源：稀土掘金

[format_png]: https://img-blog.csdnimg.cn/img_convert/00290462819c531d20e952b1e0bc6d17.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/7237a23e53ff0c2a9cec8b13dc9697cb.webp?x-oss-process=image/format,png