文档章节

jdk-logging、log4j、logback日志介绍及原理

乒乓狂魔
 乒乓狂魔
发布于 2015/04/27 07:19
字数 3199
阅读 11942
收藏 429
点赞 47
评论 17

系列文章已完成,目录如下:

#1 需要解决的疑惑

目前的日志框架有jdk自带的logging,log4j1、log4j2、logback

目前用于实现日志统一的框架apache的commons-logging、slf4j

为了理清它们的关系,与繁杂的各种集成jar包,如下:

  • log4j、log4j-api、log4j-core
  • log4j-1.2-api、log4j-jcl、log4j-slf4j-impl、log4j-jul
  • logback-core、logback-classic、logback-access
  • commons-logging
  • slf4j-api、slf4j-log4j12、slf4j-simple、jcl-over-slf4j、slf4j-jdk14、log4j-over-slf4j、slf4j-jcl

分成3篇文章来阐述

  • jdk自带的logging、log4j1、log4j2、logback的使用与原理简述
  • slf4j、apache的commons-logging与上述日志框架的集成原理
  • slf4j目前与commons-logging混用的境况

#2 jdk自带的logging

##2.1 使用案例

private static final Logger logger=Logger.getLogger(JdkLoggingTest.class.getName());

public static void main(String[] args){
	logger.info("jdk logging info: a msg");
}

其中的Logger是:java.util.logging.Logger

##2.2 简单过程分析:

不想看源码的请略过

  • 创建一个LogManager

    默认是java.util.logging.LogManager,但是也可以自定义,修改系统属性"java.util.logging.manager"即可,源码如下(manager就是LogManager):

    try {
        cname = System.getProperty("java.util.logging.manager");
        if (cname != null) {
            try {
                Class clz = ClassLoader.getSystemClassLoader().loadClass(cname);
                manager = (LogManager) clz.newInstance();
            } catch (ClassNotFoundException ex) {
                Class clz = Thread.currentThread().getContextClassLoader().loadClass(cname);
                manager = (LogManager) clz.newInstance();
            }
        }
    } catch (Exception ex) {
        System.err.println("Could not load Logmanager \"" + cname + "\"");
        ex.printStackTrace();
    }
    if (manager == null) {
        manager = new LogManager();
    }
    
  • 加载配置文件

    默认是jre目录下的lib/logging.properties文件,也可以自定义修改系统属性"java.util.logging.config.file",源码如下:

    String fname = System.getProperty("java.util.logging.config.file");
    if (fname == null) {
        fname = System.getProperty("java.home");
        if (fname == null) {
            throw new Error("Can't find java.home ??");
        }
        File f = new File(fname, "lib");
        f = new File(f, "logging.properties");
        fname = f.getCanonicalPath();
    }
    InputStream in = new FileInputStream(fname);
    BufferedInputStream bin = new BufferedInputStream(in);
    try {
        readConfiguration(bin);
    }
    
  • 创建Logger,并缓存起来,放置到一个Hashtable中,并把LogManager设置进新创建的logger中

以tomcat为例,它就自定义了上述配置:

在tomcat的启动文件catalina.bat中,有如下设置:

  • 修改属性"java.util.logging.manager",自定义LogManager,使用自己的ClassLoaderLogManager

    if not "%LOGGING_MANAGER%" == "" goto noJuliManager
    set LOGGING_MANAGER=-Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager
    :noJuliManager
    set JAVA_OPTS=%JAVA_OPTS% %LOGGING_MANAGER%
    
  • 修改属性"java.util.logging.config.file",自定义配置文件,使用自己的%CATALINA_BASE%\conf\logging.properties文件

    if not "%LOGGING_CONFIG%" == "" goto noJuliConfig
    set LOGGING_CONFIG=-Dnop
    if not exist "%CATALINA_BASE%\conf\logging.properties" goto noJuliConfig
    set LOGGING_CONFIG=-Djava.util.logging.config.file="%CATALINA_BASE%\conf\logging.properties"
    :noJuliConfig
    set JAVA_OPTS=%JAVA_OPTS% %LOGGING_CONFIG%
    

所以如果想研究tomcat的日志,可以从上面入手。

jdk自带的logging不再详细介绍,有兴趣的参见这篇文章JDK Logging深入分析

#3 log4j1

##3.1 使用案例

###3.1.1 需要的jar包

  • log4j

maven依赖如下:

<dependency>
	<groupId>log4j</groupId>
	<artifactId>log4j</artifactId>
	<version>1.2.17</version>
</dependency>

###3.1.2 使用方式

  • 第一步:编写log4j.properties配置文件,放到类路径下

    log4j.rootLogger = debug, console
    log4j.appender.console = org.apache.log4j.ConsoleAppender
    log4j.appender.console.layout = org.apache.log4j.PatternLayout
    log4j.appender.console.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} %m%n
    

    配置文件的详细内容不是本博客关注的重点,不再说明,自行搜索

  • 第二步:代码中如下使用

    public class Log4jTest {
    	private static final Logger logger=Logger.getLogger(Log4jTest.class);
    	public static void main(String[] args){
    		if(logger.isTraceEnabled()){
    			logger.debug("log4j trace message");
    		}
    		if(logger.isDebugEnabled()){
    			logger.debug("log4j debug message");
    		}
    		if(logger.isInfoEnabled()){
    			logger.debug("log4j info message");
    		}
    	}
    }
    
  • 补充:

    • 1 上述方式默认到类路径下加载log4j.properties配置文件,如果log4j.properties配置文件不在类路径下,则可以选择如下方式之一来加载配置文件

      • 使用classLoader来加载资源

        PropertyConfigurator.configure(Log4jTest.class.getClassLoader().getResource("properties/log4j.properties"));

      • 使用log4j自带的Loader来加载资源

        PropertyConfigurator.configure(Loader.getResource("properties/log4j.properties"));

##3.2 获取Logger的原理

不想看源码的请略过

本博客的重点不在于讲解log4j的架构。只是简单的说明获取一个Logger的过程。分三种情况来说明:

  • 第一种情况:没有指定配置文件路径

    • 1 第一步: 引发LogManager的类初始化

      Logger.getLogger(Log4jTest.class)的源码如下:

      static public Logger getLogger(Class clazz) {
          return LogManager.getLogger(clazz.getName());
      }
      
    • 2 第二步:初始化一个logger仓库Hierarchy

      Hierarchy的源码如下:

      public class Hierarchy implements LoggerRepository, RendererSupport, ThrowableRendererSupport {
        	private LoggerFactory defaultFactory;
        	Hashtable ht;
        	Logger root;
      	//其他略
      }
      
      • LoggerFactory defaultFactory: 就是创建Logger的工厂
      • Hashtable ht:用来存放上述工厂创建的Logger
      • Logger root:作为根Logger

      LogManager在类初始化的时候如下方式来实例化Hierarchy:

      static {
      	Hierarchy h = new Hierarchy(new RootLogger((Level) Level.DEBUG));
      	//略
      }
      

      new RootLogger作为root logger,默认是debug级别

      最后把Hierarchy绑定到LogManager上,可以在任何地方来获取这个logger仓库Hierarchy

    • 3 第三步:在LogManager的类初始化的过程中默认寻找类路径下的配置文件

      通过org.apache.log4j.helpers.Loader类来加载类路径下的配置文件:

      Loader.getResource("log4j.xml");
      Loader.getResource("log4j.properties")
      

      优先选择xml配置文件

    • 4 第四步:解析上述配置文件

      • 如果是xml文件则org.apache.log4j.xml.DOMConfigurator类来解析
      • 如果是properties文件,则使用org.apache.log4j.PropertyConfigurator来解析

      不再详细说明解析过程,看下解析后的结果:

      • 设置RootLogger的级别
      • 对RootLogger添加一系列我们配置的appender(我们通过logger来输出日志,通过logger中的appender指明了日志的输出目的地)
    • 5 第五步:当一切都准备妥当后,就该获取Logger了

      使用logger仓库Hierarchy中内置的LoggerFactory工厂来创建Logger了,并缓存起来,同时将logger仓库Hierarchy设置进新创建的Logger中

  • 第二种情况,手动来加载不在类路径下的配置文件

    PropertyConfigurator.configure 执行时会去进行上述的配置文件解析,源码如下:

    public static void configure(java.net.URL configURL) {
    	 new PropertyConfigurator().doConfigure(configURL,
    	                    LogManager.getLoggerRepository());
    }
    
    • 仍然先会引发LogManager的类加载,创建出logger仓库Hierarchy,同时尝试加载类路径下的配置文件,此时没有则不进行解析,此时logger仓库Hierarchy中的RootLogger默认采用debug级别,没有appender而已。

    • 然后解析配置文件,对上述logger仓库Hierarchy的RootLogger进行级别的设置,添加appender

    • 此时再去调用Logger.getLogger,不会导致LogManager的类初始化(因为已经加载过了)

  • 第三种情况,配置文件在类路径下,而我们又手动使用PropertyConfigurator去加载

    也就会造成2次加载解析配置文件,仅仅会造成覆盖而已(对于RootLogger进行从新设置级别,删除原有的appender,重新加载新的appender),所以多次加载解析配置文件以最后一次为准。

##3.3 主要对象总结

  • LogManager: 它的类加载会创建logger仓库Hierarchy,并尝试寻找类路径下的配置文件,如果有则解析

  • Hierarchy : 包含三个重要属性:

    • LoggerFactory logger的创建工厂
    • Hashtable 用于存放上述工厂创建的logger
    • Logger root logger,用于承载解析文件的结果,设置级别,同时存放appender
  • PropertyConfigurator: 用于解析log4j.properties文件

  • Logger : 我们用来输出日志的对象

#4 log4j2

##4.1 背景介绍 log4j2与log4j1发生了很大的变化,不兼容。log4j1仅仅作为一个实际的日志框架,slf4j、commons-logging作为门面,统一各种日志框架的混乱格局,现在log4j2也想跳出来充当门面了,也想统一大家了。哎,日志格局越来越混乱了。

log4j2分成2个部分:

  • log4j-api: 作为日志接口层,用于统一底层日志系统
  • log4j-core : 作为上述日志接口的实现,是一个实际的日志框架

##4.2 log4j2的使用案例

###4.2.1 需要的jar包

  • log4j-api
  • log4j-core

对应的maven依赖是:

<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
    <version>2.2</version>
</dependency>
<dependency>
	<groupId>org.apache.logging.log4j</groupId>
	<artifactId>log4j-core</artifactId>
	<version>2.2</version>
</dependency>

###4.2.2 使用方式

  • 第一步:编写log4j2.xml配置文件(目前log4j2只支持xml json yuml,不再支持properties文件)

    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="WARN">
      <Appenders>
        <Console name="Console" target="SYSTEM_OUT">
          <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </Console>
      </Appenders>
      <Loggers>
        <Root level="debug">
          <AppenderRef ref="Console"/>
        </Root>
      </Loggers>
    </Configuration>
    
  • 第二步: 使用方式

    private static final Logger logger=LogManager.getLogger(Log4j2Test.class);
    
    public static void main(String[] args){
    	if(logger.isTraceEnabled()){
    		logger.debug("log4j trace message");
    	}
    	if(logger.isDebugEnabled()){
    		logger.debug("log4j debug message");
    	}
    	if(logger.isInfoEnabled()){
    		logger.debug("log4j info message");
    	}
    }
    

和log4j1是不同的。此时Logger是log4j-api中定义的接口,而log4j1中的Logger则是类

##4.3 使用过程简单分析

不想看源码的请略过

  • 获取底层使用的LoggerContextFactory:

    同样LogManager的类加载会去寻找log4j-api定义的LoggerContextFactory接口的底层实现,获取方式有三种:

    • 第一种: 尝试从jar中寻找log4j2.component.properties文件,如果配置了log4j2.loggerContextFactory则使用该LoggerContextFactory
    • 第二种:如果没找到,尝试从jar包中寻找META-INF/log4j-provider.properties文件,如log4j-core-2.2中就有该文件,如下图所示: log4j-core提供的LoggerContextFactory

    如果找到多个,取优先级最高的(该文件中指定了LoggerContextFactory,同时指定了优先级FactoryPriority),如log4j-core-2.2中log4j-provider.properties的文件内容如下:

    LoggerContextFactory = org.apache.logging.log4j.core.impl.Log4jContextFactory
    Log4jAPIVersion = 2.1.0
    FactoryPriority= 10
    
    • 第三种情况:上述方式还没找到,就使用默认的SimpleLoggerContextFactory
  • 使用LoggerContextFactory获取LoggerContext

  • 根据LoggerContext获取Logger

    以log4j-core为例:

    • 会首先判断LoggerContext是否被初始化过了,没有则进行初始化
    • 获取ConfigurationFactory,从配置中获取和插件中获取(log4j-core核心包中有三个YamlConfigurationFactory、JsonConfigurationFactory、XmlConfigurationFactory)
    • 以上文的案例中,会使用XmlConfigurationFactory来加载log4j2.xml配置文件
    • LoggerContext初始化后,就可以获取或者创建Logger了

##4.4 主要对象总结

  • LogManager: 它的类加载会去寻找LoggerContextFactory接口的底层实现,会从jar包中的配置文件中寻找,如上面所述

  • LoggerContextFactory : 用于创建LoggerContext,不同的日志实现系统会有不同的实现,如log4j-core中的实现为Log4jContextFactory

  • PropertyConfigurator: 用于解析log4j.properties文件

  • LoggerContext : 它包含了配置信息,并能创建log4j-api定义的Logger接口实例,并缓存这些实例

  • ConfigurationFactory:上述LoggerContext解析配置文件,需要用到ConfigurationFactory,目前有三个YamlConfigurationFactory、JsonConfigurationFactory、XmlConfigurationFactory,分别解析yuml json xml形式的配置文件

#5 logback

##5.1 使用案例

###5.1.1 需要的jar包

  • logback-core
  • logback-classic
  • slf4j-api

对应的maven依赖为:

<dependency> 
	<groupId>ch.qos.logback</groupId> 
	<artifactId>logback-core</artifactId> 
	<version>1.1.3</version> 
</dependency> 
<dependency> 
    <groupId>ch.qos.logback</groupId> 
    <artifactId>logback-classic</artifactId> 
    <version>1.1.3</version> 
</dependency>
<dependency>
	<groupId>org.slf4j</groupId>
	<artifactId>slf4j-api</artifactId>
	<version>1.7.12</version>
</dependency>

###5.1.2 使用方式

private static final Logger logger=LoggerFactory.getLogger(LogbackTest.class);

public static void main(String[] args){
	if(logger.isDebugEnabled()){
		logger.debug("slf4j-logback debug message");
	}
	if(logger.isInfoEnabled()){
		logger.debug("slf4j-logback info message");
	}
	if(logger.isTraceEnabled()){
		logger.debug("slf4j-logback trace message");
	}
	
	LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    StatusPrinter.print(lc);
}

补充:

  • 官方使用方式,其实就和slf4j集成了起来

    上述的Logger、LoggerFactory都是slf4j自己的接口与类

  • 没有配置文件的情况下,使用的是默认配置。搜寻配置文件的过程如下:

    1. Logback tries to find a file called logback.groovy in the classpath.
    1. If no such file is found, logback tries to find a file called logback-test.xml in the classpath.
    1. If no such file is found, it checks for the file logback.xml in the classpath..
    1. If no such file is found, and the executing JVM has the ServiceLoader (JDK 6 and above) the ServiceLoader will be used to resolve an implementation of com.qos.logback.classic.spi.Configurator. The first implementation found will be used. See ServiceLoader documentation for more details.
    1. If none of the above succeeds, logback configures itself automatically using the BasicConfigurator which will cause logging output to be directed to the console.

    The fourth and last step is meant to provide a default (but very basic) logging functionality in the absence of a configuration file.

也可以在类路径下加上一个类似如下的logback.xml的配置文件,如下:

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
  </appender>

  <root level="DEBUG">          
    <appender-ref ref="STDOUT" />
  </root>  
  
</configuration>

logback则会去解析对应的配置文件。

##5.3 使用过程简单分析

不想看源码的请略过

  • slf4j与底层的日志系统进行绑定

    在jar包中寻找org/slf4j/impl/StaticLoggerBinder.class 这个类,如在logback-classic中就含有这个类,如下图所示 logback与slf4j集成

    如果找到多个StaticLoggerBinder,则表明目前底层有多个实际的日志框架,slf4j会随机选择一个

  • 使用上述找到的StaticLoggerBinder创建一个实例,并返回一个ILoggerFactory实例:

    return StaticLoggerBinder.getSingleton().getLoggerFactory();
    

    以logback-classic中的StaticLoggerBinder为例,在StaticLoggerBinder.getSingleton()过程中:会去加载解析配置文件 源码如下:

    public URL findURLOfDefaultConfigurationFile(boolean updateStatus) {
        ClassLoader myClassLoader = Loader.getClassLoaderOfObject(this);
    	//寻找logback.configurationFile的系统属性
        URL url = findConfigFileURLFromSystemProperties(myClassLoader, updateStatus);
        if (url != null) {
          return url;
        }
    	//寻找logback.groovy
        url = getResource(GROOVY_AUTOCONFIG_FILE, myClassLoader, updateStatus);
        if (url != null) {
          return url;
        }
    	//寻找logback-test.xml
        url = getResource(TEST_AUTOCONFIG_FILE, myClassLoader, updateStatus);
        if (url != null) {
          return url;
        }
    	//寻找logback.xml
        return getResource(AUTOCONFIG_FILE, myClassLoader, updateStatus);
    }
    

    目前路径都是定死的,只有logback.configurationFile的系统属性是可以更改的,所以如果我们想更改配置文件的位置(不想放在类路径下),则需要设置这个系统属性:

     System.setProperty("logback.configurationFile", "/path/to/config.xml");
    

    解析完配置文件后,返回的ILoggerFactory实例的类型是LoggerContext(它包含了配置信息)

  • 根据返回的ILoggerFactory实例,来获取Logger

    就是根据上述的LoggerContext来创建一个Logger,每个logger与LoggerContext建立了关系,并放到LoggerContext的缓存中,就是LoggerContext的如下属性:

    private Map<String, Logger> loggerCache;
    

其实上述过程就是slf4j与其他日志系统的绑定过程。不同的日志系统与slf4j集成,都会有一个StaticLoggerBinder类,并会拥有一个ILoggerFactory的实现。

#6未完待续

这一篇文章简单介绍了几种日志的简单用法,下一篇文章就来介绍他们与commons-logging和slf4j怎么集成起来,就是要弄清楚各种集成jar包做了哪些事情

欢迎关注微信公众号:乒乓狂魔

微信公众号

© 著作权归作者所有

共有 人打赏支持
乒乓狂魔
粉丝 971
博文 105
码字总数 271356
作品 0
长宁
程序员
加载中

评论(17)

jiangxinnju
jiangxinnju
Apache Extras(http://logging.apache.org/log4j/extras/)这个包也可以介绍一下,很多人有困扰,哈哈
乒乓狂魔
乒乓狂魔

引用来自“weathernowrong”的评论

引用来自“dmcpxy”的评论

整理的不错

那个→_→ 一直不知道这些个jar包的关系。。似乎有的只是api有的是实现,还有就是不清楚为何最后要结合起来 虽然我知道自己去搜可以搜到相应的资料。不过我觉得博主从这个方面再讲讲可以这个教科书式的文章最后还是谢谢博主了,
对于为何要结合起来:因为日志框架很多,第三方jar包各选择各的日志系统,造成同一个系统中会存在多种日志系统,现在就需要将这些统一起来,就有了commons-logging、slf4j与日志框架结合起来的故事
乒乓狂魔
乒乓狂魔

引用来自“weathernowrong”的评论

引用来自“dmcpxy”的评论

整理的不错

那个→_→ 一直不知道这些个jar包的关系。。似乎有的只是api有的是实现,还有就是不清楚为何最后要结合起来 虽然我知道自己去搜可以搜到相应的资料。不过我觉得博主从这个方面再讲讲可以这个教科书式的文章最后还是谢谢博主了,
目前思路是这样的,先介绍原生的使用方法(第一篇),然后介绍commons-logging与上述日志框架的集成(第二篇 今天已发布了见 http://my.oschina.net/pingpangkuangmo/blog/407895 ),然后介绍slf4j与上述日志框架的集成(第三篇),commons-logging与slf4j与日志系统的混战,以及总结各种jar包的作用(第四篇)
weathernowrong
weathernowrong

引用来自“dmcpxy”的评论

整理的不错

点错了→_→
weathernowrong
weathernowrong

引用来自“dmcpxy”的评论

整理的不错

那个→_→ 一直不知道这些个jar包的关系。。似乎有的只是api有的是实现,还有就是不清楚为何最后要结合起来 虽然我知道自己去搜可以搜到相应的资料。不过我觉得博主从这个方面再讲讲可以这个教科书式的文章最后还是谢谢博主了,
jkguowen
jkguowen
mark,写的很好,思路清晰,关注下一篇
Dupeng_
Dupeng_

引用来自“calvinwilliams”的评论

iLOG3 - 纯C日志函数库/日志处理框架 ^_^
LOG -> LOGS -> LOGCONF -> LOGSCONF -> LOGSCONF(SML)
iLOG3支持JAVA吗?
jiucheng
jiucheng
很好,收藏了
乒乓狂魔
乒乓狂魔

引用来自“泥沙砖瓦浆木匠”的评论

携程 上海总部??
是的,淞虹路那的总部
泥沙砖瓦浆木匠
泥沙砖瓦浆木匠
携程 上海总部??
Java混乱的日志体系(logback)(转)

作为一名 Java 程序员,日常开发工作中肯定会接触日志系统,但是众多的框架,包括 Log4j、Log4j2、Logback、Slf4j、Apache Common logging 等等,引用的 maven 依赖众多,到底可以去掉哪些,...

easonjim ⋅ 2017/12/27 ⋅ 0

spring boot保存|打印日志-logback的配置和使用

【转载】(https://www.cnblogs.com/winner-0715/p/6105519.html) 1.logback介绍 logback是由log4j创始人设计的又一个开源日志组件。logback当前分成三个模块:logback-core,logback-classic和...

qq_25652949 ⋅ 04/24 ⋅ 0

Java日志框架-logback的介绍及配置使用方法(纯Java工程)(转)

说明:内容估计有些旧,2011年的,但是大体意思应该没多大变化,最新的配置可以参考官方文档。 一、logback的介绍 Logback是由log4j创始人设计的又一个开源日志组件。logback当前分成三个模块...

easonjim ⋅ 2017/11/07 ⋅ 0

你不知道的System.out.println()

这篇博客是为了解释System.out.println是什么以及它的工作原理。 什么是System.out.println() System.out.println是一个Java语句,一般情况下是将传递的参数,打印到控制台。 System - 是 ...

为了美好的明天 ⋅ 2017/09/16 ⋅ 1

Log4j 2.0在开发中的高级使用详解

log4j与slf4j、logback比较 而log4j slf4j logback就是目前主流的日志框架。但后两者效率高是第一个。推荐使用:slf4j 或者 logback(spring-boot默认日志实现) log4j是apache实现的一个开源日...

spinachgit ⋅ 04/22 ⋅ 0

SpringBoot笔记(六)日志

SpringBoot默认使用作为日志记录。 同时也对包的和做了默认配置 默认配置 Spring Boot默认使用Logback来记录日志,并用INFO级别输出到控制台 默认输出元素: 时间日期:精确到毫秒 日志级别:...

世外大帝 ⋅ 04/25 ⋅ 0

Spring Boot中Starter是什么

比如我们要在Spring Boot中引入Web MVC的支持时,我们通常会引入这个模块spring-boot-starter-web,而这个模块如果解压包出来会发现里面什么都没有,只定义了一些POM依赖。 经过研究,Start...

easonjim ⋅ 2017/09/30 ⋅ 0

java 日志框架——log4j

Log4J是JAVA下的一款日志组件 下载: http://logging.apache.org/log4j/2.x/download.html 下面的示例我使用最新版本2.7无法正常运行,最新版本使用方法可能不同。本文示例使用log4j-1.2.15测...

xundh ⋅ 05/09 ⋅ 0

SLF4J: Multiple bindings were found on the class path

众所周知,SLF4J是一个日志门面框架,它的作用是用于定义统一的日志接口,而具体的日志实现是由各个日志框架实现的,比如log4j,logback等。 问题 在使用SLF4J时,当class path同时包含了多个...

勇敢的飞石 ⋅ 05/17 ⋅ 0

slf4j 是怎么绑定具体的日志框架的

SLF4J 英文全称是 Simple Logging Facade for Java, 是一个门面(外观)接口或者说各种日志框架的抽象,比如 java.util.logging, logback, log4j 等;使用这货,我们可以不用关心具体的实现...

holysu ⋅ 05/13 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

使用 vue-cli 搭建项目

vue-cli 是一个官方发布 vue.js 项目脚手架,使用 vue-cli 可以快速创建 vue 项目,GitHub地址是:https://github.com/vuejs/vue-cli 一、 安装 node.js 首先需要安装node环境,可以直接到中...

初学者的优化 ⋅ 21分钟前 ⋅ 0

设计模式 之 享元模式

设计模式 之 享元模式 定义 使用共享技术来有效地支持大量细粒度对象的复用 关键点:防止类多次创建,造成内存溢出; 使用享元模式来将内部状态与外部状态进行分离,在循环创建对象的环境下,...

GMarshal ⋅ 36分钟前 ⋅ 0

SpringBoot集成Druid的最简单的小示例

参考网页 https://blog.csdn.net/king_is_everyone/article/details/53098350 建立maven工程 Pom文件 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM......

karma123 ⋅ 今天 ⋅ 0

Java虚拟机基本结构的简单记忆

Java堆:一般是放置实例化的对象的地方,堆分新生代和老年代空间,不断未被回收的对象越老,被放入老年代空间。分配最大堆空间:-Xmx 分配初始堆空间:-Xms,分配新生代空间:-Xmn,新生代的大小一...

算法之名 ⋅ 今天 ⋅ 0

OSChina 周日乱弹 —— 这么好的姑娘都不要了啊

Osc乱弹歌单(2018)请戳(这里) 【今日歌曲】 @TigaPile :分享曾惜的单曲《讲真的》 《讲真的》- 曾惜 手机党少年们想听歌,请使劲儿戳(这里) @首席搬砖工程师 :怎样约女孩子出来吃饭,...

小小编辑 ⋅ 今天 ⋅ 8

Jenkins实践3 之脚本

#!/bin/sh# export PROJ_PATH=项目路径# export TOMCAT_PATH=tomcat路径killTomcat(){pid=`ps -ef | grep tomcat | grep java|awk '{print $2}'`echo "tom...

晨猫 ⋅ 今天 ⋅ 0

Spring Bean的生命周期

前言 Spring Bean 的生命周期在整个 Spring 中占有很重要的位置,掌握这些可以加深对 Spring 的理解。 首先看下生命周期图: 再谈生命周期之前有一点需要先明确: Spring 只帮我们管理单例模...

素雷 ⋅ 今天 ⋅ 0

zblog2.3版本的asp系统是否可以超越卢松松博客的流量[图]

最近访问zblog官网,发现zlbog-asp2.3版本已经进入测试阶段了,虽然正式版还没有发布,想必也不久了。那么作为aps纵横江湖十多年的今天,blog2.2版本应该已经成熟了,为什么还要发布这个2.3...

原创小博客 ⋅ 今天 ⋅ 0

聊聊spring cloud的HystrixCircuitBreakerConfiguration

序 本文主要研究一下spring cloud的HystrixCircuitBreakerConfiguration HystrixCircuitBreakerConfiguration spring-cloud-netflix-core-2.0.0.RELEASE-sources.jar!/org/springframework/......

go4it ⋅ 今天 ⋅ 0

二分查找

二分查找,也称折半查找、二分搜索,是一种在有序数组中查找某一特定元素的搜索算法。搜素过程从数组的中间元素开始,如果中间元素正好是要查找的元素,则搜素过程结束;如果某一特定元素大于...

人觉非常君 ⋅ 今天 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部