一、定义

SLF4J是提供给Java的一套日志规范的API。SLF4J就是一个接口，具体的日志实现由其他日志框架，比如log4j.logback。

SLF4J在项目中使用的时候必须加入SLF4J的实现框架，比如log4j,logback,只是项目的门面上是SLF4J。

二、SLFJ4J项目

slf4j-api为项目基础
slf4j-jdk14和slf4j-log4j12分别为jdk日志框架和log4j日志框架的桥接器，负责将slf4j-api和具体的实现框架连接起来
jcl-over-slf4j, log4j-over-slf4j, osgi-over-slf4j和jul-to-slf4j分别将对应的其他框架的日志桥接到slf4j上来
slf4j-nop和slf4j-simple是slf4j提供的日志实现类，一般很少用到
slf4j-ext和slf4j-migrator为工具模块

三、优势

因为SLF4J并不是日志框架实现，而是一个抽象层，一个日志规范的API接口，开发中使用SLF4J的好处，避免管理多套日志框架。

比如，一个项目中用到了logback，引入的类库则是使用log4j的，那么是不是要去维护两套日志框架，但是如果类库是使用SLF4J，开发的时候能够继续使用当前的日志框架，因为slf4j能够选择使用哪个实现框架，而不用维护另一套日志框架。

另一个特性是，SLFJ4J在日志打印的时候，使用的占位符的特性。在运行时候，占位符会被某个实际的字符串替换，从而节省新建的String对象，并且能够减少字符串的次数。

log4j方式：

 logger.debug("Processing trade with id: " + id + " symbol: " + symbol);

SLF4J方式：

logger.debug("Processing trade with id: {} and symbol : {} ", id, symbol);

四、原理

slf4j-api

slf4j-api是SLF4J的API模块，提供了日志输出的API

首先，我们看下slf4j是怎么使用的？

private Logger logger = LoggerFactory.getLogger(TestController.class);
...
logger.info("some message")

看下，getLogger方法

public static Logger getLogger(String name) {
        ILoggerFactory iLoggerFactory = getILoggerFactory();
        return iLoggerFactory.getLogger(name);
    }

ILoggerFactory是slf4j的一个接口，getILoggerFactory应该是获取一个实现类。

其中ILoggerFactory是slf4j提供的一个接口，因此我们可以猜测getILoggerFactory方法应该是拿到了其实现类.

public static ILoggerFactory getILoggerFactory() {
        return getProvider().getLoggerFactory();
    }

static SLF4JServiceProvider getProvider() {
        if (INITIALIZATION_STATE == UNINITIALIZED) {
            synchronized (LoggerFactory.class) {
                if (INITIALIZATION_STATE == UNINITIALIZED) {
                    INITIALIZATION_STATE = ONGOING_INITIALIZATION;
                    performInitialization();
                }
            }
        }
        switch (INITIALIZATION_STATE) {
        case SUCCESSFUL_INITIALIZATION:
            return PROVIDER;
        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_PROVIDER;
        }
        throw new IllegalStateException("Unreachable code");
    }

其中SLF4JServiceProvider同样是slf4j-api中提供的一个接口，那么getProvider肯定是通过某种方法拿到了该接口的实现类。

private final static void performInitialization() {
        bind();
        if (INITIALIZATION_STATE == SUCCESSFUL_INITIALIZATION) {
            versionSanityCheck();
        }
    }

    private final static void bind() {
        try {
            List<SLF4JServiceProvider> providersList = findServiceProviders();
            reportMultipleBindingAmbiguity(providersList);
            if (providersList != null && !providersList.isEmpty()) {
                PROVIDER = providersList.get(0);
                PROVIDER.initialize();
                INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION;
                reportActualBinding(providersList);
                fixSubstituteLoggers();
                replayEvents();
                // release all resources in SUBST_FACTORY
                SUBST_PROVIDER.getSubstituteLoggerFactory().clear();
            } else {
                INITIALIZATION_STATE = NOP_FALLBACK_INITIALIZATION;
                Util.report("No SLF4J providers were found.");
                Util.report("Defaulting to no-operation (NOP) logger implementation");
                Util.report("See " + NO_PROVIDERS_URL + " for further details.");

                Set<URL> staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
                reportIgnoredStaticLoggerBinders(staticLoggerBinderPathSet);
            }
        } catch (Exception e) {
            failedBinding(e);
            throw new IllegalStateException("Unexpected initialization failure", e);
        }
    }

注意其中一行代码

List<SLF4JServiceProvider> providersList = findServiceProviders();

private static List<SLF4JServiceProvider> findServiceProviders() {
        ServiceLoader<SLF4JServiceProvider> serviceLoader = ServiceLoader.load(SLF4JServiceProvider.class);
        List<SLF4JServiceProvider> providerList = new ArrayList<SLF4JServiceProvider>();
        for (SLF4JServiceProvider provider : serviceLoader) {
            providerList.add(provider);
        }
        return providerList;
    }

终于露出庐山真面目：原来是通过SPI的方式寻找SLF4JServiceProvider的实现类.

接下来看看SLF4JServiceProvider这个接口提供的方法(只贴了两个最重要的方法)

public interface SLF4JServiceProvider {
    // 返回ILoggerFactory的实现类
    public ILoggerFactory getLoggerFactory();
    
    // 初始化，实现类中一般用于初始化ILoggerFactory
    public void initialize();
}

先不着急看SLF4JServiceProvider的实现类长什么样子，先思考一个问题：如果找不到实现类或者是找到了多个实现类怎么办？

还是看bind方法。

找不到实现类：会在classpath下寻找org/slf4j/impl/StaticLoggerBinder.class类，这个类就是1.8之前slf4j寻找的Binder类，因此匹配1.8版本之前的slf4j-api的桥接器都会包含一个该类.1.8及之后的版本中即便是找到了该类，slf4j也不会使用该类完成实现框架的绑定，而是忽略，使用自带的实现类NOPLogger。该类其实啥都没做，所有的方法都是空的。因此，如果找不到SLF4JServiceProvider的实现类，系统不会报错，而是不会输出任何日志
找到多个实现类：会取第一个，当存在多个实现框架时候，取其中一个，选择权在JVM，是随机的。

桥接器

主要讲讲如何slf4j-api+桥接器+实现框架（以log4j为例）的工作原理

我们不妨思考下，我们希望利用这三件套做什么？我们想做的是编码中使用的是slf4j-api提供的方法，而实际运作的是log4j。也就是说我们希望使用Logger(slf4j提供)，而实际运行的是Logger(log4j)，其实很好办，那就是将Logger(slf4j)接收到的命令全部委托给Logger(log4j)去完成，悄悄的完成偷天换日。我们接下来去翻翻slf4j-log4j12这个桥接器的源码，看看它是怎么做的。

首先，它肯定有个SLF4JServiceProvider的实现类

public class Log4j12ServiceProvider implements SLF4JServiceProvider {

    /**
     * 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.8.99"; // !final

    private ILoggerFactory loggerFactory; 
    private IMarkerFactory markerFactory; 
    private MDCAdapter mdcAdapter;
    
    public Log4j12ServiceProvider() {
        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");
        }
    }

    @Override
    public void initialize() {
        loggerFactory = new Log4jLoggerFactory();
        markerFactory = new BasicMarkerFactory();
        mdcAdapter = new Log4jMDCAdapter();
    }
    
    public ILoggerFactory getLoggerFactory() {
        return loggerFactory;
    }

    public IMarkerFactory getMarkerFactory() {
        return markerFactory;
    }

    public MDCAdapter getMDCAdapter() {
        return mdcAdapter;
    }

    public String getRequesteApiVersion() {
        return REQUESTED_API_VERSION;
    }
}

看看它的getLoggerFactory返回的实现类

public class Log4jLoggerFactory implements ILoggerFactory {

    private static final String LOG4J_DELEGATION_LOOP_URL = "http://www.slf4j.org/codes.html#log4jDelegationLoop";

    // check for delegation loops
    static {
        try {
            Class.forName("org.apache.log4j.Log4jLoggerFactory");
            String part1 = "Detected both log4j-over-slf4j.jar AND bound slf4j-log4j12.jar on the class path, preempting StackOverflowError. ";
            String part2 = "See also " + LOG4J_DELEGATION_LOOP_URL + " for more details.";

            Util.report(part1);
            Util.report(part2);
            throw new IllegalStateException(part1 + part2);
        } catch (ClassNotFoundException e) {
            // this is the good case
        }
    }

    // key: name (String), value: a Log4jLoggerAdapter;
    ConcurrentMap<String, Logger> loggerMap;

    public Log4jLoggerFactory() {
        loggerMap = new ConcurrentHashMap<String, Logger>();
        // force log4j to initialize
        org.apache.log4j.LogManager.getRootLogger();
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.slf4j.ILoggerFactory#getLogger(java.lang.String)
     */
    public Logger getLogger(String name) {
        // 从缓存中获取Logger
        Logger slf4jLogger = loggerMap.get(name);
        if (slf4jLogger != null) {
            return slf4jLogger;
        } else {
          // 如果没有就构造一个log4j的Logger
            org.apache.log4j.Logger log4jLogger;
            if (name.equalsIgnoreCase(Logger.ROOT_LOGGER_NAME))
                log4jLogger = LogManager.getRootLogger();
            else
                log4jLogger = LogManager.getLogger(name);
            // 利用构造的log4j的Logger 构造出一个Log4jLoggerAdapter
            Logger newInstance = new Log4jLoggerAdapter(log4jLogger);
            Logger oldInstance = loggerMap.putIfAbsent(name, newInstance);
            return oldInstance == null ? newInstance : oldInstance;
        }
    }
}

注意Log4jLoggerAdapter这个类，它内部持有了一个log4j的Logger对象，自身又实现了slf4j的Logger接口，这是一个典型的适配器模式。其提供了slf4j-api的方法，但是具体事情全交给持有的log4j Logger去执行。这样就达到了连接slf4j-api和log4j的目的。而log4j Logger的具体实现则是交由log4j去完成的，slf4j-api无感知也不关心。

简单实现类

NOPLogger，什么都不做，在slf4j-api中
SimpleLogger，slf4j-simple提供的简单实现类，有兴趣的同学可以去看看，因为slf4j的定位是提供标准的API，而不是实现，因此其实现类算是个鸡肋，聊胜于无

反向桥接器

我之所以称之为反向桥接器是为了区分前文中提到的桥接器，前文提到的桥接器作用是将slf4j-api导到具体的实现框架上，而这部分的桥接器则是将实现框架提供的API调用导到slf4j-api上来。例如当前项目中使用log4j的Logger打印日志，想要切换到logback上来又不想改代码，怎么办呢？这时反向桥接器就能大展拳脚了。

将log4j的jar包从项目中拿掉，此时项目编译肯定没法通过，别急，到第二步
引入log4j-over-slf4j jar，该jar包中包含了log4j中主要的类，连名字都一样，这样编译不再报错
引入logback-classic和logback-core，大功告成

反向桥接器的原理就是自己写了一堆桥接来源相关jar中一样的类，偷天换日，悄悄的来了个狸猫换太子。

值得注意的是不要乱引入桥接器和反向桥接器，避免形成环，导致栈溢出。

总结

1. SLF4J是一个日志规范API，具体的日志实现由其他框架完成，比如log4j,logback，当存在多个实现框架选择时候，只会选择其中一个，是随机的，取决于JVM .

2. SLF4J是搭配它的实现框架如log4j,logback来使用的。
转载：https://www.jianshu.com/p/ce995868dd4a

【转】SLF4J简介