SLF4J 发现多个绑定类 Class path contains multiple SLF4J bindings._slf4j: class path contains multiple slf4j bindings

报错信息

SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in [jar:file:/C:/Users/yu109/.m2/repository/ch/qos/logback/logback-classic/1.2.3/logback-classic-1.2.3.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in [jar:file:/C:/Users/yu109/.m2/repository/org/apache/logging/log4j/log4j-slf4j-impl/2.12.1/log4j-slf4j-impl-2.12.1.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.
SLF4J: Actual binding is of type [ch.qos.logback.classic.util.ContextSelectorStaticBinder]
1
2
3
4
5

报错原因

报错信息中第一行已经说明了，在类路径下包含了多个 slf4j 的绑定，然后下面列出了对应的类， 然后最后一行说明了，从中选择了一个实际绑定的类。

其实这个警告问题并不大，即使不处理，也不会影响我们正常的日志打印，但是每次一启动就打印这种警告实在很烦。

解决办法

解决办法就很简单了，我们只需要分析maven依赖，然后找到警告日志中包含的jar，把这个jar排除依赖即可。

例如，我的工程里是存在一个 log4j-slf4j-impl 包

在pom.xml 目录执行 mvn dependency:tree

执行结果会以树形结构展现出来，然后我们找到警告中对应的jar包，然后向上找到根jar包，也就是我们的工程pom.xml 直接引用的，然后排除，如下图：

在 pom.xml 排除多余的这个jar

		<dependency>
			<groupId>net.mingsoft</groupId>
			<artifactId>ms-mpeople</artifactId>
			<version>1.0.0.0-SNAPSHOT</version>
			<exclusions>
				<exclusion>
					<groupId>org.apache.logging.log4j</groupId>
					<artifactId>log4j-slf4j-impl</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
1
2
3
4
5
6
7
8
9
10
11

根本原因

slf4j 是一个日志门面，自身并没有实现日志相关的功能，常见的实现有 logback 、 log4j等等，然后通过绑定关系，来建立slf4j 和具体日志实现类的关联，上面的报错，就是因为在类路径下发现了多个 slf4j 的绑定，因此报了这个警告，我们可以通过源代码，来看一下这个块绑定的逻辑：

我们在使用 slf4j ，通常都是如下情况：

// 我们就从LoggerFactory.getLogger 方法作为入口，看看slf4j 是如何绑定实现类的
private Logger log = LoggerFactory.getLogger(Object.class);
1
2

org.slf4j.LoggerFactory 的源码如下： 我做了一些简化，并且重新调整了源代码的顺序，从上到下是按照调用顺序整理了一下，并且只保留了主要的代码，方便我们查看：

public final class LoggerFactory {

    public static Logger getLogger(Class<?> clazz) {
		// 调用getLogger方法，如下
        Logger logger = getLogger(clazz.getName());
        // ... 
        return logger;
    }
	
	public static Logger getLogger(String name) {
		// 获取日志工厂
        ILoggerFactory iLoggerFactory = getILoggerFactory();
        return iLoggerFactory.getLogger(name);
    }
	
	public static ILoggerFactory getILoggerFactory() {
        if (INITIALIZATION_STATE == UNINITIALIZED) {
            synchronized (LoggerFactory.class) {
                if (INITIALIZATION_STATE == UNINITIALIZED) {
                    INITIALIZATION_STATE = ONGOING_INITIALIZATION;
                    performInitialization();
                }
            }
        }
       // ....
    }	


	// 用来完成一些初始化工作，具体就包括绑定日志实现类
    private final static void performInitialization() {
        bind();
        if (INITIALIZATION_STATE == SUCCESSFUL_INITIALIZATION) {
            versionSanityCheck();
        }
    }
	
	// 执行具体的绑定，首先会在类路径下找到绑定类
	private final static void bind() {
        try {
            Set<URL> staticLoggerBinderPathSet = null;

            if (!isAndroid()) {
				// 调用方法找到类路径下所有的绑定类 ，其实从这里就可以看出来slf4j是如何与具体的实现类绑定起来的
                staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
				// 检查一下如果有多个绑定类，就会报开头的那个警告
                reportMultipleBindingAmbiguity(staticLoggerBinderPathSet);
            }
            // ...
        } catch (NoClassDefFoundError ncde) {
            // ...
        } catch (java.lang.NoSuchMethodError nsme) {
            // ...
        } catch (Exception e) {
            // ...
        }
    }
		// 绑定类的全限定名，这个类在所有的slf4j中都存在
	    private static String STATIC_LOGGER_BINDER_PATH = "org/slf4j/impl/StaticLoggerBinder.class";
		
		// 查找可能存在的类路径 
	    static Set<URL> findPossibleStaticLoggerBinderPathSet() {
        Set<URL> staticLoggerBinderPathSet = new LinkedHashSet<URL>();
        try {
            ClassLoader loggerFactoryClassLoader = LoggerFactory.class.getClassLoader();
            Enumeration<URL> paths;
            if (loggerFactoryClassLoader == null) {
				// 通过类加载器找到绑定类的path路径
                paths = ClassLoader.getSystemResources(STATIC_LOGGER_BINDER_PATH);
            } else {
                paths = loggerFactoryClassLoader.getResources(STATIC_LOGGER_BINDER_PATH);
            }
            while (paths.hasMoreElements()) {
                URL path = paths.nextElement();
                staticLoggerBinderPathSet.add(path);
            }
        } catch (IOException ioe) {
            Util.report("Error getting resources from path", ioe);
        }
        return staticLoggerBinderPathSet;
    }
	
	
	// 这个方法就是打印开头的那个报警，发现了多个绑定类
	private static void reportMultipleBindingAmbiguity(Set<URL> binderPathSet) {
        if (isAmbiguousStaticLoggerBinderPathSet(binderPathSet)) {
            Util.report("Class path contains multiple SLF4J bindings.");
            for (URL path : binderPathSet) {
                Util.report("Found binding in [" + path + "]");
            }
            Util.report("See " + MULTIPLE_BINDINGS_URL + " for an explanation.");
        }
    }
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94