点击上方 "编程技术圈"关注, 星标或置顶一起成长

后台回复“大礼包”有惊喜礼包！

每日英文

Sometimes you have to accept the fact that certain things will never go back to how they used to be.

有时候，你不得不接受这个现实：有些事情已回不到从前了。

每日掏心话

保持一份自信，保住一份尊严，宁可高傲到发霉，也不要死缠到发疯。

责编：乐乐 | 来自：空无链接：juejin.cn/post/6942731044269326366

编程技术圈(ID:study_tech)第 1247 次推文

往日回顾：2021 年 4 月程序员工资统计，这太可怕了……

   正文   

Java 里的各种日志框架，相信大家都不陌生。Log4j/Log4j2/Logback/jboss logging 等等，其实这些日志框架核心结构没什么区别，只是细节实现上和其性能上有所不同。本文带你从零开始，一步一步的设计一个日志框架.输出内容 - LoggingEvent提到日志框架，最容易想到的核心功能，那就是输出日志了。那么对于一行日志内容来说，应该至少包含以下几个信息：日志时间戳线程信息日志名称（一般是全类名）日志级别日志主体（需要输出的内容，比如 info（str））为了方便的管理输出内容，现在需要创建一个输出内容的类来封装这些信息：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 +                ", thread + threadName + '\'' +                ", threadId=" + threadId +                ", logger + loggerName + '\'' +                '}';    }}对于每一次日志打印，应该属于一次输出的 “事件 - Event”，所以这里命名为 LoggingEvent
输出组件 - Appender有了输出内容之后，现在需要考虑输出方式。输出的方式可以有很多：标准输出 / 控制台（Standard Output/Console）、文件（File）、邮件（Email）、甚至是消息队列（MQ）和数据库。
现在将输出功能抽象成一个组件 “输出器” - Appender，这个 Appender 组件的核心功能就是输出，下面是 Appender 的实现代码：
public interface Appender {    void append(LoggingEvent event);}不同的输出方式，只需要实现 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();        }    }}日志级别设计 - Level日志框架还应该提供日志级别的功能，程序在使用时可以打印不同级别的日志，还可以根据日志级别来调整那些日志可以显示，一般日志级别会定义为以下几种，级别从左到右排序，只有大于等于某级别的 LoggingEvent 才会进行输出
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，输出不同级别的日志。不过显然还不太够，还是缺少一些核心功能
搜索公众号顶级架构师后台回复“offer”，获取一份惊喜礼包。
日志层级 - 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.appender.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 >    </appender><logger >        <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现在还需要一个初始化的入口，用于加载 / 解析配置文件，提供加载 / 解析后的全局 LoggerContextpublic 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-/logcPS：欢迎在留言区留下你的观点，一起讨论提高。如果今天的文章让你有新的启发，欢迎转发分享给更多人。版权申明：内容来源网络，版权归原创者所有。除非无法确认，我们都会标明作者及出处，如有侵权烦请告知，我们会立即删除并表示歉意。谢谢!欢迎加入后端架构师交流群，在后台回复“学习”即可。最近面试BAT，整理一份面试资料《Java面试BAT通关手册》，覆盖了Java核心技术、JVM、Java并发、SSM、微服务、数据库、数据结构等等。在这里，我为大家准备了一份2021年最新最全BAT等大厂Java面试经验总结。
别找了，想获取史上最简单的Java大厂面试题学习资料
扫下方二维码回复「面试」就好了猜你还想看
阿里、腾讯、百度、华为、京东最新面试题汇集
字节跳动涉代码抄袭被诉陪22.74亿，连错误的函数都搬？程序员缺乏经验的 7 种表现一个基于SpringBoot + Mybatis + Vue的代码生成器嘿，你在看吗？