项目存在多个logback配置

以下两个是我在使用slf4j + logback时候日志提示的问题，问题不大，都是WARN，并不真正影响运行，但是结果可能不是你希望的结果。

<1>

SLF4J: Found binding in [jar:file:/servers/storm-0.9.0.1/lib/logback-classic-1.0.6.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in [jar:file:/servers/test_index/index.jar!/org/slf4j/impl/StaticLoggerBinder.class]

SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.

Class path contains multiple SLF4J bindings.

<2>

Could NOT find resource [logback.groovy]
- Could NOT find resource [logback-test.xml]
- Found resource [logback.xml] at [file:/D:/IdeaCode/gitCode/index_file/index_file_service/target/classes/logback.xml]
- Resource [logback.xml] occurs multiple times on the classpath.
 - Resource [logback.xml] occurs at [file:/D:/IdeaCode/index/service/target/classes/logback.xml]
 - Resource [logback.xml] occurs at [file:/D:/IdeaCode/index/dao/target/classes/logback.xml]

简单介绍下SLF4J：

SLF4J(Simple logging Facade for Java)不是一个真正的日志实现，而是一个抽象层，它允许你在后台使用任意一个日志类库。如果是在编写供内外部都可以使用的API或者通用类库，那么你真不会希望使用你类库的客户端必须使用你选择的日志类库。

SLF4j采用了静态绑定来确定具体日志库。静态绑定就是为每一个具体的日志库写一个包名和类名都相同类： org.slf4j.impl.StaticLoggerBinder，这个类的功能就是调用具体的日志库。这个类会存放在Adaptation layer或者native implementation of slf4j-api的jar包中。SLF4j的使用者只要把具体日志库对应的Adaptation layer或者native implementation of slf4j-api的jar包放入classpath中,SLF4j便会装载(load)对应版本的org.slf4j.impl.StaticLoggerBinder，从而调用具体的日志库。

如果项目中之前使用了Log4j，现在要使用SLF4J + LogBack,如果遇到冲突，先观察以下jar包：

(slf4j-XXX-version.jar)
slf4j-log4j12.jar：slf4j提供 log 接口,其具体实现是根据放入程序的绑定器决定.
slf4j-log4j12.jar就是实现通过slf4j调度使用log4j。

(XXX-over-slf4j.jar)
所谓的桥接器即一个假的日志实现工具。
log4j-over-slf4j.jar：是一个桥接器，本来组件是通过log4j输出日志的，通过该桥接器被转到slf4j,slf4j在根据绑器把日志交给具体的日志实现工具。

如果log4j-over-slf4j.jar 和 slf4j-log4j12.jar共存话，就像两个人互相推卸责任不干活，最终陷入死循环。

可以将对应的jar排除

<exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>log4j-over-slf4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>

针对情况<1>，一般是在classpath下出现了多个logback可以静态绑定的日志实现，slf4j会默认选择其中的一种实现来绑定，如若出现其他错误再仔细排查。

在这里logback启动的时候，加载配置文件的顺序：

1. 如果指定了 logback.configurationFile性,将使用这个属性的地址，如启动指定了：  java -Dlogback.configurationFile=/path/to/config.xml

2.如果没有配置上面的属性, 将会在classpath中查找  logback.groovy ,如果没有找到文件,依次查找  logback-test.xml, logback.xml 。

3.如果都没有找到, jdk版本如果是 jdk6+,会调用ServiceLoader 查找 com.qos.logback.classic.spi.Configurator接口的第一个实现类

4.如果上面都没有,将使用ch.qos.logback.classic.BasicConfigurator,在控制台输出日志

针对情况<2>，一般是在classpath下出现了多个logback配置文件，一般是在使用了maven不同的模块中使用了不同的配置，其实可以将所有模块公用一个配置。

正如stackoverflow上所述一样，

As far as I‘m concerned, you should never package a logging config file (logback.xml, log4j.properties, or what have you) inside a JAR file. The whole point of even having a logging config file is to make it easy for the end-user to adjust logging levels by editing the file. Burying it in an archive defeats the purpose of that, because to change the logging level your user has to expand the archive, edit the file, and then re-package the archive.

Here‘s my preferred layout for a deployed application. It‘s a little bit more work to set up, but IMO is worth the trouble because it gives you the flexibility and ease of configuration that an uberjar doesn‘t.

my-app/
  bin/
    run-app.sh
  config/
    logback.xml
  lib/
    my-lib.jar
    my-app.jar
Your run-app.sh script would look something like:

BIN=`dirname "$0"`
BASE=$BIN/..
java -cp "$BASE/config:$BASE/lib/*" my-app.main
This has the advantage that, by putting the config directory at the front of the classpath, any logging config file found there should take precedence over anything that might be found in one of the JARs (e.g. included by a third-party library that you have no control over).

你最好不要将配置文件打包到jar包中，因为增加配置文件本质上就是为了方便用户调整一下参数配置，如果将它打包到jar包中，你需要修改指定的文件并从新打包，上线。这样的优势在于你可以方便的修改一些线上的配置，并且实时被加载生效。

我将跟进一些源码，粗略的看下都发生了写什么。

入口：org.slf4j.impl.StaticLoggerBinder

void init() {
        try {
            try {　　　　　　　　　　//这里开始初始化配置
                (new ContextInitializer(this.defaultLoggerContext)).autoConfig();
            } catch (JoranException var2) {
                Util.report("Failed to auto configure default logger context", var2);
            }

            StatusPrinter.printInCaseOfErrorsOrWarnings(this.defaultLoggerContext);
            this.contextSelectorBinder.init(this.defaultLoggerContext, KEY);
            this.initialized = true;
        } catch (Throwable var3) {
            Util.report("Failed to instantiate [" + LoggerContext.class.getName() + "]", var3);
        }

    }

ch.qos.logback.classic.util.ContextInitializer：



public void autoConfig() throws JoranException {    StatusListenerConfigHelper.installIfAsked(this.loggerContext);


//加载配置文件，logback.groovy(有加载，无继续)---->logback-test.xml(有加载，无继续)------>logback.xml


    URL url = this.findURLOfDefaultConfigurationFile(true);    if(url != null) {　　　　//读取设置配置信息        this.configureByResource(url);    } else {      //找不到配置文件，设置默认        BasicConfigurator.configure(this.loggerContext);    }

}


//加载配置文件，logback.groovy(有加载，无继续)---->logback-test.xml(有加载，无继续)------>logback.xml//getResource()---->statusOnResourceSearch()----->multiplicityWarning()--->打印Resource [logback.xml] occurs multiple times on the classpath


public URL findURLOfDefaultConfigurationFile(boolean updateStatus) {    ClassLoader myClassLoader = Loader.getClassLoaderOfObject(this);    URL url = this.findConfigFileURLFromSystemProperties(myClassLoader, updateStatus);    if(url != null) {        return url;    } else {        url = this.getResource("logback.groovy", myClassLoader, updateStatus);        if(url != null) {            return url;        } else {            url = this.getResource("logback-test.xml", myClassLoader, updateStatus);            return url != null?url:this.getResource("logback.xml", myClassLoader, updateStatus);        }    }}


 


private URL getResource(String filename, ClassLoader myClassLoader, boolean updateStatus) {    URL url = Loader.getResource(filename, myClassLoader);    if(updateStatus) {        this.statusOnResourceSearch(filename, myClassLoader, url);    }

return url;}


private void statusOnResourceSearch(String resourceName, ClassLoader classLoader, URL url) {    StatusManager sm = this.loggerContext.getStatusManager();    if(url == null) {        sm.add(new InfoStatus("Could NOT find resource [" + resourceName + "]", this.loggerContext));    } else {        sm.add(new InfoStatus("Found resource [" + resourceName + "] at [" + url.toString() + "]", this.loggerContext));        this.multiplicityWarning(resourceName, classLoader);    }

}



private void multiplicityWarning(String resourceName, ClassLoader classLoader) {    Set urlSet = null;    StatusManager sm = this.loggerContext.getStatusManager();

try {        urlSet = Loader.getResourceOccurenceCount(resourceName, classLoader);    } catch (IOException var7) {        sm.add(new ErrorStatus("Failed to get url list for resource [" + resourceName + "]", this.loggerContext, var7));    }

if(urlSet != null && urlSet.size() > 1) {        sm.add(new WarnStatus("Resource [" + resourceName + "] occurs multiple times on the classpath.", this.loggerContext));        Iterator i$ = urlSet.iterator();

while(i$.hasNext()) {            URL url = (URL)i$.next();            sm.add(new WarnStatus("Resource [" + resourceName + "] occurs at [" + url.toString() + "]", this.loggerContext));        }    }

}


完整代码：


ch.qos.logback.classic.util.ContextInitializer：





//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package ch.qos.logback.classic.util;

import ch.qos.logback.classic.BasicConfigurator;
import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.gaffer.GafferUtil;
import ch.qos.logback.classic.joran.JoranConfigurator;
import ch.qos.logback.classic.util.EnvUtil;
import ch.qos.logback.classic.util.StatusListenerConfigHelper;
import ch.qos.logback.core.joran.spi.JoranException;
import ch.qos.logback.core.status.ErrorStatus;
import ch.qos.logback.core.status.InfoStatus;
import ch.qos.logback.core.status.StatusManager;
import ch.qos.logback.core.status.WarnStatus;
import ch.qos.logback.core.util.Loader;
import ch.qos.logback.core.util.OptionHelper;
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Iterator;
import java.util.Set;

public class ContextInitializer {
    public static final String GROOVY_AUTOCONFIG_FILE = "logback.groovy";
    public static final String AUTOCONFIG_FILE = "logback.xml";
    public static final String TEST_AUTOCONFIG_FILE = "logback-test.xml";
    public static final String CONFIG_FILE_PROPERTY = "logback.configurationFile";
    public static final String STATUS_LISTENER_CLASS = "logback.statusListenerClass";
    public static final String SYSOUT = "SYSOUT";
    final LoggerContext loggerContext;

    public ContextInitializer(LoggerContext loggerContext) {
        this.loggerContext = loggerContext;
    }

    public void configureByResource(URL url) throws JoranException {
        if(url == null) {
            throw new IllegalArgumentException("URL argument cannot be null");
        } else {
            if(url.toString().endsWith("groovy")) {
                if(EnvUtil.isGroovyAvailable()) {
                    GafferUtil.runGafferConfiguratorOn(this.loggerContext, this, url);
                } else {
                    StatusManager configurator = this.loggerContext.getStatusManager();
                    configurator.add(new ErrorStatus("Groovy classes are not available on the class path. ABORTING INITIALIZATION.", this.loggerContext));
                }
            }

            if(url.toString().endsWith("xml")) {
                JoranConfigurator configurator1 = new JoranConfigurator();
                configurator1.setContext(this.loggerContext);
                configurator1.doConfigure(url);
            }

        }
    }

    void joranConfigureByResource(URL url) throws JoranException {
        JoranConfigurator configurator = new JoranConfigurator();
        configurator.setContext(this.loggerContext);
        configurator.doConfigure(url);
    }

    private URL findConfigFileURLFromSystemProperties(ClassLoader classLoader, boolean updateStatus) {
        String logbackConfigFile = OptionHelper.getSystemProperty("logback.configurationFile");
        if(logbackConfigFile != null) {
            URL result = null;

            URL e1;
            try {
                result = new URL(logbackConfigFile);
                URL e = result;
                return e;
            } catch (MalformedURLException var13) {
                result = Loader.getResource(logbackConfigFile, classLoader);
                if(result != null) {
                    URL f1 = result;
                    return f1;
                }

                File f = new File(logbackConfigFile);
                if(!f.exists() || !f.isFile()) {
                    return null;
                }

                try {
                    result = f.toURI().toURL();
                    e1 = result;
                } catch (MalformedURLException var12) {
                    return null;
                }
            } finally {
                if(updateStatus) {
                    this.statusOnResourceSearch(logbackConfigFile, classLoader, result);
                }

            }

            return e1;
        } else {
            return null;
        }
    }

    public URL findURLOfDefaultConfigurationFile(boolean updateStatus) {
        ClassLoader myClassLoader = Loader.getClassLoaderOfObject(this);
        URL url = this.findConfigFileURLFromSystemProperties(myClassLoader, updateStatus);
        if(url != null) {
            return url;
        } else {
            url = this.getResource("logback.groovy", myClassLoader, updateStatus);
            if(url != null) {
                return url;
            } else {
                url = this.getResource("logback-test.xml", myClassLoader, updateStatus);
                return url != null?url:this.getResource("logback.xml", myClassLoader, updateStatus);
            }
        }
    }

    private URL getResource(String filename, ClassLoader myClassLoader, boolean updateStatus) {
        URL url = Loader.getResource(filename, myClassLoader);
        if(updateStatus) {
            this.statusOnResourceSearch(filename, myClassLoader, url);
        }

        return url;
    }

    public void autoConfig() throws JoranException {
        StatusListenerConfigHelper.installIfAsked(this.loggerContext);
        URL url = this.findURLOfDefaultConfigurationFile(true);
        if(url != null) {
            this.configureByResource(url);
        } else {
            BasicConfigurator.configure(this.loggerContext);
        }

    }

    private void multiplicityWarning(String resourceName, ClassLoader classLoader) {
        Set urlSet = null;
        StatusManager sm = this.loggerContext.getStatusManager();

        try {
            urlSet = Loader.getResourceOccurenceCount(resourceName, classLoader);
        } catch (IOException var7) {
            sm.add(new ErrorStatus("Failed to get url list for resource [" + resourceName + "]", this.loggerContext, var7));
        }

        if(urlSet != null && urlSet.size() > 1) {
            sm.add(new WarnStatus("Resource [" + resourceName + "] occurs multiple times on the classpath.", this.loggerContext));
            Iterator i$ = urlSet.iterator();

            while(i$.hasNext()) {
                URL url = (URL)i$.next();
                sm.add(new WarnStatus("Resource [" + resourceName + "] occurs at [" + url.toString() + "]", this.loggerContext));
            }
        }

    }

    private void statusOnResourceSearch(String resourceName, ClassLoader classLoader, URL url) {
        StatusManager sm = this.loggerContext.getStatusManager();
        if(url == null) {
            sm.add(new InfoStatus("Could NOT find resource [" + resourceName + "]", this.loggerContext));
        } else {
            sm.add(new InfoStatus("Found resource [" + resourceName + "] at [" + url.toString() + "]", this.loggerContext));
            this.multiplicityWarning(resourceName, classLoader);
        }

    }
}




ch.qos.logback.core.util.Loader：





//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package ch.qos.logback.core.util;

import ch.qos.logback.core.Context;
import ch.qos.logback.core.util.OptionHelper;
import java.io.IOException;
import java.net.URL;
import java.security.AccessControlException;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Set;

public class Loader {
    static final String TSTR = "Caught Exception while in Loader.getResource. This may be innocuous.";
    private static boolean ignoreTCL = false;
    public static final String IGNORE_TCL_PROPERTY_NAME = "logback.ignoreTCL";
    private static boolean HAS_GET_CLASS_LOADER_PERMISSION = false;

    public Loader() {
    }

    public static Set<URL> getResourceOccurenceCount(String resource, ClassLoader classLoader) throws IOException {
        HashSet urlSet = new HashSet();
        Enumeration urlEnum = classLoader.getResources(resource);

        while(urlEnum.hasMoreElements()) {
            URL url = (URL)urlEnum.nextElement();
            urlSet.add(url);
        }

        return urlSet;
    }

    public static URL getResource(String resource, ClassLoader classLoader) {
        try {
            return classLoader.getResource(resource);
        } catch (Throwable var3) {
            return null;
        }
    }

    public static URL getResourceBySelfClassLoader(String resource) {
        return getResource(resource, getClassLoaderOfClass(Loader.class));
    }

    public static ClassLoader getTCL() {
        return Thread.currentThread().getContextClassLoader();
    }

    public static Class loadClass(String clazz, Context context) throws ClassNotFoundException {
        ClassLoader cl = getClassLoaderOfObject(context);
        return cl.loadClass(clazz);
    }

    public static ClassLoader getClassLoaderOfObject(Object o) {
        if(o == null) {
            throw new NullPointerException("Argument cannot be null");
        } else {
            return getClassLoaderOfClass(o.getClass());
        }
    }

    public static ClassLoader getClassLoaderAsPrivileged(final Class clazz) {
        return !HAS_GET_CLASS_LOADER_PERMISSION?null:(ClassLoader)AccessController.doPrivileged(new PrivilegedAction() {
            public ClassLoader run() {
                return clazz.getClassLoader();
            }
        });
    }

    public static ClassLoader getClassLoaderOfClass(Class clazz) {
        ClassLoader cl = clazz.getClassLoader();
        return cl == null?ClassLoader.getSystemClassLoader():cl;
    }

    public static Class loadClass(String clazz) throws ClassNotFoundException {
        if(ignoreTCL) {
            return Class.forName(clazz);
        } else {
            try {
                return getTCL().loadClass(clazz);
            } catch (Throwable var2) {
                return Class.forName(clazz);
            }
        }
    }

    static {
        String ignoreTCLProp = OptionHelper.getSystemProperty("logback.ignoreTCL", (String)null);
        if(ignoreTCLProp != null) {
            ignoreTCL = OptionHelper.toBoolean(ignoreTCLProp, true);
        }

        HAS_GET_CLASS_LOADER_PERMISSION = ((Boolean)AccessController.doPrivileged(new PrivilegedAction() {
            public Boolean run() {
                try {
                    AccessController.checkPermission(new RuntimePermission("getClassLoader"));
                    return Boolean.valueOf(true);
                } catch (AccessControlException var2) {
                    return Boolean.valueOf(false);
                }
            }
        })).booleanValue();
    }
}




但是这个时候，如果有两个配置文件，以哪个文件为主呢？下篇解释。


参考：


http://stackoverflow.com/questions/18263139/how-do-i-suppress-a-inherited-projects-logback-xml-file-2-logback-xml-in-a-sing


http://stackoverflow.com/questions/3401051/suppress-all-logback-output-to-console


http://jira.qos.ch/browse/LOGBACK-337
				


				
时间： 2024-10-01 04:06:50 

		


		


	

	
	

		


		
项目存在多个logback配置的相关文章


								

		

			

                剖析项目多个logback配置(下)
			

		

		

									

				来源:http://www.cnblogs.com/guozp/p/5973038.html 上篇大概描述了logback的加载顺序以及加载的源码,本篇将分析如果在你的Maven或者其他多模块的项目中,每个模块都存在logback.xml的情况,项目会加载哪个为准. 这里简单的测试下,我的service模块下有个logback.xml,其他的模块下也有,但是输出目录不同,以此来观察. service模块: <?xml version="1.0" encoding="UT			

		

	

				

		

			

                gradle多项目构建、添加logback日志功能、以及相关配置
			

		

		

									

				项目模块化 1.所有项目使用java插件(这里以java为例,伙计们根据自己的项目决定) 在根项目的build.grdle中配置,子项目中的参数删除 allprojects {//对所有项目应用 apply plugin: 'java' sourceCompatibility = 1.8 } //特殊应用的模块在直接的build.gradle中声明即可 这里的配置是有顺序的allprojects必须在subprojects的上方(别问我为啥.说多了都是泪) 2.配置Web子项目打包成war 在w			

		

	

				

		

			

                Java程序员修炼之道 之 Logging(1/3) - Logback 配置
			

		

		

									

				写在前面的话: 作为<Java程序员修炼之道>博文的第一个主题Logging,我计划中按照如下三篇来写: Logback的简单介绍和配置 在Java代码中如何使用SLF4J来写日志以及写日志的要点 作为一个程序员,在日常工作中如何分析和挖掘Log. PS:默认生成的目录不对,仔细检查过了,我的h1,h2,h3,h4用的都没错. 1. 缘起 写代码中的日志是一个除了用代码实现功能之外最基础最基础的一个技能了,是一个必须掌握的技能.但是目前为止,关于如何日志的文章和书籍还是不多. 1.1 写日志的			

		

	

				

		

			

                SpringBoot(十) Logback 配置详解
			

		

		

									

				一.了解 简单地说,Logback 是一个 Java 领域的日志框架.它被认为是 Log4J 的继承人.Logback 主要由三个模块组成: logback-core logback-classic logback-access logback-core 是其它模块的基础设施,其它模块基于它构建,显然,logback-core 提供了一些关键的通用机制.logback-classic 的地位和作用等同于 Log4J,它也被认为是 Log4J 的一个改进版,并且它实现了简单日志门面 SLF4J:而			

		

	

				

		

			

                logback 配置详解（一）
			

		

		

									

				转自:logback 配置详解(一) 一:根节点<configuration>包含的属性: scan: 当此属性设置为true时,配置文件如果发生改变,将会被重新加载,默认值为true. scanPeriod: 设置监测配置文件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒.当scan为true时,此属性生效.默认的时间间隔为1分钟. debug: 当此属性设置为true时,将打印出logback内部日志信息,实时查看logback运行状态.默认值为false. 例如: Xml代码			

		

	

				

		

			

                logback配置
			

		

		

									

				import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class MyApp { final static Logger logger = LoggerFactory.getLogger("MyApp.class"); public static void main(String[] args) { logger.trace("trace"); logger.debug("debug			

		

	

				

		

			

                logback -- 配置详解 -- 三 -- &lt;encoder&gt;
			

		

		

									

				附: logback.xml实例 logback -- 配置详解 -- 一 -- <configuration>及子节点 logback -- 配置详解 -- 二 -- <appender> logback -- 配置详解 -- 三 -- <encoder> logback -- 配置详解 -- 四 -- <filter> -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --			

		

	

				

		

			

                logback 配置
			

		

		

									

				logback 配置 logback的配置方式包括:编程配置.XML文件配置.Groovy文件配置.对于使用log4j的用户,还可以通过logback提供的工具( http://logback.qos.ch/translator/ ) 将log4j.properties配置文件转换为logback.xml格式. logback 初始化配置的步骤如下: 在类路径下依次查找 logback.groovy, logback-test.xml, logback.xml文件: 若找到配置文件,则读取文件,			

		

	

				

		

			

                [转]解决web项目无法部署到eclipse配置的本地tomcat
			

		

		

									

				web项目无法部署到eclipse配置的本地tomcat 一.发现问题 在eclipse中新建Dynamic Web Project,配置好本地的tomcat并写好代码后选择Run on Server,但运行后发现在tomcat的安装目录下的webapps并没有出现所建立的工程名字. 二.验证 很明显项目并没有自动部署到Tomcat的Webapps中而是部署在了别的容器中.在内置浏览器中输入http://localhost:8080/webDemo/login.jsp可正常打开.但在外部浏览器上