手把手教你從零設計一個日誌框架

時間 2021-01-02

標籤 java git github 數據庫緩存 app 框架 ide svg 性能欄目 Java 简体版

原文原文鏈接

Java裏的各類日誌框架，相信你們都不陌生。Log4j/Log4j2/Logback/jboss logging等等，其實這些日誌框架核心結構沒什麼區別，只是細節實現上和其性能上有所不一樣。本文帶你從零開始，一步一步的設計一個日誌框架java

輸出組件 - Appender

提到日誌框架，最容易想到的核心功能，那就是輸出日誌了。輸出的方式能夠有不少：標準輸出/控制檯（Standard Output/Console）、文件（File）、郵件（Email）、甚至是消息隊列（MQ）和數據庫。git

如今將輸出功能抽象成一個組件「輸出器」 - Appender，這個Appender組件的核心功能就是輸出，下面是Appender的實現代碼：github

public interface Appender {
    void append(String body);
}

不一樣的輸出方式，只須要實現Appender接口作不一樣的實現便可，好比ConsoleAppender - 輸出至控制檯數據庫

public class ConsoleAppender implements Appender {
    private OutputStream out = System.out;
    private OutputStream out_err = System.err;

    @Override
    public void append(LoggingEvent event) {
        try {
            out.write(event.toString().getBytes(encoding));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

輸出內容 - LoggingEvent

有了輸出方式的組件以後，如今須要考慮輸出內容的問題。一行日誌的核心內容至少應該包含如下幾個信息：緩存

日誌時間戳
線程信息
日誌名稱（通常是全類名）
日誌級別
日誌主體（須要輸出的內容，好比info（日誌主題））

爲了方便的管理輸出內容，如今須要建立一個輸出內容的類來封裝這些信息：app

public class LoggingEvent {
    public long timestamp;//日誌時間戳
    private int level;//日誌級別
    private Object message;//日誌主題
    private String threadName;//線程名稱
    private long threadId;//線程id
    private String loggerName;//日誌名稱
    
    //getter and setters...
    
    @Override
    public String toString() {
        return "LoggingEvent{" +
                "timestamp=" + timestamp +
                ", level=" + level +
                ", message=" + message +
                ", threadName='" + threadName + '\'' +
                ", threadId=" + threadId +
                ", loggerName='" + loggerName + '\'' +
                '}';
    }
}

對於每一第二天志打印，應該屬於一次輸出的「事件-Event」，因此這裏命名爲LoggingEvent框架

那如今有了LoggingEvent，那麼對於Appender來講，接收的輸出內容參數須要爲LoggingEvent了。如今再回去把Appender.append方法的入參修改爲LoggingEvent：ide

public interface Appender {
    void append(LoggingEvent event);
}

日誌級別設計 - Level

一個日誌框架，應該提供日誌級別的功能，程序在使用時能夠打印不一樣級別的日誌，還能夠根據日誌級別來調整那些日誌能夠顯示，通常日誌級別會定義爲如下幾種，級別從左到右排序，只有大於等於某級別的LoggingEvent纔會進行輸出svg

ERROR > WARN > INFO > DEBUG > TRACE

如今來建立一個日誌級別的枚舉，只有兩個屬性，一個級別名稱，一個級別數值（方便作比較）性能

public enum Level {
    ERROR(40000, "ERROR"), WARN(30000, "WARN"), INFO(20000, "INFO"), DEBUG(10000, "DEBUG"), TRACE(5000, "TRACE");

    private int levelInt;
    private String levelStr;

    Level(int i, String s) {
        levelInt = i;
        levelStr = s;
    }

    public static Level parse(String level) {
        return valueOf(level.toUpperCase());
    }

    public int toInt() {
        return levelInt;
    }

    public String toString() {
        return levelStr;
    }

    public boolean isGreaterOrEqual(Level level) {
        return levelInt>=level.toInt();
    }

}

日誌級別定義完成以後，再將LoggingEvent中的日誌級別替換爲這個Level枚舉

public class LoggingEvent {
    public long timestamp;//日誌時間戳
    private Level level;//替換後的日誌級別
    private Object message;//日誌主題
    private String threadName;//線程名稱
    private long threadId;//線程id
    private String loggerName;//日誌名稱
    
    //getter and setters...
}

如今基本的輸出方式和輸出內容都已經基本完成，下一步須要設計日誌打印的入口，畢竟有入口才能打印嘛

日誌打印入口 - Logger

如今來考慮日誌打印入口如何設計，做爲一個日誌打印的入口，須要包含如下核心功能：

提供error/warn/info/debug/trace幾個打印的方法
擁有一個name屬性，用於區分不一樣的logger
調用appender輸出日誌
擁有本身的專屬級別（好比自身級別爲INFO，那麼只有INFO/WARN/ERROR才能夠輸出）

先來簡單建立一個Logger接口，方便擴展

public interface Logger{
    void trace(String msg);

    void info(String msg);

    void debug(String msg);

    void warn(String msg);

    void error(String msg);

    String getName();
}

再建立一個默認的Logger實現類：

public class LogcLogger implements Logger{
    private String name;
    private Appender appender;
    private Level level = Level.TRACE;//當前Logger的級別，默認最低
    private int effectiveLevelInt;//冗餘級別字段，方便使用
    
    @Override
    public void trace(String msg) {
        filterAndLog(Level.TRACE,msg);
    }

    @Override
    public void info(String msg) {
        filterAndLog(Level.INFO,msg);
    }

    @Override
    public void debug(String msg) {
        filterAndLog(Level.DEBUG,msg);
    }

    @Override
    public void warn(String msg) {
        filterAndLog(Level.WARN,msg);
    }

    @Override
    public void error(String msg) {
        filterAndLog(Level.ERROR,msg);
    }
    
    /**
     * 過濾並輸出，全部的輸出方法都會調用此方法
     * @param level 日誌級別
     * @param msg 輸出內容
     */
    private void filterAndLog(Level level,String msg){
        LoggingEvent e = new LoggingEvent(level, msg,getName());
        //目標的日誌級別大於當前級別才能夠輸出
        if(level.toInt() >= effectiveLevelInt){
            appender.append(e);
        }
    }
    
    @Override
    public String getName() {
        return name;
    }
    
    //getters and setters...
}

好了，到如今爲止，如今已經完成了一個最最最基本的日誌模型，能夠建立Logger，輸出不一樣級別的日誌。不過顯然還不太夠，仍是缺乏一些核心功能

日誌層級 - Hierarchy

通常在使用日誌框架時，有一個很基本的需求：不一樣包名的日誌使用不一樣的輸出方式，或者不一樣包名下類的日誌使用不一樣的日誌級別，好比我想讓框架相關的DEBUG日誌輸出，便於調試，其餘默認用INFO級別。

並且在使用時並不但願每次建立Logger都引用一個Appender，這樣也太不友好了；最好是直接使用一個全局的Logger配置，同時還支持特殊配置的Logger，且這個配置須要讓程序中建立Logger時無感（好比LoggerFactory.getLogger(XXX.class)）

可上面現有的設計可沒法知足這個需求，須要稍加改造

如今設計一個層級結構，每個Logger擁有一個Parent Logger，在filterAndLog時優先使用本身的Appender，若是本身沒有Appender，那麼就向上調用父類的appnder，有點反向「雙親委派（parents delegate）」的意思

上圖中的Root Logger，就是全局默認的Logger，默認狀況下它是全部Logger（新建立的）的Parent Logger。因此在filterAndLog時，默認都會使用Root Logger的appender和level來進行輸出

如今將filterAndLog方法調整一下，增長向上調用的邏輯：

private LogcLogger parent;//先給增長一個parent屬性

private void filterAndLog(Level level,String msg){
    LoggingEvent e = new LoggingEvent(level, msg,getName());
    //循環向上查找可用的logger進行輸出
    for (LogcLogger l = this;l != null;l = l.parent){
        if(l.appender == null){
            continue;
        }
        if(level.toInt()>effectiveLevelInt){
            l.append(e);
        }
        break;
    }
}

好了，如今這個日誌層級的設計已經完成了，不過上面提到不一樣包名使用不一樣的logger配置，尚未作到，包名和logger如何實現對應呢？

其實很簡單，只須要爲每一個包名的配置單獨定義一個全局Logger，在解析包名配置時直接爲不一樣的包名

日誌上下文 - LoggerContext

考慮到有一些全局的Logger，和Root Logger須要被各類Logger引用，因此得設計一個Logger容器，用來存儲這些Logger

/**
 * 一個全局的上下文對象
 */
public class LoggerContext {

    /**
     * 根logger
     */
    private Logger root;

    /**
     * logger緩存，存放解析配置文件後生成的logger對象，以及經過程序手動建立的logger對象
     */
    private Map<String,Logger> loggerCache = new HashMap<>();

    public void addLogger(String name,Logger logger){
        loggerCache.put(name,logger);
    }

    public void addLogger(Logger logger){
        loggerCache.put(logger.getName(),logger);
    }
    //getters and setters...
}

有了存放Logger對象們的容器，下一步能夠考慮建立Logger了

日誌建立 - LoggerFactory

爲了方便的構建Logger的層級結構，每次new可不太友好，如今建立一個LoggerFactory接口

public interface ILoggerFactory {
    //經過class獲取/建立logger
    Logger getLogger(Class<?> clazz);
    //經過name獲取/建立logger
    Logger getLogger(String name);
    //經過name建立logger
    Logger newLogger(String name);
}

再來一個默認的實現類

public class StaticLoggerFactory implements ILoggerFactory {

    private LoggerContext loggerContext;//引用LoggerContext

    @Override
    public Logger getLogger(Class<?> clazz) {
        return getLogger(clazz.getName());
    }

    @Override
    public Logger getLogger(String name) {
        Logger logger = loggerContext.getLoggerCache().get(name);
        if(logger == null){
            logger = newLogger(name);
        }
        return logger;
    }
    
    /**
     * 建立Logger對象
     * 匹配logger name，拆分類名後和已建立（包括配置的）的Logger進行匹配
     * 好比當前name爲com.aaa.bbb.ccc.XXService，那麼name爲com/com.aaa/com.aaa.bbb/com.aaa.bbb.ccc
     * 的logger均可以做爲parent logger，不過這裏須要順序拆分，優先匹配「最近的」
     * 在這個例子裏就會優先匹配com.aaa.bbb.ccc這個logger，做爲本身的parent
     *
     * 若是沒有任何一個logger匹配，那麼就使用root logger做爲本身的parent
     *
     * @param name Logger name
     */
    @Override
    public Logger newLogger(String name) {
        LogcLogger logger = new LogcLogger();
        logger.setName(name);
        Logger parent = null;
        //拆分包名，向上查找parent logger
        for (int i = name.lastIndexOf("."); i >= 0; i = name.lastIndexOf(".",i-1)) {
            String parentName = name.substring(0,i);
            parent = loggerContext.getLoggerCache().get(parentName);
            if(parent != null){
                break;
            }
        }
        if(parent == null){
            parent = loggerContext.getRoot();
        }
        logger.setParent(parent);
        logger.setLoggerContext(loggerContext);
        return logger;
    }
}

再來一個靜態工廠類，方便使用：

public class LoggerFactory {

    private static ILoggerFactory loggerFactory = new StaticLoggerFactory();

    public static ILoggerFactory getLoggerFactory(){
        return loggerFactory;
    }

    public static Logger getLogger(Class<?> clazz){
        return getLoggerFactory().getLogger(clazz);
    }

    public static Logger getLogger(String name){
        return getLoggerFactory().getLogger(name);
    }
}

至此，全部基本組件已經完成，剩下的就是裝配了

配置文件設計

配置文件需至少須要有如下幾個配置功能：

配置Appender
配置Logger
配置Root Logger

下面是一份最小配置的示例

<configuration>

    <appender name="std_plain" class="cc.leevi.common.logc.appender.ConsoleAppender">
    </appender>

    <logger name="cc.leevi.common.logc">
        <appender-ref ref="std_plain"/>
    </logger>

    <root level="trace">
        <appender-ref ref="std_pattern"/>
    </root>
</configuration>

除了XML配置，還能夠考慮增長YAML/Properties等形式的配置文件，因此這裏須要將解析配置文件的功能抽象一下，設計一個Configurator接口，用於解析配置文件：

public interface Configurator {
    void doConfigure();
}

再建立一個默認的XML形式的配置解析器：

public class XMLConfigurator implements Configurator{
    
    private final LoggerContext loggerContext;
    
    public XMLConfigurator(URL url, LoggerContext loggerContext) {
        this.url = url;//文件url
        this.loggerContext = loggerContext;
    }
    
    @Override
    public void doConfigure() {
        try{
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder documentBuilder = factory.newDocumentBuilder();
            Document document = documentBuilder.parse(url.openStream());
            parse(document.getDocumentElement());
            ...
        }catch (Exception e){
            ...
        }
    }
    private void parse(Element document) throws IllegalAccessException, ClassNotFoundException, InstantiationException {
        //do parse...
    }
}

解析時，裝配LoggerContext，將配置中的Logger/Root Logger/Appender等信息構建完成，填充至傳入的LoggerContext

如今還須要一個初始化的入口，用於加載/解析配置文件，提供加載/解析後的全局LoggerContext

public class ContextInitializer {
    final public static String AUTOCONFIG_FILE = "logc.xml";//默認使用xml配置文件
    final public static String YAML_FILE = "logc.yml";

    private static final LoggerContext DEFAULT_LOGGER_CONTEXT = new LoggerContext();
    
   /**
    * 初始化上下文
    */
    public static void autoconfig() {
        URL url = getConfigURL();
        if(url == null){
            System.err.println("config[logc.xml or logc.yml] file not found!");
            return ;
        }
        String urlString = url.toString();
        Configurator configurator = null;

        if(urlString.endsWith("xml")){
            configurator = new XMLConfigurator(url,DEFAULT_LOGGER_CONTEXT);
        }
        if(urlString.endsWith("yml")){
            configurator = new YAMLConfigurator(url,DEFAULT_LOGGER_CONTEXT);
        }
        configurator.doConfigure();
    }

    private static URL getConfigURL(){
        URL url = null;
        ClassLoader classLoader = ContextInitializer.class.getClassLoader();
        url = classLoader.getResource(AUTOCONFIG_FILE);
        if(url != null){
            return url;
        }
        url = classLoader.getResource(YAML_FILE);
        if(url != null){
            return url;
        }
        return null;
    }
    
   /**
    *  獲取全局默認的LoggerContext
    */
    public static LoggerContext getDefautLoggerContext(){
        return DEFAULT_LOGGER_CONTEXT;
    }
}

如今還差一步，將加載配置文件的方法嵌入LoggerFactory，讓LoggerFactory.getLogger的時候自動初始化，來改造一下StaticLoggerFactory：

public class StaticLoggerFactory implements ILoggerFactory {

    private LoggerContext loggerContext;

    public StaticLoggerFactory() {
        //構造StaticLoggerFactory時，直接調用配置解析的方法，並獲取loggerContext
        ContextInitializer.autoconfig();
        loggerContext = ContextInitializer.getDefautLoggerContext();
    }
}

如今，一個日誌框架就已經基本完成了。雖然還有不少細節沒有完善，但主體功能都已經包含，麻雀雖小五臟俱全