日志门面

2020-03-10

字数统计: 8.2k字 | 阅读时长≈ 40分

日志门面

门面就是一间房子里面很多东西，跟每个东西打交道太麻烦，于是设立一个保安来看守充当门面角色，此时跟里面东西打交道只需跟门面打交道，但是门面要提供调用里面东西所暴露的方法

面向接口开发，不在依赖具体的实现类，减少代码的耦合

项目通过导入不同的日志实现类来灵活切换日志框架

统一api，方便开发者学习和使用

统一配置便于项目日志管理

JCL

apache已经放弃维护

jakarta Commons Logging是apache提供的一个通用日志api

他是为所有的java日志实现提供一个统一的接口，它自身也提供一个日志实现，但是很弱（SimpleLog）

JCL有两个抽象类，Log和LogFactory（负责创建log对象）

应用–》jcl–》（log4j,jul,logback）

pom.xml


<dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>

Log

/*
一个简单的日志接口抽象日志API。为了成功地被{@link logfactory}实例化，实现这个接口的类必须有一个构造函数，该构造函数接受一个表示该日志的“name”的字符串参数。

<code>Log</code>使用的六个日志级别是（按顺序）：
* <ol> 从小到大
 * <li>trace (the least serious)</li>
 * <li>debug</li>
 * <li>info</li>
 * <li>warn</li>
 * <li>error</li>
 * <li>fatal (the most serious)</li>
 * </ol>

这些日志级别到底层日志系统使用的概念的映射依赖于实现。不过，实现应该确保这种排序按预期的方式进行。

性能通常是一个日志问题。通过检查适当的属性，组件可以避免昂贵的操作（生成要记录的信息）。
 * <pre>
 *    if (log.isDebugEnabled()) {
 *        ... do something expensive ...
 *        log.debug(theResult);
 *    }
 * </pre>
 
底层日志系统的配置通常是在日志API外部完成的，通过该系统支持的任何机制。

*/

    void debug(Object message);

    void debug(Object message, Throwable t);

    void error(Object message);

    void error(Object message, Throwable t);

    void fatal(Object message);

    void fatal(Object message, Throwable t);

    void info(Object message);

    void info(Object message, Throwable t);

    boolean isDebugEnabled();

    boolean isErrorEnabled();

    boolean isFatalEnabled();

    boolean isInfoEnabled();

    boolean isTraceEnabled();

    /**
     * 当前是否启用警告日志记录？
     * <p>
     * 调用此方法可防止在日志级别超过warn时执行代价高昂的操作（例如，<code>String</code>连接）。
     *
     * @如果在基础记录器中启用了warn，则返回true。
     */
    boolean isWarnEnabled();

    void trace(Object message);

    void trace(Object message, Throwable t);


    void warn(Object message);

    /**
     * Logs an error with warn log level.
     *
     * @param message 记录这个消息
     * @param t 记录这个原因
     */
    void warn(Object message, Throwable t);

获取


    
public Log getInstance(String name) throws LogConfigurationException {
    // protected Hashtable instances = new Hashtable();
        Log instance = (Log) instances.get(name);
        if (instance == null) {
            instance = newInstance(name);
            instances.put(name, instance);
        }
        return instance;
    }



 protected Log newInstance(String name) throws LogConfigurationException {
        Log instance;
        try {
            if (logConstructor == null) {
                //这是通过spi机制，服务自动发现来实例化一个对象
                instance = discoverLogImplementation(name);
            }
            else {
                //通过指定的构造方法
                Object params[] = { name };
                instance = (Log) logConstructor.newInstance(params);
            }

            if (logMethod != null) {
                //通过指定的工厂方法
                Object params[] = { this };
                logMethod.invoke(instance, params);
            }

            return instance;

        } catch (LogConfigurationException lce) {

            // 这种类型的异常意味着发现中存在问题，并且我们已经输出了有关该问题的诊断信息，等等；请将其传递下去
            throw lce;

        } catch (InvocationTargetException e) {
            // 调用先前发现的构造函数或方法时出现问题
            Throwable c = e.getTargetException();
            throw new LogConfigurationException(c == null ? e : c);
        } catch (Throwable t) {
            handleThrowable(t); //调用先前发现的构造函数或方法时可能会重新引发问题
            throw new LogConfigurationException(t);
        }
    }




private Log discoverLogImplementation(String logCategory)
        throws LogConfigurationException {
        if (isDiagnosticsEnabled()) {
            logDiagnostic("Discovering a Log implementation...");
        }

    //初始化一些配置信息
        initConfiguration();

        Log result = null;

        // 查看用户是否指定要使用的日志实现
        String specifiedLogClassName = findUserSpecifiedLogClassName();

        if (specifiedLogClassName != null) {
            if (isDiagnosticsEnabled()) {
                logDiagnostic("Attempting to load user-specified log class '" +
                    specifiedLogClassName + "'...");
            }

            result = createLogFromClass(specifiedLogClassName,
                                        logCategory,
                                        true);
            if (result == null) {
                StringBuffer messageBuffer =  new StringBuffer("User-specified log class '");
                messageBuffer.append(specifiedLogClassName);
                messageBuffer.append("' cannot be found or is not useable.");

                // 打错名字或拼错名字是常见的错误。如果可以的话，构建一个好的错误消息
                informUponSimilarName(messageBuffer, specifiedLogClassName, LOGGING_IMPL_LOG4J_LOGGER);
                informUponSimilarName(messageBuffer, specifiedLogClassName, LOGGING_IMPL_JDK14_LOGGER);
                informUponSimilarName(messageBuffer, specifiedLogClassName, LOGGING_IMPL_LUMBERJACK_LOGGER);
                informUponSimilarName(messageBuffer, specifiedLogClassName, LOGGING_IMPL_SIMPLE_LOGGER);
                throw new LogConfigurationException(messageBuffer.toString());
            }

            return result;
        }

        // 没有用户指定的日志；请尝试查找类路径上的内容
        // 请注意，我们故意在classestoDiscovery上循环，并期望createLogFromClass方法在可能的源类加载器上循环。结果是：
    //      for each discoverable log adapter
        //      for each possible classloader
        //          see if it works
        //
        // 乍一看，反其道而行之似乎合情合理：
        //   for each possible classloader
        //     for each discoverable log adapter
        //        see if it works
        //
        // 后者对于用户可安装的日志库（如log4j）当然有优势；例如，在webapp中，在查找父类加载器之前，该代码应该首先检查用户是否提供了任何可能的日志库。然而，不幸的是，Jdk14Logger将始终在jvm>=1.4中工作，SimpleLog将始终在任何jvm中工作。所以永远不会在类循环中查找父类路径。然而，许多用户希望将log4j放在那里会导致它被检测到（这是JCL的历史行为）。所以我们采用第一种方法。在webapp中绑定了特定日志库的用户应该使用commons-logging.propertiesMETA-INF中的文件或服务文件，以强制使用该日志记录库，而不是依赖于发现。

        if (isDiagnosticsEnabled()) {
            logDiagnostic(
                "No user-specified Log implementation; performing discovery" +
                " using the standard supported logging implementations...");
        }
    
    /*
      private static final String LOGGING_IMPL_LOG4J_LOGGER = "org.apache.commons.logging.impl.Log4JLogger";
    
    private static final String[] classesToDiscover = {
            LOGGING_IMPL_LOG4J_LOGGER,
            "org.apache.commons.logging.impl.Jdk14Logger",
            "org.apache.commons.logging.impl.Jdk13LumberjackLogger",
            "org.apache.commons.logging.impl.SimpleLog"
    };
 
    
    
    */
    //这里才是真正使用默认的一套
        for(int i=0; i<classesToDiscover.length && result == null; ++i) {
            result = createLogFromClass(classesToDiscover[i], logCategory, true);
        }

        if (result == null) {
            throw new LogConfigurationException
                        ("No suitable Log implementation");
        }

        return result;
    }





 private Log createLogFromClass(String logAdapterClassName,
                                   String logCategory,
                                   boolean affectState)
        throws LogConfigurationException {

        if (isDiagnosticsEnabled()) {
            logDiagnostic("Attempting to instantiate '" + logAdapterClassName + "'");
        }

        Object[] params = { logCategory };
        Log logAdapter = null;
        Constructor constructor = null;

        Class logAdapterClass = null;
        ClassLoader currentCL = getBaseClassLoader();

        for(;;) {
            // 遍历类加载器层次结构，试图找到一个可行的类加载器。
            logDiagnostic("Trying to load '" + logAdapterClassName + "' from classloader " + objectId(currentCL));
            try {
                if (isDiagnosticsEnabled()) {
                    //显示.class文件在类路径中第一次出现的位置。这是一个ClassLoader.loadClass将从加载类--除非类加载器执行了一些奇怪的操作。
                    URL url;
                    String resourceName = logAdapterClassName.replace('.', '/') + ".class";
                    if (currentCL != null) {
                        url = currentCL.getResource(resourceName );
                    } else {
                        url = ClassLoader.getSystemResource(resourceName + ".class");
                    }

                    if (url == null) {
                        logDiagnostic("Class '" + logAdapterClassName + "' [" + resourceName + "] cannot be found.");
                    } else {
                        logDiagnostic("Class '" + logAdapterClassName + "' was found at '" + url + "'");
                    }
                }

                Class c;
                try {
                  。//  反射加载类
                    c = Class.forName(logAdapterClassName, true, currentCL);
                } catch (ClassNotFoundException originalClassNotFoundException) {
                    // 当前的类加载器在此或任何祖先类加载器中找不到日志适配器。在这种情况下，没有必要尝试更高的层次。。
                    String msg = originalClassNotFoundException.getMessage();
                    logDiagnostic("The log adapter '" + logAdapterClassName + "' is not available via classloader " +
                                  objectId(currentCL) + ": " + msg.trim());
                    try {
                        // 试试类加载器。这在TCCL不包含执行的代码或JCL的情况下可能有效。这种行为表明应用程序类加载策略与Java1.2类加载准则不一致，但JCL可以处理这种情况。
                        c = Class.forName(logAdapterClassName);
                    } catch (ClassNotFoundException secondaryClassNotFoundException) {
                        // 继续下去没有意义：此适配器不可用
                        msg = secondaryClassNotFoundException.getMessage();
                        logDiagnostic("The log adapter '" + logAdapterClassName +
                                      "' is not available via the LogFactoryImpl class classloader: " + msg.trim());
                        break;
                    }
                }
			//实例化
                constructor = c.getConstructor(logConstructorSignature);
                Object o = constructor.newInstance(params);

                // 请注意，我们在尝试创建一个实例（而不是测试）之后进行此测试Log.class.isAssignableFrom（c） ]这样当适配器无论如何都无法实例化时，我们就不会抱怨日志层次结构问题。
                if (o instanceof Log) {
                    logAdapterClass = c;
                    logAdapter = (Log) o;
                    break;
                }

                // OOps，我们这里有一个潜在的问题。已经找到了适配器类，并且它的底层库也存在，但是有多个日志接口类可用，因此无法强制转换为调用者所需的类型。我们当然不能使用此记录器，但我们需要知道是继续发现还是立即终止。
                // 如果handleFlawedHierarchy方法认为此问题是致命的，则抛出LogConfigurationException，如果不是，则返回。
                handleFlawedHierarchy(currentCL, c);
            } catch (NoClassDefFoundError e) {
                // 我们能够加载适配器，但它引用了找不到的其他类。这仅仅意味着底层记录器库不存在于此或任何祖先类加载器中。在这种情况下，没有必要尝试更高的层次。。
                String msg = e.getMessage();
                logDiagnostic("The log adapter '" + logAdapterClassName +
                              "' is missing dependencies when loaded via classloader " + objectId(currentCL) +
                              ": " + msg.trim());
                break;
            } catch (ExceptionInInitializerError e) {
                //静态初始值设定项块或与日志适配器类上的静态变量关联的初始值设定项代码引发了异常。
                //
                //我们认为这意味着找不到适配器的底层日志库
                String msg = e.getMessage();
                logDiagnostic("The log adapter '" + logAdapterClassName +
                              "' is unable to initialize itself when loaded via classloader " + objectId(currentCL) +
                              ": " + msg.trim());
                break;
            } catch (LogConfigurationException e) {
                // 上面对handleFlawedHierarchy的调用一定引发了LogConfigurationException，所以只需抛出它
                throw e;
            } catch (Throwable t) {
                handleThrowable(t); //可能会再次抛出手。发现将决定这是否是一个致命的问题。如果它是致命的，那么将抛出一个LogConfigurationException。
                handleFlawedDiscovery(logAdapterClassName, currentCL, t);
            }

            if (currentCL == null) {
                break;
            }

            // try the parent classloader currentCL = currentCL.getParent();
            currentCL = getParentClassLoader(currentCL);
        }

        if (logAdapterClass != null && affectState) {
            // We've succeeded, so set instance fields
            this.logClassName   = logAdapterClassName;
            this.logConstructor = constructor;

            // Identify the <code>setLogFactory</code> method (if there is one)
            try {
                this.logMethod = logAdapterClass.getMethod("setLogFactory", logMethodSignature);
                logDiagnostic("Found method setLogFactory(LogFactory) in '" + logAdapterClassName + "'");
            } catch (Throwable t) {
                handleThrowable(t); // may re-throw t
                this.logMethod = null;
                logDiagnostic("[INFO] '" + logAdapterClassName + "' from classloader " + objectId(currentCL) +
                              " does not declare optional method " + "setLogFactory(LogFactory)");
            }

            logDiagnostic("Log adapter '" + logAdapterClassName + "' from classloader " +
                          objectId(logAdapterClass.getClassLoader()) + " has been selected for use.");
        }

        return logAdapter;
    }

LogFactory

/*

用于创建{@linklog}实例的工厂，其发现和配置特性与JAXP等标准javaapi所采用的功能相似。

<strong>IMPLEMENTATION NOTE</strong> - 这个实现主要基于apachexerces中的SAXParserFactory和DocumentBuilderFactory实现（对应于JAXP可插拔性api）
*/


static {
        // 注意：在initDiagnostics之前调用方法是安全的（尽管诊断输出被丢弃）。
        thisClassLoader = getClassLoader(LogFactory.class);
        // 为了避免在同一个应用程序中通过不同的类加载器使用JCL的多个实例时产生混淆，我们确保每个记录的消息都有一个前缀form[LogFactory from classloader OID]
        //
        // 注意，这个前缀应该与LogFactoryImpl中的前缀保持一致。但是这里我们不需要输出关于LogFactory的实际*实例*的信息，因为从这个类输出诊断的所有方法都是静态的。
        String classLoaderName;
        try {
            ClassLoader classLoader = thisClassLoader;
            if (thisClassLoader == null) {
                classLoaderName = "BOOTLOADER";
            } else {
                classLoaderName = objectId(classLoader);
            }
        } catch (SecurityException e) {
            classLoaderName = "UNKNOWN";
        }
        diagnosticPrefix = "[LogFactory from " + classLoaderName + "] ";
        diagnosticsStream = initDiagnostics();
        logClassLoaderEnvironment(LogFactory.class);
        factories = createFactoryStore();
        if (isDiagnosticsEnabled()) {
            logDiagnostic("BOOTSTRAP COMPLETED");
        }
    }

获取

public static LogFactory getFactory() throws LogConfigurationException {
       // Identify the class loader we will be using
       //不出意外都是获取主线程的ClassLoader
       ClassLoader contextClassLoader = getContextClassLoaderInternal();

       if (contextClassLoader == null) {
           // This is an odd enough situation to report about. This output will be a nuisance on JDK1.1, as the system classloader is null in that environment.
           if (isDiagnosticsEnabled()) {
               logDiagnostic("Context classloader is null.");
           }
       }

       // Return any previously registered factory for this class loader
       LogFactory factory = getCachedFactory(contextClassLoader);
       if (factory != null) {
           return factory;
       }

       if (isDiagnosticsEnabled()) {
           logDiagnostic(
                   "[LOOKUP] LogFactory implementation requested for the first time for context classloader " +
                   objectId(contextClassLoader));
           logHierarchy("[LOOKUP] ", contextClassLoader);
       }

       // 加载属性文件。
       //
       //如果properties文件存在，那么它的内容将作为LogFactory实现类上的“attributes”。一个特定的属性还可以控制使用哪个LogFactory具体子类，但只有在其他发现机制失败的情况下。。
       //
       // 由于属性文件（如果存在）最终会以某种方式使用，我们不妨先查找它。

       Properties props = getConfigurationFile(contextClassLoader, FACTORY_PROPERTIES);

       // 通过检查加载的属性文件（如果有）来确定是否使用线程上下文类加载器来加载日志类。
       ClassLoader baseClassLoader = contextClassLoader;
       if (props != null) {
           String useTCCLStr = props.getProperty(TCCL_KEY);
           if (useTCCLStr != null) {
               // The Boolean.valueOf(useTCCLStr).booleanValue() formulation
               // is required for Java 1.2 compatibility.
               if (Boolean.valueOf(useTCCLStr).booleanValue() == false) {
                   // 在定位任何日志工厂或日志类时不要使用当前上下文类加载器，只需使用加载此抽象类的类。当这个类部署在容器的共享类路径中时，这意味着webapps不能部署自己的日志实现。这也意味着，是否从TCCL加载特定于库的配置文件取决于实现。
                   baseClassLoader = thisClassLoader;
               }
           }
       }

       // Determine which concrete LogFactory subclass to use.
       // First, try a global system property
       if (isDiagnosticsEnabled()) {
           logDiagnostic("[LOOKUP] Looking for system property [" + FACTORY_PROPERTY +
                         "] to define the LogFactory subclass to use...");
       }

       try {
           String factoryClass = getSystemProperty(FACTORY_PROPERTY, null);
           if (factoryClass != null) {
               if (isDiagnosticsEnabled()) {
                   logDiagnostic("[LOOKUP] Creating an instance of LogFactory class '" + factoryClass +
                                 "' as specified by system property " + FACTORY_PROPERTY);
               }
               factory = newFactory(factoryClass, baseClassLoader, contextClassLoader);
           } else {
               if (isDiagnosticsEnabled()) {
                   logDiagnostic("[LOOKUP] No system property [" + FACTORY_PROPERTY + "] defined.");
               }
           }
       } catch (SecurityException e) {
           if (isDiagnosticsEnabled()) {
               logDiagnostic("[LOOKUP] A security exception occurred while trying to create an" +
                             " instance of the custom factory class" + ": [" + trim(e.getMessage()) +
                             "]. Trying alternative implementations...");
           }
           // ignore
       } catch (RuntimeException e) {
           // 这与在服务文件中指定错误的LogFactory类时的行为不一致。
           //
           // 此处可能发生的一个可能的异常是，当指定的类不能转换为此LogFactory类型时，会发生ClassCastException。
           if (isDiagnosticsEnabled()) {
               logDiagnostic("[LOOKUP] An exception occurred while trying to create an" +
                             " instance of the custom factory class" + ": [" +
                             trim(e.getMessage()) +
                             "] as specified by a system property.");
           }
           throw e;
       }

       // 第二，尝试使用JDK1.3类发现机制来查找服务，这涉及到将一个具有接口类名称的文件放在META-INF/services目录中，其中文件的内容是一行指定实现所需接口的具体类的单行。

       if (factory == null) {
           if (isDiagnosticsEnabled()) {
               logDiagnostic("[LOOKUP] Looking for a resource file of name [" + SERVICE_ID +
                             "] to define the LogFactory subclass to use...");
           }
           try {
               final InputStream is = getResourceAsStream(contextClassLoader, SERVICE_ID);

               if( is != null ) {
                   // This code is needed by EBCDIC and other strange systems. It's a fix for bugs reported in xerces
                   BufferedReader rd;
                   try {
                       rd = new BufferedReader(new InputStreamReader(is, "UTF-8"));
                   } catch (java.io.UnsupportedEncodingException e) {
                       rd = new BufferedReader(new InputStreamReader(is));
                   }

                   String factoryClassName = rd.readLine();
                   rd.close();

                   if (factoryClassName != null && ! "".equals(factoryClassName)) {
                       if (isDiagnosticsEnabled()) {
                           logDiagnostic("[LOOKUP]  Creating an instance of LogFactory class " +
                                         factoryClassName +
                                         " as specified by file '" + SERVICE_ID +
                                         "' which was present in the path of the context classloader.");
                       }
                       factory = newFactory(factoryClassName, baseClassLoader, contextClassLoader );
                   }
               } else {
                   // is == null
                   if (isDiagnosticsEnabled()) {
                       logDiagnostic("[LOOKUP] No resource file with name '" + SERVICE_ID + "' found.");
                   }
               }
           } catch (Exception ex) {
               // note: if the specified LogFactory class wasn't compatible with LogFactory
               // for some reason, a ClassCastException will be caught here, and attempts will
               // continue to find a compatible class.
               if (isDiagnosticsEnabled()) {
                   logDiagnostic(
                       "[LOOKUP] A security exception occurred while trying to create an" +
                       " instance of the custom factory class" +
                       ": [" + trim(ex.getMessage()) +
                       "]. Trying alternative implementations...");
               }
               // ignore
           }
       }

       // Third try looking into the properties file read earlier (if found)

       if (factory == null) {
           if (props != null) {
               if (isDiagnosticsEnabled()) {
                   logDiagnostic(
                       "[LOOKUP] Looking in properties file for entry with key '" + FACTORY_PROPERTY +
                       "' to define the LogFactory subclass to use...");
               }
               String factoryClass = props.getProperty(FACTORY_PROPERTY);
               if (factoryClass != null) {
                   if (isDiagnosticsEnabled()) {
                       logDiagnostic(
                           "[LOOKUP] Properties file specifies LogFactory subclass '" + factoryClass + "'");
                   }
                   factory = newFactory(factoryClass, baseClassLoader, contextClassLoader);

                   // TODO: think about whether we need to handle exceptions from newFactory
               } else {
                   if (isDiagnosticsEnabled()) {
                       logDiagnostic("[LOOKUP] Properties file has no entry specifying LogFactory subclass.");
                   }
               }
           } else {
               if (isDiagnosticsEnabled()) {
                   logDiagnostic("[LOOKUP] No properties file available to determine" + " LogFactory subclass from..");
               }
           }
       }

       // Fourth, try the fallback implementation class

       if (factory == null) {
           if (isDiagnosticsEnabled()) {
               logDiagnostic(
                   "[LOOKUP] Loading the default LogFactory implementation '" + FACTORY_DEFAULT +
                   "' via the same classloader that loaded this LogFactory" +
                   " class (ie not looking in the context classloader).");
           }

           // 注意：与上面的代码不同，上面的代码可以尝试通过TCCL加载自定义的LogFactory实现，我们不尝试通过context类加载器加载默认的LogFactory实现，因为：
           // *这可能会导致问题（请参阅newFactory方法中的注释）没有人应该自定义默认类的代码是的，我们确实放弃了子类的能力来发布一个更新版本的LogFactoryImpl类，并让它由父类中的一个旧LogFactory类动态地使用它，但无论如何，这不一定是个好主意。
           factory = newFactory(FACTORY_DEFAULT, thisClassLoader, contextClassLoader);
       }

       if (factory != null) {
           /**
            * 总是使用上下文类加载器进行缓存。
            */
           cacheFactory(contextClassLoader, factory);

           if (props != null) {
               Enumeration names = props.propertyNames();
               while (names.hasMoreElements()) {
                   String name = (String) names.nextElement();
                   String value = props.getProperty(name);
                   factory.setAttribute(name, value);
               }
           }
       }

       return factory;
   }

使用

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.junit.Test;
 @Test
    public void test2() throws InterruptedException {

        Log aa = LogFactory.getLog("aa");

     
        aa.debug("aaaaaa");
    }

日志门面：对于特定的日志框架配置还是指定日志框架的样子，只是获取日志对象方式使用通用的一套

Slf4j

log4j , jcl , slf4j ,logback log4j2 这里是由程序员之间的关系的，有兴趣可以了解

这个门面于logback一起诞生

简单的日志门面（simple logging facade for java）主要给java日志访问提供一套标准接口，具体有其他日志框架实现

提供日志框架的绑定和日志框架的桥接

http://www.slf4j.org/

请注意，启用SLF4J的库意味着仅添加一个强制性依赖项，即slf4j-api.jar。如果在类路径上未找到绑定，则SLF4J将默认为无操作实现。

pom.xml


   <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.26</version>
    </dependency>

<!-- simple log绑定-->
 <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-simple</artifactId>
        <version>1.7.21</version>
    </dependency>

LoggerFactory


/*
<code>LoggerFactory</code>是一个实用程序类，为各种日志API生成记录器，尤其是log4j、logback和jdk1.4日志记录。还支持其他实现，如NOPLogger和SimpleLogger。
<code>LoggerFactory</code>实际上是一个{@link ILoggerFactory}实例的包装器，它在编译时与<code>LoggerFactory</code>绑定。
请注意<code>LoggerFactory</code>中的所有方法都是静态的。

*/

LoggerFactoryBinder


/*

一个内部接口，帮助静态LoggerFactory类与适当的{@link ILoggerFactory}实例绑定。

*/
有点像 log4j的 RepositySelector的样子
/**
     * Return the instance of {@link ILoggerFactory} that 
     * {@link org.slf4j.LoggerFactory} class should bind to.
     * 
     * @return the instance of {@link ILoggerFactory} that 
     * {@link org.slf4j.LoggerFactory} class should bind to.
     */
    public ILoggerFactory getLoggerFactory();

    /**
     * The String form of the {@link ILoggerFactory} object that this 
     * <code>LoggerFactoryBinder</code> instance is <em>intended</em> to return. 
     * 
     * <p>This method allows the developer to interrogate this binder's intention
     * which may be different from the {@link ILoggerFactory} instance it is able to 
     * yield in practice. The discrepancy should only occur in case of errors.
     * 
     * @return the class name of the intended {@link ILoggerFactory} instance
     */
    public String getLoggerFactoryClassStr();

ILoggerFactory

/*
<code>ILoggerFactory</code>实例按名称制造{@linklogger}实例。


大多数用户通过静态的{@link loggerfactory#getLogger（String）}方法检索{@linklogger}实例。此接口的一个实例在编译时与{@link LoggerFactory}类进行内部绑定。
*/

    public Logger getLogger(String name);

默认使用SimpleLoggerFactory：{@link ILoggerFactory}的实现，它总是返回{@link SimpleLogger}实例

工厂获取

//未初始化
static final int UNINITIALIZED = 0;
//正在进行的初始化
    static final int ONGOING_INITIALIZATION = 1;
//初始化失败
    static final int FAILED_INITIALIZATION = 2;
//成功初始化
    static final int SUCCESSFUL_INITIALIZATION = 3;
//NOP后备初始化
    static final int NOP_FALLBACK_INITIALIZATION = 4;

//注意是一个volatile，禁止指令重排， 线程可见
    static volatile int INITIALIZATION_STATE = UNINITIALIZED;


public static ILoggerFactory getILoggerFactory() {
        if (INITIALIZATION_STATE == UNINITIALIZED) {
            synchronized (LoggerFactory.class) {
                if (INITIALIZATION_STATE == UNINITIALIZED) {
                    INITIALIZATION_STATE = ONGOING_INITIALIZATION;
                    performInitialization();
                }
            }
        }
        switch (INITIALIZATION_STATE) {
        case SUCCESSFUL_INITIALIZATION:
            return StaticLoggerBinder.getSingleton().getLoggerFactory();
        case NOP_FALLBACK_INITIALIZATION:
            return NOP_FALLBACK_FACTORY;
        case FAILED_INITIALIZATION:
            throw new IllegalStateException(UNSUCCESSFUL_INIT_MSG);
        case ONGOING_INITIALIZATION:
            // support re-entrant behavior.
            // See also http://jira.qos.ch/browse/SLF4J-97
            return SUBST_FACTORY;
        }
        throw new IllegalStateException("Unreachable code");
    }



    private final static void performInitialization() {
        //绑定
        bind();
       
        if (INITIALIZATION_STATE == SUCCESSFUL_INITIALIZATION) {
            // //如果初始化成功 ，做一个智能的版本检查
            versionSanityCheck();
        }
    }



  private final static void bind() {
        try {
            Set<URL> staticLoggerBinderPathSet = null;
            if (!isAndroid()) {
                //安卓系统这一步不需要做
                // private static String STATIC_LOGGER_BINDER_PATH = "org/slf4j/impl/StaticLoggerBinder.class";
                /*
                从用于加载类的搜索路径中查找指定名称的所有资源。这样找到的资源将作为URL的Enumeration对象返回。从用于加载类的搜索路径中查找指定名称的资源。此方法通过系统类加载器定位资源（请参见{@link#getSystemClassLoader（）}）。
                */
                staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
                reportMultipleBindingAmbiguity(staticLoggerBinderPathSet);
            }
            // the next line does the binding
            //这里初始化一下StaticLoggerBinder和SimpleLoggerFactory也是为什么强制到入simple包的原因，到了这里就有了默认的日志工厂
            StaticLoggerBinder.getSingleton();
            INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION;
            
            //看到reportActualBinding不要管，就是控制台打印
            reportActualBinding(staticLoggerBinderPathSet);
            
            ///多线程环境下整合logger 
            fixSubstituteLoggers();
            
            //因为此时有些logger实现已经改变，所以重播一次事件
            replayEvents();
            // release all resources in SUBST_FACTORY
            //这里花里胡哨的搞个SUBST_FACTORY出来 就是为了多线程处理logfactory更加快速
            SUBST_FACTORY.clear();
        } catch (NoClassDefFoundError ncde) {
            String msg = ncde.getMessage();
            if (messageContainsOrgSlf4jImplStaticLoggerBinder(msg)) {
                INITIALIZATION_STATE = NOP_FALLBACK_INITIALIZATION;
                Util.report("Failed to load class \"org.slf4j.impl.StaticLoggerBinder\".");
                Util.report("Defaulting to no-operation (NOP) logger implementation");
                Util.report("See " + NO_STATICLOGGERBINDER_URL + " for further details.");
            } else {
                failedBinding(ncde);
                throw ncde;
            }
        } catch (java.lang.NoSuchMethodError nsme) {
            String msg = nsme.getMessage();
            if (msg != null && msg.contains("org.slf4j.impl.StaticLoggerBinder.getSingleton()")) {
                INITIALIZATION_STATE = FAILED_INITIALIZATION;
                Util.report("slf4j-api 1.6.x (or later) is incompatible with this binding.");
                Util.report("Your binding is version 1.5.5 or earlier.");
                Util.report("Upgrade your binding to version 1.6.x.");
            }
            throw nsme;
        } catch (Exception e) {
            failedBinding(e);
            throw new IllegalStateException("Unexpected initialization failure", e);
        }
    }

Logger

/*
org.slf4j.Logger接口是SLF4J API的主要用户入口点。
 * 预期日志记录是通过这个接口的具体实现进行的。
典型使用模式：


 * import org.slf4j.Logger;
 * import org.slf4j.LoggerFactory;
 *
 * public class Wombat {
 *
 *   final static Logger logger = LoggerFactory.getLogger(Wombat.class);
 *   Integer t;
 *   Integer oldT;
 *
 *   public void setTemperature(Integer temperature) {
 *     oldT = t;
 *     t = temperature;
 *     logger.debug("Temperature set to {}. Old temperature was {}.", t, oldT);
 *     if(temperature.intValue() > 50) {
 *       logger.info("Temperature has risen above 50 degrees.");
 *     }
 *   }
 * }
 * </pre>
 请务必阅读与参数化日志记录相关的常见问题解答条目。请注意，日志记录语句可以在出现异常/抛出时参数化。
 一旦您习惯于使用logger，即这个接口的实例，就可以考虑使用MDC和标记。
*/

    //用于检索根记录器名称的不区分大小写的字符串常量。
    final public String ROOT_LOGGER_NAME = "ROOT";

    //返回此<code>记录器</code>实例的名称。
    public String getName();

    // 是否为跟踪级别启用了记录器实例？ 如果为跟踪级别启用此记录器，则为True，否则为false。（减少昂贵操作）
    public boolean isTraceEnabled();

    //在跟踪级别记录消息。
    public void trace(String msg);

    /**
     * 根据指定的格式和参数在跟踪级别记录消息。
     * <p>此形式可避免在为跟踪级别禁用记录器时创建多余的 字符串对象。 </p>
     * @param format 格式字符串
     * @param arg    参数
     */
    public void trace(String format, Object arg);

   //与上面相同，可以带两个参数
    public void trace(String format, Object arg1, Object arg2);

    /**
    与第一个和第二个相同
     但是，此变量会导致在调用方法之前创建<code>Object[]</code>的隐藏成本（且相对较小），即使此记录器已禁用跟踪。
     使用{@link#trace（String，Object）one}和{@link#trace（String，Object，Object）两个}参数的变体的存在完全是为了避免这种隐藏的代价。
     * @param format    the format string
     * @param arguments a list of 3 or more arguments
     * @since 1.4
     */
    public void trace(String format, Object... arguments);

    /**
     * 在跟踪级别记录异常（throwable），并附带一条消息。
     * @param msg    伴随异常的消息
     * @param t       要记录的异常（throwable）
     * @since 1.4
     */
    public void trace(String msg, Throwable t);

    /**
     * 与{@link#isTraceEnabled（）}方法类似，只是标记数据也被考虑在内。
     * @param marker 要考虑的标记数据
     */
    public boolean isTraceEnabled(Marker marker);

    /**
     * 使用跟踪级别的特定标记记录消息。
     *
     * @param marker 特定于此日志语句的标记数据
     * @param msg    the message string to be logged
     */
    public void trace(Marker marker, String msg);

    /**
     * 此方法类似于{@link#trace（String，Object）}方法，只是标记数据也被考虑在内。
     */
    public void trace(Marker marker, String format, Object arg);

    public void trace(Marker marker, String format, Object arg1, Object arg2);

    public void trace(Marker marker, String format, Object... argArray);

    public void trace(Marker marker, String msg, Throwable t);

    public boolean isDebugEnabled();

    public void debug(String msg);

    public void debug(String format, Object arg);

    public void debug(String format, Object arg1, Object arg2);

    public void debug(String format, Object... arguments);

    public void debug(String msg, Throwable t);

    public boolean isDebugEnabled(Marker marker);

    public void debug(Marker marker, String msg);

    public void debug(Marker marker, String format, Object arg);

    public void debug(Marker marker, String format, Object arg1, Object arg2);

    public void debug(Marker marker, String format, Object... arguments);

    public void debug(Marker marker, String msg, Throwable t);

    public boolean isInfoEnabled();

    public void info(String msg);

    public void info(String format, Object arg);

    public void info(String format, Object arg1, Object arg2);

    public void info(String format, Object... arguments);

    public void info(String msg, Throwable t);

    public boolean isInfoEnabled(Marker marker);

    public void info(Marker marker, String msg);

    public void info(Marker marker, String format, Object arg);

    public void info(Marker marker, String format, Object arg1, Object arg2);

    public void info(Marker marker, String format, Object... arguments);

    public void info(Marker marker, String msg, Throwable t);

    public boolean isWarnEnabled();

    public void warn(String msg);

    public void warn(String format, Object arg);

    public void warn(String format, Object... arguments);

    public void warn(String format, Object arg1, Object arg2);

    public void warn(String msg, Throwable t);

    public boolean isWarnEnabled(Marker marker);

    public void warn(Marker marker, String msg);

    public void warn(Marker marker, String format, Object arg);

    public void warn(Marker marker, String format, Object arg1, Object arg2);

    public void warn(Marker marker, String format, Object... arguments);

    public void warn(Marker marker, String msg, Throwable t);

    public boolean isErrorEnabled();

    public void error(String msg);

    public void error(String format, Object arg);

    public void error(String format, Object arg1, Object arg2);

    public void error(String format, Object... arguments);

    public void error(String msg, Throwable t);

    public boolean isErrorEnabled(Marker marker);

    public void error(Marker marker, String msg);

    public void error(Marker marker, String format, Object arg);

    public void error(Marker marker, String format, Object arg1, Object arg2);

    public void error(Marker marker, String format, Object... arguments);

    public void error(Marker marker, String msg, Throwable t);

logger获取



/*


*/
public Logger getLogger(String name) {
        Logger simpleLogger = loggerMap.get(name);
        if (simpleLogger != null) {
            return simpleLogger;
        } else {
            Logger newInstance = new SimpleLogger(name);
            Logger oldInstance = loggerMap.putIfAbsent(name, newInstance);
            return oldInstance == null ? newInstance : oldInstance;
        }
    }


初始化
     
    SimpleLogger(String name) {
        this.name = name;

        String levelString = recursivelyComputeLevelString();
        if (levelString != null) {
            this.currentLogLevel = stringToLevel(levelString);
        } else {
            this.currentLogLevel = DEFAULT_LOG_LEVEL;
        }
    }
 //递归计算level
  String recursivelyComputeLevelString() {
        String tempName = name;
        String levelString = null;
        int indexOfLastDot = tempName.length();
        while ((levelString == null) && (indexOfLastDot > -1)) {
            tempName = tempName.substring(0, indexOfLastDot);
            levelString = getStringProperty(LOG_KEY_PREFIX + tempName, null);
            indexOfLastDot = String.valueOf(tempName).lastIndexOf(".");
        }
        return levelString;
    }

日志记录

 很简单就是根据配置文件设置是否需要进行字符串拼接，最后打印

private void log(int level, String message, Throwable t) {
        if (!isLevelEnabled(level)) {
            return;
        }

        StringBuilder buf = new StringBuilder(32);

        // Append date-time if so configured
        if (SHOW_DATE_TIME) {
            if (DATE_FORMATTER != null) {
                buf.append(getFormattedDate());
                buf.append(' ');
            } else {
                buf.append(System.currentTimeMillis() - START_TIME);
                buf.append(' ');
            }
        }

        // Append current thread name if so configured
        if (SHOW_THREAD_NAME) {
            buf.append('[');
            buf.append(Thread.currentThread().getName());
            buf.append("] ");
        }

        if (LEVEL_IN_BRACKETS)
            buf.append('[');

        // Append a readable representation of the log level
        switch (level) {
        case LOG_LEVEL_TRACE:
            buf.append("TRACE");
            break;
        case LOG_LEVEL_DEBUG:
            buf.append("DEBUG");
            break;
        case LOG_LEVEL_INFO:
            buf.append("INFO");
            break;
        case LOG_LEVEL_WARN:
            buf.append(WARN_LEVEL_STRING);
            break;
        case LOG_LEVEL_ERROR:
            buf.append("ERROR");
            break;
        }
        if (LEVEL_IN_BRACKETS)
            buf.append(']');
        buf.append(' ');

        // Append the name of the log instance if so configured
        if (SHOW_SHORT_LOG_NAME) {
            if (shortLogName == null)
                shortLogName = computeShortName();
            buf.append(String.valueOf(shortLogName)).append(" - ");
        } else if (SHOW_LOG_NAME) {
            buf.append(String.valueOf(name)).append(" - ");
        }

        // Append the message
        buf.append(message);

        write(buf, t);

    }
void write(StringBuilder buf, Throwable t) {
        TARGET_STREAM.println(buf.toString());
        if (t != null) {
            t.printStackTrace(TARGET_STREAM);
        }
        TARGET_STREAM.flush();
    }

绑定日志的实现（Bingding）

如前所诉，slf4j支持各种日志框架

slf4j发行般附加了几个称为 slf4j绑定的文件，每个绑定对应一个受支持的框架

使用slf4j的绑定流程:

1 添加slf4j-api的依赖

2 使用slf4j的api在项目中进行统一的日志记录

3 绑定具体的日志实现框架

1绑定已经实现了slf4j的日志框架，直接添加对应依赖

2绑定没有实现slf4j的日志框架，先添加日志的适配器，在添加实现类依赖

4slf4j有且仅有一个日志框架实现的绑定（出现多个则默认使用第一个依赖日志实现）

绑定logback

pom.xml

<dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-api</artifactId>
       <version>1.7.26</version>
   </dependency>

   <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-simple</artifactId>
       <version>1.7.21</version>
   </dependency>

   <dependency>
       <groupId>ch.qos.logback</groupId>
       <artifactId>logback-classic</artifactId>
       <version>1.2.3</version>
   </dependency>

代码

jar:file:/F:/maven/repository/org/slf4j/slf4j-simple/1.7.21/slf4j-simple-1.7.21.jar!/org/slf4j/impl/StaticLoggerBinder.class
jar:file:/F:/maven/repository/ch/qos/logback/logback-classic/1.2.3/logback-classic-1.2.3.jar!/org/slf4j/impl/StaticLoggerBinder.class
    
    
  上面说明了 /org/slf4j/impl/StaticLoggerBinder.class这个类，在当前项目中有两个地方可以找到 
此时只会使用第一个 的绑定类
    
    那我们需要把/*
      <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-simple</artifactId>
        <version>1.7.21</version>
    </dependency>
    */去掉，然后再看 ，发现StaticLoggerBinder替换成logback-classic的了，这是利用了同包同类名的方式进行StaticLoggerBinder的导入

绑定 Nop

他是一个日志开关，绑定它之后，slf4j不会输出任何日志

pom.xml


<dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-nop</artifactId>
      <version>1.7.25</version>
  </dependency>

以上的两种遵循了 slf4j的规范，所以直接导入依赖即可

绑定 log4j

因为log4j没有遵从slf4j的日志规范，所以需要一个适配器来桥接

pom.xml

<dependency>
     <groupId>org.slf4j</groupId>
     <artifactId>slf4j-log4j12</artifactId>
     <version>1.7.12</version>
 </dependency>
     <dependency>
         <groupId>log4j</groupId>
         <artifactId>log4j</artifactId>
         <version>1.2.17</version>
     </dependency>

代码

public class StaticLoggerBinder implements LoggerFactoryBinder 

  /**
     * The unique instance of this class.
     * 
     */
    private static final StaticLoggerBinder SINGLETON = new StaticLoggerBinder();

    /**
     * Return the singleton of this class.
     * 
     * @return the StaticLoggerBinder singleton
     */
    public static final StaticLoggerBinder getSingleton() {
        return SINGLETON;
    }
  private StaticLoggerBinder() {
        loggerFactory = new Log4jLoggerFactory();
        try {
            @SuppressWarnings("unused")
            Level level = Level.TRACE;
        } catch (NoSuchFieldError nsfe) {
            Util.report("This version of SLF4J requires log4j version 1.2.12 or later. See also http://www.slf4j.org/codes.html#log4j_version");
        }
    }

  */
    public Logger getLogger(String name) {
        Logger slf4jLogger = loggerMap.get(name);
        if (slf4jLogger != null) {
            return slf4jLogger;
        } else {
            org.apache.log4j.Logger log4jLogger;
            if (name.equalsIgnoreCase(Logger.ROOT_LOGGER_NAME))
                log4jLogger = LogManager.getRootLogger();
            else
                log4jLogger = LogManager.getLogger(name);

            Logger newInstance = new Log4jLoggerAdapter(log4jLogger);
            Logger oldInstance = loggerMap.putIfAbsent(name, newInstance);
            return oldInstance == null ? newInstance : oldInstance;
        }
    }



Log4jLoggerAdapter 就是为了 把log4j的logger提供的api给  slf4j的api做一层对应关系
    例如：
     public void error(String msg, Throwable t) {
        logger.log(FQCN, Level.ERROR, msg, t);
    }

    public void log(Marker marker, String callerFQCN, int level, String msg, Object[] argArray, Throwable t) {
        Level log4jLevel;
        switch (level) {
        case LocationAwareLogger.TRACE_INT:
            log4jLevel = traceCapable ? Level.TRACE : Level.DEBUG;
            break;
        case LocationAwareLogger.DEBUG_INT:
            log4jLevel = Level.DEBUG;
            break;
        case LocationAwareLogger.INFO_INT:
            log4jLevel = Level.INFO;
            break;
        case LocationAwareLogger.WARN_INT:
            log4jLevel = Level.WARN;
            break;
        case LocationAwareLogger.ERROR_INT:
            log4jLevel = Level.ERROR;
            break;
        default:
            throw new IllegalStateException("Level number " + level + " is not recognized.");
        }
        logger.log(callerFQCN, log4jLevel, msg, t);
    }

绑定jul

与log4j一样，需要适配

pom.xml


<dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-jdk14</artifactId>
        <version>1.7.25</version>
    </dependency>

代码


public class StaticLoggerBinder implements LoggerFactoryBinder {

    /**
     * The unique instance of this class.
     * 
     */
    private static final StaticLoggerBinder SINGLETON = new StaticLoggerBinder();

    /**
     * Return the singleton of this class.
     * 
     * @return the StaticLoggerBinder singleton
     */
    public static final StaticLoggerBinder getSingleton() {
        return SINGLETON;
    }

    /**
     * Declare the version of the SLF4J API this implementation is compiled against. 
     * The value of this field is modified with each major release. 
     */
    // to avoid constant folding by the compiler, this field must *not* be final
    public static String REQUESTED_API_VERSION = "1.6.99"; // !final

    private static final String loggerFactoryClassStr = org.slf4j.impl.JDK14LoggerFactory.class.getName();

    /** The ILoggerFactory instance returned by the {@link #getLoggerFactory} method
     * should always be the same object
     */
    private final ILoggerFactory loggerFactory;

    private StaticLoggerBinder() {
        // Note: JCL gets substituted at build time by an appropriate Ant task
        loggerFactory = new org.slf4j.impl.JDK14LoggerFactory();
    }
    
    
--------------------------------    JDK14LoggerFactory-------
    
      public JDK14LoggerFactory() {
        loggerMap = new ConcurrentHashMap<String, Logger>();
        // ensure jul initialization. see SLF4J-359 
        // note that call to java.util.logging.LogManager.getLogManager() fails on the Google App Engine platform. See SLF4J-363
        java.util.logging.Logger.getLogger("");
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.slf4j.ILoggerFactory#getLogger(java.lang.String)
     */
    public Logger getLogger(String name) {
        // the root logger is called "" in JUL
        if (name.equalsIgnoreCase(Logger.ROOT_LOGGER_NAME)) {
            name = "";
        }

        Logger slf4jLogger = loggerMap.get(name);
        if (slf4jLogger != null)
            return slf4jLogger;
        else {
            java.util.logging.Logger julLogger = java.util.logging.Logger.getLogger(name);
            Logger newInstance = new JDK14LoggerAdapter(julLogger);
            Logger oldInstance = loggerMap.putIfAbsent(name, newInstance);
            return oldInstance == null ? newInstance : oldInstance;
        }
    }
    
    --------------------JDK14LoggerAdapter------
        适配器 就是聚合具体日志框架实现的 logger，然后 处理消息并调用
         public void error(String msg, Throwable t) {
        if (logger.isLoggable(Level.SEVERE)) {
            log(SELF, Level.SEVERE, msg, t);
        }
    }

    /**
     * Log the message at the specified level with the specified throwable if any.
     * This method creates a LogRecord and fills in caller date before calling
     * this instance's JDK14 logger.
     * 
     * See bug report #13 for more details.
     * 
     * @param level
     * @param msg
     * @param t
     */
    private void log(String callerFQCN, Level level, String msg, Throwable t) {
        // millis and thread are filled by the constructor
        LogRecord record = new LogRecord(level, msg);
        record.setLoggerName(getName());
        record.setThrown(t);
        // Note: parameters in record are not set because SLF4J only
        // supports a single formatting style
        fillCallerData(callerFQCN, record);
        logger.log(record);
    }

桥接

log4j的桥接

pom.xml


<dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-api</artifactId>
       <version>1.7.26</version>
   </dependency>

   <dependency>
       <groupId>ch.qos.logback</groupId>
       <artifactId>logback-classic</artifactId>
       <version>1.2.3</version>
   </dependency>
   <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>log4j-over-slf4j</artifactId>
       <version>1.7.25</version>
   </dependency>

代码

桥接是什么，就是把按照包名加类名然后重写一遍

那么此时适配和桥接不能放一起，因为此时真正的log4j的logger不存在，只有一个假的在这里

那么slf4j通过 StaticLoggerBinder的对象获取的logger还是那个假的，假的调用又会走到获取slf4j的调用，一直反复，此时栈溢出

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

  public static Logger getLogger(String name) {
        org.apache.log4j.Logger instance = log4jLoggers.get(name);
        if (instance != null) {
            return instance;
        } else {
            Logger newInstance = new Logger(name);
            Logger oldInstance = log4jLoggers.putIfAbsent(name, newInstance);
            return oldInstance == null ? newInstance : oldInstance;
        }
    }
-------------
    
       protected Logger(String name) {
        super(name);
    }
    
    Category(String name) {
        this.name = name;
        slf4jLogger = LoggerFactory.getLogger(name);
        if (slf4jLogger instanceof LocationAwareLogger) {
            locationAwareLogger = (LocationAwareLogger) slf4jLogger;
        }
    }

-------------------
    
    public void trace(Object message) {
        differentiatedLog(null, LOGGER_FQCN, LocationAwareLogger.TRACE_INT, message, null);
    }

void differentiatedLog(Marker marker, String fqcn, int level, Object message, Throwable t) {

        String m = convertToString(message);
        if (locationAwareLogger != null) {
            locationAwareLogger.log(marker, fqcn, level, m, null, t);
        } else {
            switch (level) {
            case LocationAwareLogger.TRACE_INT:
                slf4jLogger.trace(marker, m);
                break;
            case LocationAwareLogger.DEBUG_INT:
                slf4jLogger.debug(marker, m);
                break;
            case LocationAwareLogger.INFO_INT:
                slf4jLogger.info(marker, m);
                break;
            case LocationAwareLogger.WARN_INT:
                slf4jLogger.warn(marker, m);
                break;
            case LocationAwareLogger.ERROR_INT:
                slf4jLogger.error(marker, m);
                break;
            }
        }
    }

本文作者： 忘忧症
本文链接： https://NepenthesZGW.github.io/2020/03/10/framework/log/日志门面/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！