posts - 3,&
comments - 4,&
trackbacks - 0
common-loggingcommon-logging是apache提供的一个通用的日志接口。用户可以自由选择第三方的日志组件作为具体实现，像log4j，或者jdk自带的logging， common-logging会通过动态查找的机制，在程序运行时自动找出真正使用的日志库。当然，common-logging内部有一个Simple logger的简单实现，但是功能很弱。所以使用common-logging，通常都是配合着log4j来使用。使用它的好处就是，代码依赖是common-logging而非log4j， 避免了和具体的日志方案直接耦合，在有必要时，可以更改日志实现的第三方库。使用common-logging的常见代码：[java]&import&mons.logging.L&&import&mons.logging.LogF&&&&public&class&A&{&&&&&&private&static&Log&logger&=&LogFactory.getLog(this.getClass());&&}&&动态查找原理：Log 是一个接口声明。LogFactory 的内部会去装载具体的日志系统，并获得实现该Log 接口的实现类。LogFactory 内部装载日志系统的流程如下：首先，寻找mons.logging.LogFactory 属性配置。否则，利用JDK1.3 开始提供的service 发现机制，会扫描classpah 下的META-INF/services/mons.logging.LogFactory文件，若找到则装载里面的配置，使用里面的配置。否则，从Classpath 里寻找commons-logging.properties ，找到则根据里面的配置加载。否则，使用默认的配置：如果能找到Log4j 则默认使用log4j 实现，如果没有则使用JDK14Logger 实现，再没有则使用commons-logging 内部提供的SimpleLog 实现。从上述加载流程来看，只要引入了log4j 并在classpath 配置了log4j.xml ，则commons-logging 就会使log4j 使用正常，而代码里不需要依赖任何log4j 的代码。slf4jslf4j全称为Simple Logging Facade for JAVA，java简单日志门面。类似于Apache Common-Logging，是对不同日志框架提供的一个门面封装，可以在部署的时候不修改任何配置即可接入一种日志实现方案。但是，他在编译时静态绑定真正的Log库。使用SLF4J时，如果你需要使用某一种日志实现，那么你必须选择正确的SLF4J的jar包的集合（各种桥接包）。使用slf4j的常见代码：[java]&import&org.slf4j.L&&import&org.slf4j.LoggerF&&&&public&class&A&{&&&&&&private&static&Log&logger&=&LogFactory.getLog(this.getClass());&&}&&slf4j静态绑定原理：SLF4J 会在编译时会绑定import org.slf4j.impl.StaticLoggerB 该类里面实现对具体日志方案的绑定接入。任何一种基于slf4j 的实现都要有一个这个类。如：org.slf4j.slf4j-log4j12-1.5.6: 提供对 log4j 的一种适配实现。注意：如果有任意两个实现slf4j 的包同时出现，那么就可能出现问题。slf4j 与 common-logging 比较common-logging通过动态查找的机制，在程序运行时自动找出真正使用的日志库。由于它使用了ClassLoader寻找和载入底层的日志库， 导致了象OSGI这样的框架无法正常工作，因为OSGI的不同的插件使用自己的ClassLoader。 OSGI的这种机制保证了插件互相独立，然而却使Apache Common-Logging无法工作。slf4j在编译时静态绑定真正的Log库,因此可以再OSGI中使用。另外，SLF4J 支持参数化的log字符串，避免了之前为了减少字符串拼接的性能损耗而不得不写的if(logger.isDebugEnable())，现在你可以直接写：logger.debug(“current user is: {}”, user)。拼装消息被推迟到了它能够确定是不是要显示这条消息的时候，但是获取参数的代价并没有幸免。Log4jApache的一个开放源代码项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件、甚至是套接口服务 器、NT的事件记录器、UNIX Syslog守护进程等；用户也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，用户能够更加细致地控制日志的生成过程。这些可以通过一个 配置文件来灵活地进行配置，而不需要修改程序代码。LogBackLogback是由log4j创始人设计的又一个开源日记组件。logback当前分成三个模块：logback-core,logback- classic和logback-access。logback-core是其它两个模块的基础模块。logback-classic是log4j的一个 改良版本。此外logback-classic完整实现SLF4J API使你可以很方便地更换成其它日记系统如log4j或JDK14 Logging。logback-access访问模块与Servlet容器集成提供通过Http来访问日记的功能。&Log4j 与 LogBack 比较LogBack作为一个通用可靠、快速灵活的日志框架，将作为Log4j的替代和SLF4J组成新的日志系统的完整实现。LOGBack声称具有极佳的性能，“ 某些关键操作，比如判定是否记录一条日志语句的操作，其性能得到了显著的提高。这个操作在LogBack中需要3纳秒，而在Log4J中则需要30纳秒。 LogBack创建记录器（logger）的速度也更快：13微秒，而在Log4J中需要23微秒。更重要的是，它获取已存在的记录器只需94纳秒，而 Log4J需要2234纳秒，时间减少到了1/23。跟JUL相比的性能提高也是显著的”。 另外，LOGBack的所有文档是全面免费提供的，不象Log4J那样只提供部分免费文档而需要用户去购买付费文档。&slf4j与其他各种日志组件的桥接应用代码中使用slf4j接口，接入具体实现的方法应用代码中使用别的日志接口，转成slf4j的方法日志组件相关历史Java 界里有许多实现日志功能的工具，最早得到广泛使用的是 log4j，许多应用程序的日志部分都交给了 log4j，不过作为组件开发者，他们希望自己的组件不要紧紧依赖某一个工具，毕竟在同一个时候还有很多其他很多日志工具，假如一个应用程序用到了两个组件，恰好两个组件使用不同的日志工具，那么应用程序就会有两份日志输出了。为了解决这个问题，Apache Commons Logging （之前叫 Jakarta Commons Logging，JCL）粉墨登场，JCL 只提供 log 接口，具体的实现则在运行时动态寻找。这样一来组件开发者只需要针对 JCL 接口开发，而调用组件的应用程序则可以在运行时搭配自己喜好的日志实践工具。所以即使到现在你仍会看到很多程序应用 JCL + log4j 这种搭配，不过当程序规模越来越庞大时，JCL的动态绑定并不是总能成功，具体原因大家可以 Google 一下，这里就不再赘述了。解决方法之一就是在程序部署时静态绑定指定的日志工具，这就是 SLF4J 产生的原因。跟 JCL 一样，SLF4J 也是只提供 log 接口，具体的实现是在打包应用程序时所放入的绑定器（名字为 slf4j-XXX-version.jar）来决定，XXX 可以是 log4j12, jdk14, jcl, nop 等，他们实现了跟具体日志工具（比如 log4j）的绑定及代理工作。举个例子：如果一个程序希望用 log4j 日志工具，那么程序只需针对 slf4j-api 接口编程，然后在打包时再放入 slf4j-log4j12-version.jar 和 log4j.jar 就可以了。现在还有一个问题，假如你正在开发应用程序所调用的组件当中已经使用了 JCL 的，还有一些组建可能直接调用了 java.util.logging，这时你需要一个桥接器（名字为 XXX-over-slf4j.jar）把他们的日志输出重定向到 SLF4J，所谓的桥接器就是一个假的日志实现工具，比如当你把 jcl-over-slf4j.jar 放到 CLASS_PATH 时，即使某个组件原本是通过 JCL 输出日志的，现在却会被 jcl-over-slf4j “骗到”SLF4J 里，然后 SLF4J 又会根据绑定器把日志交给具体的日志实现工具。过程如下Component|| log to Apache Commons LoggingVjcl-over-slf4j.jar --- (redirect) ---& SLF4j ---& slf4j-log4j12-version.jar ---& log4j.jar ---& 输出日志看到上面的流程图可能会发现一个有趣的问题，假如在 CLASS_PATH 里同时放置 log4j-over-slf4j.jar 和 slf4j-log4j12-version.jar 会发生什么情况呢？没错，日志会被踢来踢去，最终进入死循环。所以使用 SLF4J 的比较典型搭配就是把 slf4j-api、JCL 桥接器、java.util.logging（JUL）桥接器、log4j 绑定器、log4j 这5个 jar 放置在 CLASS_PATH 里。不过并不是所有APP容器都是使用 log4j 的，比如 Google AppEngine 它使用的是 java.util.logging（JUL），这时应用 SLF4J 的搭配就变成 slf4j-api、JCL桥接器、logj4桥接器、JUL绑定器这4个 jar 放置在 WEB-INF/lib 里。
阅读(12153)
java日志组件介绍（common-logging，log4j，slf4j，logback ）
关于Java 日志最好的介绍。转载过去。&&&&&&
java日志组件介绍（common-logging，log4j，slf4j，logback ）
lihai ,拿走&&&&&&
java日志组件介绍（common-logging，log4j，slf4j，logback ）
赞一个，详细代码示例可参考这个：&&&&&&
java日志组件介绍（common-logging，log4j，slf4j，logback ）
很清晰，谢谢。&&&&&&
3031123456789101112141516171819202122232425262728293012345678910
阅读排行榜
评论排行榜用SLF4j/Logback打印日志-1 - 简书
用SLF4j/Logback打印日志-1
中已经写了很多日志方面的零散的非技术的东西。本篇更像一份入门说明，讲解一下SLF4j/Logback。SLF4J是一套抽象的日志API接口，logback它是的底层实现，所以在这里的大部分代码中，看到的API都是
提供的，但是日志系统的配置还是按照
在后端logger系统中，有三个最基础的概念需要先熟悉：
Logger 日志记录器 - 日志记录器就是一个普通的Java类而已
logger.debug("Hello world.Debug");
这里面的logger就是日志记录器，每个日志记录器都可以独立的配置属性。
Appender 输出源 - 输出源是日志最终输出的地方，比如控制台或者文件
Layout(Encoder) 布局 - 布局决定了日志的打印格式，比如使用 %r [%t] %-5p %c %x - %m%n可以打印出 467 [main] INFO org.apache.log4j.examples.Sort - Exiting main method.这样的日志。
这在后面会有更详细的介绍，接下来先看一个HelloWorld - 感受一下logback的魅力。
HelloWorld
入门很重要，这里还是采用IntelJ+Gradle的编程环境，按步骤来：
创建目录，这是一个非常简单的Java工程，仅有一个App.java 类?
logback-test tree .
├── build.gradle
└── src
└── main
├── java
└── com
└── hello
└── App.java
配置build.gradle文件，这里仅添加了对 logback 的依赖，logback还会依赖 slf4j, Gradle会帮我们解决这些间接依赖的问题。
group 'com.hello'
version '1.0-SNAPSHOT'
apply plugin: 'java'
repositories {
mavenCentral()
dependencies {
compile 'ch.qos.logback:logback-core:1.1.+'
compile 'ch.qos.logback:logback-classic:1.1.+'
实现 App.java 并右键运行
// App.java:
package com.
import org.slf4j.L
import org.slf4j.LoggerF
public class App {
private static final Logger logger = LoggerFactory.getLogger(App.class);
public static void main(String[] args) {
logger.debug("Hello world.");
// 控制台打印的结果
Console:10:35:22.504 [main] DEBUG com.hello.App - Hello world.
这个例子没有太多值得关注的地方，我们仅仅调用了一个方法 logger.debug("Hello world."); 打印了一条日志。但是注意到打印出来的日志格式是这样的：
Console:10:35:22.504 [main] DEBUG com.hello.App - Hello world.
除了我们要打印的信息“Hello world”之外，多了很多信息，比如 Console、时间戳、DEBUG符号，类名等。这些信息是在日志打印的时候logback默认加上去的，可以通过配置文件来修改这些信息。
默认情况下logback会在classpath下寻找名为logback.xml的配置文件（还有另外4种查找配置文件的方式，见）如果没有找到任何配置文件，会使用 BasicConfigurator 初始化一个默认配置，它会把结果打印到控制台，这就是上面“HelloWorld”示例的情况。为了让logback可以加载到配置文件，需要在 src/main/resources/ 目录下创建文件 logback.xml（Gradle会自动把 resources 目录下的文件放到classpath目录）。
logback.xml文件的内容为：
&configuration&
&appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"&
&!-- encoders are assigned the type
ch.qos.logback.classic.encoder.PatternLayoutEncoder by default --&
&pattern&%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n&/pattern&
&/encoder&
&/appender&
&root level="debug"&
&appender-ref ref="STDOUT" /&
&/configuration&
这是和默认配置等效的一条配置。
日志记录器 - logger
在上面的 “HelloWorld” 示例中，我们通过 Logger logger = LoggerFactory.getLogger(App.class); 工厂方法获得了一个日志记录器。并通过 logger.debug("Hello world."); 方法打印了一条信息，但是如果我们通过 < 方法是打印不出来的，原因是什么呢？
在logback中日志记录器是继承的，继承的规则是 com.hello.foo 会继承 com.hello 的日志配置，父子关系通过 . 来分割，所以 com 是 com.hello 的父节点。在logback中默认会有一个 root-logger（根 - 日志记录器）的存在，所有的其他日志记录器都会默认继承它的配置。在配置文件中看到的:
&root level="debug"&
&appender-ref ref="STDOUT" /&
就是“根”。所以当我们调用 Logger logger = LoggerFactory.getLogger(App.class); 的时候，默认是从 root-logger 那里继承了日志输出配置，而 root-logger 默认的log打印级别是 debug，所以用 < 打印不出日志。
那么如何配置一个普通的日志记录器呢？这是非常简单的：
&logger name="com.hello" level="INFO"/&
这样便配置了一个名为 com.hello 的日志记录器（一般会用包名作为日志记录器的名字），name 是必须配置的属性。然后可以通过 Logger logger = LoggerFactory.getLogger("com.hello") 来得到这个日志记录器。
下面的三种写法是等效的：
1. Logger logger = LoggerFactory.getLogger(App.class)
2. Logger logger = LoggerFactory.getLogger(App.class.getName())
3. Logger logger = LoggerFactory.getLogger("com.hello.App")
日志输出源 - Appenders
在上面的配置文件中其实已经见识到了日志输出源的配置：
&appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"&
&pattern&%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n&/pattern&
&/encoder&
&/appender&
这个输出源配置把日志打印到控制台，格式为 %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n，输出源的 name 和 class 属性是必须配置的选项。比如还可以配置把日志打印到文件：
&appender name="FILE" class="ch.qos.logback.core.FileAppender"&
&file&myApp.log&/file&
&pattern&%date %level [%thread] %logger{10} [%file:%line] %msg%n&/pattern&
&/encoder&
&/appender&
有了输出源之后，就可以给logger配置输出源，一个logger可以配置多个输出源：
&root level="debug"&
&appender-ref ref="STDOUT" /&
&appender-ref ref="FILE" /&
这里给root-logger配置了两个输出源，此时如果我们调用 logger.debug方法会发现控制台和根目录下的myApp.log文件都打印了相同的日志。在上面的“HelloWorld”工程中，我们这样配置logback.xml文件:
&configuration&
&appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"&
&!-- encoders are assigned the type
ch.qos.logback.classic.encoder.PatternLayoutEncoder by default --&
&pattern&%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n&/pattern&
&/encoder&
&/appender&
&appender name="file" class="ch.qos.logback.core.FileAppender"&
&file&log/demo.file.log&/file&
&pattern&%date %level [%thread] %logger{10} [%file:%line] %msg%n&/pattern&
&/encoder&
&/appender&
&logger name="com.hello" level="INFO"&&/logger&
&root level="debug"&
&appender-ref ref="STDOUT" /&
&appender-ref ref="file" /&
&/configuration&
再次操作会在工程根目录的 log/demo.file.log 文件中打印
11:38:06,068 INFO [main] c.h.App [App.java:11]
在控制台会打印：
11:38:06.068 [main] INFO
com.hello.App -
在这里创建了两个输出源，一个基于文件的输出源 &appender name="file" class="ch.qos.logback.core.FileAppender"& 并配置了文件路径和日志输出格式。另一个是基于控制台的输出源 &appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"&然后在 root-logger 下面添加了这个输出源，所以这条日志会在文件和控制台各打印一份（注意因为配置的格式不同，打印出来的结果也略有不同）。
在logback中，level的配置会被继承，但是appender的配置会被子logger保留。这么说有点抽象，看下面的例子：
&configuration&
&appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"&
&pattern&%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n&/pattern&
&/encoder&
&/appender&
&logger name="com.hello"&
&appender-ref ref="STDOUT" /&
&root level="debug"&
&appender-ref ref="STDOUT" /&
&/configuration&
这个配置会导致控制台打印两次：
11:38:06.068 [main] INFO
com.hello.App -
11:38:06.068 [main] INFO
com.hello.App -
当调用 LoggerFactory.getLogger("com.hello.App") 的时候，它继承了来自 &logger name="com.hello"& 和 root-logger 的输出源，而他们的输出源都是控制台，所以导致在控制台输出了两次。解决办法是，要么在有继承关系的logger中配置不同的输出源（从业务上避免），要么在子logger中覆盖父节点中的配置。可以通过 additivity="false" 配置实现：
&logger name="com.hello" additivity="false"&
&appender-ref ref="STDOUT" /&
additivity 属性告诉logback不要继承来自父类的设置。
布局 - Layout 和 编码 - Encoder
Layouts are logback components responsible for transforming an incoming event into a String.
Layout主要用来把log事件转换成String。一般布局都是配置在 Appender 里面的：
&appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender"&
&layout class="org.apache.log4j.PatternLayout"&
&param name="ConversionPattern" value="%d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n" /&
&/appender&
注意，上面的示例使用的Appender是org.apache.log4j.ConsoleAppender ，这是log4j的配置而不是这里讲的logback，这是因为在过去日志系统确实都是使用Layout来做日志转换的，但是由于一些
，logback在Layout上面又封装了一层 - Encoder，表现在配置上就是这样的（这才是logback的配置）：
&appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"&
&pattern&%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n&/pattern&
&/encoder&
&/appender&
但是Encoder的出现并不影响我们的配置，只是在形式上多了一个&encoder/&标签。一般使用最多的是 PatternLayout 或 PatternLayouEncoder ，他们的特点是提供了很多约定的标记，这些标记都以 % 开头，比如logger名称、日志等级日期、线程名等。比如：%level [%thread]: %message%n可以打印出日志等级，线程名字和日志本身。
Layouts, as discussed in detail in the next chapter, are only able to transform an event into a String. Moreover, given that a layout has no control over when events get written out, layouts cannot aggregate events into batches. Contrast this with encoders which not only have total control over the format of the bytes written out, but also control when (and if) those bytes get written out.
事实上我们在使用logback的时候很少见到直接使用layout，这是因为layout只能把一条log事件转化成String，layout不能控制log什么时候被写入文件，也不能做到批量处理。Encoder是被发明出来解决这些问题的。目前为止Encoders只有一个实现 - PatternLayoutEncoder，它内部包含了一个PatternLayout，所以可以像使用PatternLayout一样使用Encoder。
至此已经粗略介绍完Logback的三个最重要的部分，下面会记录一些常用且比较重要的配置属性
有一个最重要的配置 - TimeBasedRollingPolicy 策略配置限于限于篇幅只能转移到下一篇了。
1. 变量定义和替换
这种功能在Maven里面也经常用到，用法很简答：
&configuration&
&property name="USER_HOME" value="/home/sebastien" /&
&appender name="FILE" class="ch.qos.logback.core.FileAppender"&
&file&${USER_HOME}/myApp.log&/file&
&pattern&%msg%n&/pattern&
&/encoder&
&/appender&
&root level="debug"&
&appender-ref ref="FILE" /&
&/configuration&
这里定义了一个变量 &property name="USER_HOME" value="/home/sebastien" /& 并通过 ${USER_HOME} 引用。变量定义的意义在于可以对一些全局性的属性/变量做统一的配置。如果有很多变量的时候，可以把变量定义在单独的文件中，通过 &property file="src/main/java/chapters/configuration/variables1.properties" /& 来引用。
// variables1.properties
USER_HOME=/home/sebastien
fileName=myApp.log
destination=${USER_HOME}/${fileName}
2. Scope配置通过配置 Scope 可以设置变量的作用空间，用法
&property scope="context" name="nodeId" value="firstNode" /&
有三种Scope是可以配置的：
1. LOCAL SCOPE
2. CONTEXT SCOPE
3. SYSTEM SCOPE
3. if表达式在xml中写代码的既视感：
&!-- if-then-else form --&
&if condition="some conditional expression"&
4. 常用条件表达式函数
1. property('key')
2. isDefined('key')
3. isNull("key")
5. 文件引用
// 引用方式
&include file="src/main/java/chapters/configuration/includedConfig.xml"/&
&include resource="includedConfig.xml"/&
&include url="/includedConfig.xml"/&
// 被引用文件
&included&
&appender name="includedConsole" class="ch.qos.logback.core.ConsoleAppender"&
&pattern&"%d - %m%n"&/pattern&
&/encoder&
&/appender&
&/included&
6. 使用时间戳属性
这种属性在哪些很短命的需要经常重启的App中用的比较多，每次重启会产生新的log文件（下面还有更牛逼的）
&timestamp key="bySecond" datePattern="yyyyMMdd'T'HHmmss"/&
&file&log-${bySecond}.txt&/file&
7. 常用的转移标记：
%c{length} /%lo{length} /logger{length} 打印logger名称，并控制长度，比如；%logger{5}
mainPackage.sub.sample.Bar
%C{length} /class{length} 打印出产生这条log的调用方的完整名字，并控制长度。这个方法效率不高，慎用。(目测要调用堆栈才能查到调用方的类名或者方法)
%contextName / %cn 打印出logger的上下文信息。在Configuration一节中我们曾经看到过这个的使用
%d{pattern} / %date{pattern} /%d{pattern, timezone} /%date{pattern, timezone} 打印出当前时间，通过pattern来控制日期格式，比如：%date{HH:mm:ss.SSS}
14:06:49.812
%F / %file 打印出产生这条log的java源文件，这个方法效率不高，慎用。
打印出产生这条log的堆栈信息，并控制长度，效率不高
%caller{depth}
%caller{depthStart..depthEnd}
%caller{depth, evaluator-1, ... evaluator-n}
%caller{depthStart..depthEnd, evaluator-1, ... evaluator-n}
%L / %line 打印出产生这条log的源码行号
%m / %msg / %message 打印loggger方法传入的消息，比如.("hello"),指代这里的“hello”
%M / %method 打印出产生这条log的方法名，效率不高
%p / %le /%level 打印出日志等级
%r / %relative 打印出自动App启动至今流逝的时间（单位：毫秒）
%t / %thread 打印出产生这条log的线程名字
%X{key:-defaultVal} / mdc{key:-defaultVal} 打印出MDC中定义的上下文
打印出异常的堆栈信息，并控制深度，默认情况下会打印所有的堆栈信息
%ex{depth}
%exception{depth}
%throwable{depth}
%ex{depth, evaluator-1, ..., evaluator-n}
%exception{depth, evaluator-1, ..., evaluator-n}
%throwable{depth, evaluator-1, ..., evaluator-n}
和 %ex一样，但是会给出jar包信息
%xEx{depth}
%xException{depth}
%xThrowable{depth}
%xEx{depth, evaluator-1, ..., evaluator-n}
%xException{depth, evaluator-1, ..., evaluator-n}
%xThrowable{depth, evaluator-1, ..., evaluator-n}
%nopex /%nopexception 忽略异常信息
%marker 打印marker信息，格式：parentName [ child1, child2 ]
%property{key} 引用之前定义的变量（或属性）
%replace(p){r, t} 举例说明：%replace(%msg){'\s', ''}，会把消息中的所有空格移除
目前就职于某宝，做Android和Server端开发博客分类：
一直以来,项目都是使用log4j+slf4j的方案来做日志, 最近看到 logback的文章,优点多多,手痒不已
注:阅读此文,需要有一定的log 日志基础
logback介绍:
首先logback,log4j,slf4j的作者是同一个人 ,java界鼎鼎大名的 Ceki Gülcü,logback为取代log4j而生，而log4j基本停止维护
logback优点:
提供独特而实用特性
logback缺点:
编写logback.xml 没有提示由于logback的灵活性,没有tld/schema规范文件,导致编写没有提示,增
logback+slf4j 项目中 java类里面的代码的写法和 log4j+slf4j的 代码写法完全一模一样的
import org.slf4j.L
import org.slf4j.LoggerF
*这个类提供了一些根据类的class文件位置来定位的方法。
* @version 1.0
上午12:40:08
* @since 1.0
public class ClassLoaderUtil{
private final static Logger log
= LoggerFactory.getLogger(ClassLoaderUtil.class);
slf4j的切面日志功能功不可没,代码中可以忽略logback或者 log4j 的存在
去掉 maven pom.xml 所有直接/间接的 log4j 依赖
&dependency&
&groupId&loxia2&/groupId&
&artifactId&loxia2-support&/artifactId&
&version&${version.loxia}&/version&
&exclusions&
&exclusion&
&artifactId&slf4j-log4j12&/artifactId&
&groupId&org.slf4j&/groupId&
&/exclusion&
&exclusion&
&artifactId&slf4j-api&/artifactId&
&groupId&org.slf4j&/groupId&
&/exclusion&
&/exclusions&
&/dependency&
去掉 maven pom.xml 所有直接/间接的 slf4j-log4j12 依赖
如上面的 exclusion
增加 logback 依赖
&!--******** logback and slf4j ******** --&
&dependency&
&groupId&ch.qos.logback&/groupId&
&artifactId&logback-core&/artifactId&
&version&${version.logback}&/version&
&/dependency&
&dependency&
&groupId&ch.qos.logback&/groupId&
&artifactId&logback-classic&/artifactId&
&version&${version.logback}&/version&
&/dependency&
&dependency&
&groupId&ch.qos.logback&/groupId&
&artifactId&logback-access&/artifactId&
&version&${version.logback}&/version&
&/dependency&
&dependency&
&groupId&org.slf4j&/groupId&
&artifactId&slf4j-api&/artifactId&
&version&${version.slf4j}&/version&
&/dependency&
&!--jul桥接 用来输出 Java Logging Framework (JUL) --&
&dependency&
&groupId&org.slf4j&/groupId&
&artifactId&jul-to-slf4j&/artifactId&
&version&${version.slf4j}&/version&
&/dependency&
&!-- jcl桥接，用来输出 第三方Jakarta Commons Logging (JCL) --&
&dependency&
&groupId&org.slf4j&/groupId&
&artifactId&jcl-over-slf4j&/artifactId&
&version&${version.slf4j}&/version&
&/dependency&
增加 logback.xml到 classpath下
&?xml version="1.0" encoding="UTF-8"?&
&configuration&
&appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender"&
&filter class="ch.qos.logback.classic.filter.ThresholdFilter"&
&level&DEBUG&/level&
&!-- 注意 logback 的括号需要转义 --&
&encoder charset="UTF-8" class="ch.qos.logback.classic.encoder.PatternLayoutEncoder"&
&pattern&%d{MMdd HH:mm:ss} %-5level \(%F:%L\) %method\(\) - %m%n
&/pattern&
&/encoder&
&/appender&
&appender-ref ref="CONSOLE" /&
&level value="DEBUG" /&
&/configuration&
配置完，启动程序，可以看到 日志输出和原先 log4j 基本上一样
从Log4j迁移到LogBack的理由
日志组件logback的介绍及配置使用方法
论坛回复 /
(0 / 3440)
浏览: 263335 次
来自: 上海
如果放到Nginx所在磁盘可以简单调整，这样就不用改直接用了。 ...
感谢，在这里找到了答案,解决问题就是需要找到了原理，才能找到答 ...
能帮忙看下吗
你好，我按照你的配置了，还是不行我的nginx配置如下serv ...
yfp 写道哥们，其实还有更简单的办法，因为P ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'