手把手教你从零设计一个日志框架

时间  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）”的意思
logger_hierarchy.svg

上图中的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();
    }
}

如今，一个日志框架就已经基本完成了。虽然还有不少细节没有完善，但主体功能都已经包含，麻雀虽小五脏俱全

完整代码

本文中为了便于阅读，有些代码并无贴上来，详细完整的代码能够参考：
https://github.com/kongwu-/logc

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程