logback与Spring、SpringMVC结合使用教程（转）

摘要：本文主要介绍了如何在spring、springMVC中使用logback

一、logback与Spirng结合使用

1、maven添加引用：

  1. <dependency>
  2. <groupId>log4j</groupId>
  3. <artifactId>log4j</artifactId>
  4. <version>${log4j.version}</version>
  5. </dependency>
  6. <dependency>
  7. <groupId>org.slf4j</groupId>
  8. <artifactId>slf4j-api</artifactId>
  9. <version>${slf4j.version}</version>
  10. </dependency>
  11. <dependency>
  12. <groupId>ch.qos.logback</groupId>
  13. <artifactId>logback-classic</artifactId>
  14. <version>1.1.2</version>
  15. </dependency>
  16. <dependency>
  17. <groupId>ch.qos.logback</groupId>
  18. <artifactId>logback-core</artifactId>
  19. <version>1.1.2</version>
  20. </dependency>
  21. <dependency>
  22. <groupId>org.logback-extensions</groupId>
  23. <artifactId>logback-ext-spring</artifactId>
  24. <version>0.1.1</version>
  25. </dependency>

其中logback-ext-spring这个jar包是为了和spring一起使用的。

2、src/main/resource添加logback.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <configuration>
  3. <!-- 尽量别用绝对路径，如果带参数不同容器路径解释可能不同,以下配置参数在pom.xml里 -->
  4. <property name="log.root.level" value="${log.root.level}" /> <!-- 日志级别 -->
  5. <property name="log.other.level" value="${log.other.level}" /> <!-- 其他日志级别 -->
  6. <property name="log.base" value="${log.base}" /> <!-- 日志路径，这里是相对路径，web项目eclipse下会输出到eclipse的安装目录下，如果部署到linux上的tomcat下，会输出到tomcat/bin目录 下 -->
  7. <property name="log.moduleName" value="${log.moduleName}" />  <!-- 模块名称， 影响日志配置名，日志文件名 -->
  8. <property name="log.max.size" value="100MB" /> <!-- 日志文件大小 -->
  9. <!--控制台输出 -->
  10. <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
  11. <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  12. <Pattern>%date{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread]%logger{56}.%method:%L -%msg%n</Pattern>
  13. </encoder>
  14. </appender>
  15. <!-- 日志文件输出 -->
  16. <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">
  17. <File>${log.base}/${log.moduleName}.log</File><!-- 设置日志不超过${log.max.size}时的保存路径，注意如果 是web项目会保存到Tomcat的bin目录 下 -->
  18. <!-- 滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件。-->
  19. <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  20. <FileNamePattern>${log.base}/archive/${log.moduleName}_all_%d{yyyy-MM-dd}.%i.log.zip
  21. </FileNamePattern>
  22. <!-- 当天的日志大小 超过${log.max.size}时,压缩日志并保存 -->
  23. <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
  24. <maxFileSize>${log.max.size}</maxFileSize>
  25. </timeBasedFileNamingAndTriggeringPolicy>
  26. </rollingPolicy>
  27. <!-- 日志输出的文件的格式  -->
  28. <layout class="ch.qos.logback.classic.PatternLayout">
  29. <pattern>%date{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread]%logger{56}.%method:%L -%msg%n</pattern>
  30. </layout>
  31. </appender>
  32. <!-- 为某个包下的所有类的指定Appender 这里也可以指定类名称例如：com.aa.bb.ClassName -->
  33. <logger name="com.lin" additivity="false">
  34. <level value="debug" />
  35. <appender-ref ref="stdout" />
  36. <appender-ref ref="file" />
  37. </logger>
  38. <!-- root将级别为“DEBUG”及大于“DEBUG”的日志信息交给已经配置好的名为“Console”的appender处理，“Console”appender将信息打印到Console -->
  39. <root level="debug">
  40. <appender-ref ref="stdout" /> <!-- 标识这个appender将会添加到这个logger -->
  41. <appender-ref ref="file" />
  42. </root>
  43. </configuration>

其中，下面这几个参数 是在pom.xml里配置的，如果你不想在pom.xml里来配置，也可以直接写死就是

<property name="log.root.level" value="${log.root.level}" /> 
<property name="log.other.level" value="${log.other.level}" /> 
<property name="log.base" value="${log.base}" /> 
<property name="log.moduleName" value="${log.moduleName}" />  
<property name="log.max.size" value="10kb" />

参数内容如下：

  1. <profiles>
  2. <!-- 开发环境 -->
  3. <profile>
  4. <id>dev</id>
  5. <activation>
  6. <activeByDefault>true</activeByDefault>
  7. </activation>
  8. <!-- 以下配置properties中用到一些变量，如数据库连接参数、日志打印等 -->
  9. <properties>
  10. <!-- DB Resource -->
  11. <jdbc_driverClassName>com.mysql.jdbc.Driver</jdbc_driverClassName>
  12. <jdbc_url>jdbc:mysql://localhost:3306/learning</jdbc_url>
  13. <jdbc_username>root</jdbc_username>
  14. <jdbc_password>[email protected]</jdbc_password>
  15. <log.moduleName>ssm-project</log.moduleName>
  16. <log.base>logs</log.base>
  17. <log.other.level>DEBUG</log.other.level>
  18. <log.root.level>DEBUG</log.root.level>
  19. <log.stdout.ref><![CDATA[<appender-ref ref="stdout" />]]></log.stdout.ref>
  20. </properties>
  21. </profile>
  22. </profiles>

3、如果单独的跑一个spring项目，不带web页面的话，那么这时跑个单元测试就可以打印日志了

看看输出的文件：

二、logback与spingMVC结合使用

其实与spingMVC只需要在上面的工程中，在web.xml里添加如下内容即可。

  1. <!-- 添加日志监听器 -->
  2. <context-param>
  3. <param-name>logbackConfigLocation</param-name>
  4. <param-value>classpath:logback.xml</param-value>
  5. </context-param>
  6. <listener>
  7. <listener-class>ch.qos.logback.ext.spring.web.LogbackConfigListener</listener-class>
  8. </listener>

然后本地启动tomcat，把项目加载进来，注意，此时的日志输出路径 不会像上面一样出现在工程所在路径的logs目录下，而会放在eclipse安装目录下，自动新建一个logs目录 下：

而如果将此war包上传到linux下的tomcat的webapp目录后，日志文件会保存在tomcat/bin/logs目录下，记得，这个是web项目和非web项目日志保存路径的不同！

下面这一个是配置比较复杂的，大的工程更多的是以这种方式来配置的，针对不同的包，不同级别的日志来分别打印，如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <configuration>
  3. <!-- 尽量别用绝对路径，如果带参数不同容器路径解释可能不同,以下配置参数在pom.xml里 -->
  4. <property name="log.root.level" value="${log.root.level}" /> <!-- 日志级别 -->
  5. <property name="log.other.level" value="${log.other.level}" /> <!-- 其他日志级别 -->
  6. <property name="log.base" value="${log.base}" /> <!-- 日志路径，这里是相对路径，web项目eclipse下会输出到eclipse的安装目录下，如果部署到linux上的tomcat下，会输出到tomcat/bin目录 下 -->
  7. <property name="log.moduleName" value="${log.moduleName}" />  <!-- 模块名称， 影响日志配置名，日志文件名 -->
  8. <property name="log.max.size" value="100MB" /> <!-- 日志文件大小,超过这个大小将被压缩 -->
  9. <!--控制台输出 -->
  10. <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
  11. <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  12. <Pattern>%date{yyyy-MM-dd HH:mm:ss.SSS} %-5level[%thread]%logger{56}.%method:%L -%msg%n</Pattern>
  13. </encoder>
  14. </appender>
  15. <!-- 用来保存输出所有级别的日志 -->
  16. <appender name="file.all" class="ch.qos.logback.core.rolling.RollingFileAppender">
  17. <File>${log.base}/${log.moduleName}.log</File><!-- 设置日志不超过${log.max.size}时的保存路径，注意如果
  18. 是web项目会保存到Tomcat的bin目录 下 -->
  19. <!-- 滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件。 -->
  20. <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  21. <FileNamePattern>${log.base}/archive/${log.moduleName}_all_%d{yyyy-MM-dd}.%i.log.zip
  22. </FileNamePattern>
  23. <!-- 文件输出日志 (文件大小策略进行文件输出，超过指定大小对文件备份) -->
  24. <timeBasedFileNamingAndTriggeringPolicy
  25. class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
  26. <maxFileSize>${log.max.size}</maxFileSize>
  27. </timeBasedFileNamingAndTriggeringPolicy>
  28. </rollingPolicy>
  29. <!-- 日志输出的文件的格式 -->
  30. <layout class="ch.qos.logback.classic.PatternLayout">
  31. <pattern>%date{yyyy-MM-dd HH:mm:ss.SSS} %-5level[%thread]%logger{56}.%method:%L -%msg%n</pattern>
  32. </layout>
  33. </appender>
  34. <!-- 这也是用来保存输出所有级别的日志 -->
  35. <appender name="file.all.other" class="ch.qos.logback.core.rolling.RollingFileAppender">
  36. <File>${log.base}/${log.moduleName}_other.log</File>
  37. <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  38. <FileNamePattern>${log.base}/archive/${log.moduleName}_other_%d{yyyy-MM-dd}.%i.log.zip
  39. </FileNamePattern>
  40. <timeBasedFileNamingAndTriggeringPolicy
  41. class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
  42. <maxFileSize>${log.max.size}</maxFileSize>
  43. </timeBasedFileNamingAndTriggeringPolicy>
  44. </rollingPolicy>
  45. <layout class="ch.qos.logback.classic.PatternLayout">
  46. <pattern>%date{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread] %logger{56}.%method:%L -%msg%n</pattern>
  47. </layout>
  48. </appender>
  49. <!-- 只用保存输出error级别的日志 -->
  50. <appender name="file.error"
  51. class="ch.qos.logback.core.rolling.RollingFileAppender">
  52. <File>${log.base}/${log.moduleName}_err.log</File>
  53. <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  54. <FileNamePattern>${log.base}/archive/${log.moduleName}_err_%d{yyyy-MM-dd}.%i.log.zip
  55. </FileNamePattern>
  56. <timeBasedFileNamingAndTriggeringPolicy
  57. class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
  58. <maxFileSize>${log.max.size}</maxFileSize>
  59. </timeBasedFileNamingAndTriggeringPolicy>
  60. </rollingPolicy>
  61. <layout class="ch.qos.logback.classic.PatternLayout">
  62. <pattern>%date{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread] %logger{56}.%method:%L - %msg%n</pattern>
  63. </layout>
  64. <!-- 下面为配置只输出error级别的日志 -->
  65. <filter class="ch.qos.logback.classic.filter.LevelFilter">
  66. <level>ERROR</level>
  67. <onMatch>ACCEPT</onMatch>
  68. <onMismatch>DENY</onMismatch>
  69. </filter>
  70. </appender>
  71. <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
  72. <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
  73. <!-- 添加附加的appender,最多只能添加一个 -->
  74. <appender name="file.async" class="ch.qos.logback.classic.AsyncAppender">
  75. <discardingThreshold>0</discardingThreshold>
  76. <queueSize>256</queueSize>
  77. <includeCallerData>true</includeCallerData>
  78. <appender-ref ref="file.all" />
  79. </appender>
  80. <appender name="file.async.other" class="ch.qos.logback.classic.AsyncAppender">
  81. <discardingThreshold>0</discardingThreshold>
  82. <queueSize>256</queueSize>
  83. <includeCallerData>true</includeCallerData>
  84. <appender-ref ref="file.all.other" />
  85. </appender>
  86. <!-- 为某个包下的所有类的指定Appender 这里也可以指定类名称例如：com.aa.bb.ClassName -->
  87. <logger name="com.lin" additivity="false">
  88. <level value="${log.root.level}" />
  89. <appender-ref ref="stdout" />
  90. <appender-ref ref="file.async" /><!-- 即com.lin包下级别为 ${log.root.level}的才会使用file.async来打印 -->
  91. <appender-ref ref="file.error" />
  92. </logger>
  93. <!-- root将级别为${log.root.level}及大于${log.root.level}的日志信息交给已经配置好的名为“Console”的appender处理，“Console”appender将信息打印到Console,其它同理 -->
  94. <root level="${log.root.level}">
  95. <appender-ref ref="stdout" /> <!--  标识这个appender将会添加到这个logger -->
  96. <appender-ref ref="file.async.other" />
  97. <appender-ref ref="file.error" />
  98. </root>
  99. </configuration>

还有另一个网上的找的配置文件，笔者 没有使用过，不过，大家可以参考下来写：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <configuration scan="true" scanPeriod="10 seconds" debug="false">
  3. <!--打印logback初始化日志系统信息，debug="true"是同等效果-->
  4. <!--<statusListener class="ch.qos.logback.core.status.OnConsoleStatusListener"/>-->
  5. <!-- 将日志输出在当前项目的根目录下 -->
  6. <property name="contextPath" value="/home/logs/valiuser"/>
  7. <!-- 日志的上下文路径 -->
  8. <property name="logPath" value="${contextPath}"/>
  9. <!-- 配置日志的滚动时间 -->
  10. <property name="maxHistory" value="90"/>
  11. <!-- 打印日志到控制台 -->
  12. <appender name="rootConsole" class="ch.qos.logback.core.ConsoleAppender">
  13. <!-- encoder 在控制台打印日志的格式 -->
  14. <encoder>
  15. <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36}.%M - %msg%n</pattern>
  16. </encoder>
  17. </appender>
  18. <!--
  19. 定义日志的输出方式:输出在文件夹debug/debug.log文件中
  20. 配置所有类所有级别的滚动日志
  21. -->
  22. <appender name="rootRollingDebug" class="ch.qos.logback.core.rolling.RollingFileAppender">
  23. <file>${logPath}/debug/debug.log</file>
  24. <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  25. <fileNamePattern>${logPath}/debug/debug.%d{yyyy-MM-dd}.log</fileNamePattern>
  26. <!-- 设置日志的滚动时间 -->
  27. <maxHistory>${maxHistory}</maxHistory>
  28. </rollingPolicy>
  29. <encoder>
  30. <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36}.%M - %msg%n</pattern>
  31. <charset>UTF-8</charset>
  32. </encoder>
  33. </appender>
  34. <!--
  35. 定义日志的输出方式:输出在文件夹info/root.log文件中
  36. 配置所有类INFO级别的滚动日志
  37. -->
  38. <appender name="rootRollingInfo" class="ch.qos.logback.core.rolling.RollingFileAppender">
  39. <file>${logPath}/info/info.log</file>
  40. <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  41. <fileNamePattern>${logPath}/info/info.%d{yyyy-MM-dd}.log</fileNamePattern>
  42. <!-- 设置日志的滚动时间 -->
  43. <maxHistory>${maxHistory}</maxHistory>
  44. </rollingPolicy>
  45. <encoder>
  46. <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36}.%M - %msg%n</pattern>
  47. <charset>UTF-8</charset>
  48. </encoder>
  49. <!--
  50. info/root.log文件中的日志级别是 INFO以上的级别
  51. <filter class="ch.qos.logback.classic.filter.ThresholdFilter"> 和
  52. <filter class="ch.qos.logback.classic.filter.LevelFilter">的区别是什么呢?
  53. LevelFilter:严格限制日志的输出级别,使用LevelFilter设置,只会在文件中出现级别为INFO级别的日志内容。
  54. -->
  55. <filter class="ch.qos.logback.classic.filter.LevelFilter">
  56. <level>INFO</level>
  57. <onMatch>ACCEPT</onMatch>
  58. <onMismatch>DENY</onMismatch>
  59. </filter>
  60. </appender>
  61. <!--
  62. 定义日志的输出方式:输出在文件夹warn/root.log文件中
  63. 配置所有类WARN级别的滚动日志
  64. -->
  65. <appender name="rootRollingWarn" class="ch.qos.logback.core.rolling.RollingFileAppender">
  66. <file>${logPath}/warn/warn.log</file>
  67. <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  68. <fileNamePattern>${logPath}/warn/warn.%d{yyyy-MM-dd}.log</fileNamePattern>
  69. <!-- 设置日志的滚动时间 -->
  70. <maxHistory>${maxHistory}</maxHistory>
  71. </rollingPolicy>
  72. <encoder>
  73. <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36}.%M - %msg%n</pattern>
  74. <charset>UTF-8</charset>
  75. </encoder>
  76. <!-- warn/root.log文件中的日志级别是 WARN以上的级别  -->
  77. <filter class="ch.qos.logback.classic.filter.LevelFilter">
  78. <level>WARN</level>
  79. </filter>
  80. </appender>
  81. <!--
  82. 定义日志的输出方式:输出在文件夹error/root.log文件中
  83. 配置所有类ERROR级别的滚动日志
  84. -->
  85. <appender name="rootRollingError" class="ch.qos.logback.core.rolling.RollingFileAppender">
  86. <file>${logPath}/error/error.log</file>
  87. <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  88. <fileNamePattern>${logPath}/error/error.%d{yyyy-MM-dd}.log</fileNamePattern>
  89. <!-- 设置日志的滚动时间 -->
  90. <maxHistory>${maxHistory}</maxHistory>
  91. </rollingPolicy>
  92. <encoder>
  93. <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36}.%M - %msg%n</pattern>
  94. <charset>UTF-8</charset>
  95. </encoder>
  96. <!-- error/root.log文件中的日志级别是 ERROR以上的级别 -->
  97. <filter class="ch.qos.logback.classic.filter.LevelFilter">
  98. <level>ERROR</level>
  99. </filter>
  100. </appender>
  101. <!--
  102. 定义日志的输出方式:输出在文件夹sql/root.log文件中
  103. 配置所有类SQL的日志
  104. -->
  105. <appender name="rootRollingSql" class="ch.qos.logback.core.rolling.RollingFileAppender">
  106. <file>${logPath}/sql/sql.log</file>
  107. <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  108. <fileNamePattern>${logPath}/sql/sql.%d{yyyy-MM-dd}.log</fileNamePattern>
  109. <!-- 设置日志的滚动时间 -->
  110. <maxHistory>${maxHistory}</maxHistory>
  111. </rollingPolicy>
  112. <encoder>
  113. <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36}.%M - %msg%n</pattern>
  114. <charset>UTF-8</charset>
  115. </encoder>
  116. </appender>
  117. <!--
  118. 定义日志的输出方式:输出在文件夹business/rootsql.log文件中
  119. 打印业务逻辑级别的日志到business文件下
  120. -->
  121. <appender name="businessRollingDebug" class="ch.qos.logback.core.rolling.RollingFileAppender">
  122. <file>${logPath}/business/business.log</file>
  123. <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  124. <fileNamePattern>${logPath}/business/business.%d{yyyy-MM-dd}.log</fileNamePattern>
  125. <!-- 设置日志的滚动时间 -->
  126. <maxHistory>${maxHistory}</maxHistory>
  127. </rollingPolicy>
  128. <encoder>
  129. <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36}.%M - %msg%n</pattern>
  130. <charset>UTF-8</charset>
  131. </encoder>
  132. </appender>
  133. <!--
  134. 默认的日志主线程<root>
  135. 定义输出日志的级别.DEBUG级别
  136. 下面设置的意思是:会将debug级别的日志输出在一下这五个appender-ref对应的appender上
  137. -->
  138. <root level="DEBUG">
  139. <appender-ref ref="rootConsole"/>
  140. <appender-ref ref="rootRollingDebug"/>
  141. </root>
  142. <root level="WARN">
  143. <appender-ref ref="rootRollingWarn"/>
  144. </root>
  145. <root level="ERROR">
  146. <appender-ref ref="rootRollingError"/>
  147. </root>
  148. <root level="INFO">
  149. <appender-ref ref="rootRollingInfo"/>
  150. </root>
  151. <!--
  152. 除了使用默认的日志主线程<root>外，还可以通过<logger>标签定制其他日志线程如：
  153. 其中name指定线程针对的包路径，level是日志级别，<appender-ref>定义使用那种appender。
  154. -->
  155. <!--log4jdbc   begin -->
  156. <!--
  157. jdbc.sqlonly不显示sql执行的时间
  158. jdbc.sqltiming显示sql执行的时间{executed in 2 msec}
  159. 二者使用一个即可
  160. <logger name="jdbc.sqlonly" level="DEBUG"  addtivity="false">
  161. <appender-ref ref="rootConsole"/>
  162. <appender-ref ref="rootRollingSql"/>
  163. </logger>
  164. -->
  165. <logger name="jdbc.sqltiming" level="DEBUG" addtivity="false">
  166. <appender-ref ref="rootConsole"/>
  167. <appender-ref ref="rootRollingSql"/>
  168. </logger>
  169. <!--log4jdbc   end -->
  170. <!--
  171. 打印项目中com包下的日志到appender-ref指定的appender中  打印级别是debug
  172. 这里可以用来专门打印某一类别的日志到某一个特定的文件中.
  173. 比如:可以打印所有的业务逻辑到业务逻辑文件中;打印所有的controller请求到指定的文件中.
  174. -->
  175. <logger name="com" level="DEBUG" addtivity="true">
  176. <appender-ref ref="businessRollingDebug"/>
  177. </logger>
  178. <!--
  179. 打印具体的某个文件中的日志到某个文件夹下.
  180. 注意:不是打印com.baihui.LogBackTest2文件夹下的日志,而是LogBackTest2文件的日志
  181. addtivity="false" 表示打印的日志不向上传递,如果设置成addtivity="true"会怎么样呢?没错,日志打印了两遍
  182. -->
  183. <logger name="com.baihui" level="DEBUG" addtivity="false">
  184. <appender-ref ref="rootConsole"/>
  185. </logger>
  186. <logger name="baihui" level="ERROR" addtivity="false">
  187. <appender-ref ref="rootConsole"/>
  188. </logger>
  189. </configuration>

<pattern>里面的转换符说明：

转换符 作用
c {length } 
lo {length } 
logger {length } 		 输出日志的logger名，可有一个整形参数，功能是缩短logger名，设置为0表示只输入logger最右边点符号之后的字符串。

Conversion specifier Logger name Result
%logger mainPackage.sub.sample.Bar mainPackage.sub.sample.Bar
%logger{0} mainPackage.sub.sample.Bar Bar
%logger{5} mainPackage.sub.sample.Bar m.s.s.Bar
%logger{10} mainPackage.sub.sample.Bar m.s.s.Bar
%logger{15} mainPackage.sub.sample.Bar m.s.sample.Bar
%logger{16} mainPackage.sub.sample.Bar m.sub.sample.Bar
%logger{26} mainPackage.sub.sample.Bar mainPackage.sub.sample.Bar
C {length } 
class {length } 		 输出执行记录请求的调用者的全限定名。参数与上面的一样。尽量避免使用，除非执行速度不造成任何问题。
contextName 
cn 		 输出上下文名称。
d {pattern } 
date {pattern } 		 输出日志的打印日志，模式语法与java.text.SimpleDateFormat 兼容。

Conversion Pattern Result
%d 2006-10-20 14:06:49,812
%date 2006-10-20 14:06:49,812
%date{ISO8601} 2006-10-20 14:06:49,812
%date{HH:mm:ss.SSS} 14:06:49.812
%date{dd MMM yyyy ;HH:mm:ss.SSS} 20 oct. 2006;14:06:49.812
F / file 输出执行记录请求的java源文件名。尽量避免使用，除非执行速度不造成任何问题。
caller{depth}caller{depth, evaluator-1, ... evaluator-n} 输出生成日志的调用者的位置信息，整数选项表示输出信息深度。

例如， %caller{2}   输出为：

0    [main] DEBUG - logging statement
Caller+0   at mainPackage.sub.sample.Bar.sampleMethodName(Bar.java:22)
Caller+1   at mainPackage.sub.sample.Bar.createLoggingRequest(Bar.java:17)

例如， %caller{3}   输出为：

16   [main] DEBUG - logging statement
Caller+0   at mainPackage.sub.sample.Bar.sampleMethodName(Bar.java:22)
Caller+1   at mainPackage.sub.sample.Bar.createLoggingRequest(Bar.java:17)
Caller+2   at mainPackage.ConfigTester.main(ConfigTester.java:38)
L / line 输出执行日志请求的行号。尽量避免使用，除非执行速度不造成任何问题。
m / msg / message
输出应用程序提供的信息。
M / method 输出执行日志请求的方法名。尽量避免使用，除非执行速度不造成任何问题。
n 输出平台先关的分行符“\n”或者“\r\n”。
p / le / level 输出日志级别。
r / relative 输出从程序启动到创建日志记录的时间，单位是毫秒
t / thread 输出产生日志的线程名。
replace(p ){r, t}
p 为日志内容，r 是正则表达式，将p 中符合r 的内容替换为t 。

例如， "%replace(%msg){‘\s‘, ‘‘}"

参考文章：http://www.360doc.com/content/14/1016/15/8072791_417440479.shtml

http://blog.csdn.net/evankaka/article/details/50637994

原文地址：https://www.cnblogs.com/anyiz/p/10712299.html

时间： 2024-10-09 06:55:28

logback与Spring、SpringMVC结合使用教程（转）的相关文章

logback与Spring、SpringMVC结合使用教程

林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 摘要:本文主要介绍了如何在spring.springMVC中使用logback 一.logback与Spirng结合使用 1.maven添加引用: <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>${log4j.versio

SSM框架——Spring+SpringMVC+Mybatis的搭建教程

一:概述 SSM框架在项目开发中经常使用到,相比于SSH框架,它在仅几年的开发中运用的更加广泛. Spring作为一个轻量级的框架,有很多的拓展功能,最主要的我们一般项目使用的就是IOC和AOP. SpringMVC是Spring实现的一个Web层,相当于Struts的框架,但是比Struts更加灵活和强大! Mybatis是 一个持久层的框架,在使用上相比Hibernate更加灵活,可以控制sql的编写,使用 XML或注解进行相关的配置! 根据上面的描述,学习SSM框架就非常的重要了! 二:搭

Spring+SpringMVC+MyBatis+LogBack+C3P0+Maven+Git小结（转）

摘要 出于兴趣,想要搭建一个自己的小站点,目前正在积极的准备环境,利用Spring+SpringMVC+MyBatis+LogBack+C3P0+Maven+Git,这里总结下最近遇到的一些问题及解决办法,后续慢慢的继续补~ 目录[-] 一:建立一个Maven结构的Web工程 二:Spring.SpringMVC重复加载bean对象问题. 三:实现自个的数据缓存机制 2种缓存数据简介及其数据结构分析 2中缓存数据加载实现流程介绍 三:通过Spring自定义标签形式实现配置项类型数据的缓存数据结构

Spring+SpringMvc+Mybatis框架集成搭建教程

一.背景 最近有很多同学由于没有过SSM(Spring+SpringMvc+Mybatis , 以下简称SSM)框架的搭建的经历,所以在自己搭建SSM框架集成的时候,出现了这样或者那样的问题,很是苦恼,网络上又没有很详细的讲解以及搭建的教程.闲来无事,我就利用空闲时间来写这样一个教程和搭建步骤,来帮助那些有问题的小伙伴,让你从此SSM搭建不再有问题. 二.教程目录 1.Spring+SpringMvc+Mybatis框架集成搭建教程一(项目创建) 2.Spring+SpringMvc+Mybat

Spring+SpringMvc+Mybatis框架集成搭建教程一(背景介绍及项目创建)

一.背景 最近有很多同学由于没有过SSM(Spring+SpringMvc+Mybatis , 以下简称SSM)框架的搭建的经历,所以在自己搭建SSM框架集成的时候,出现了这样或者那样的问题,很是苦恼,网络上又没有很详细的讲解以及搭建的教程.闲来无事,我就利用空闲时间来写这样一个教程和搭建步骤,来帮助那些有问题的小伙伴,让你从此SSM搭建不再有问题. 二.搭建步骤 1.框架搭建环境 Spring 4.2.6.RELEASE SpringMvc 4.2.6.RELEASE Mybatis 3.2.

SSM框架——详细整合教程（Spring+SpringMVC+MyBatis）【转载】

最近在学习Spring+SpringMVC+MyBatis的整合.以下是参考网上的资料自己实践操作的详细步骤. 1.基本概念 1.1.Spring Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来.它是为了解决企业应用开发的复杂性而创建的.Spring使用基本的JavaBean来完成以前只可能由EJ

Spring+SpringMvc+Mybatis框架集成搭建教程二(依赖配置及框架整合)

依赖导入以及框架整合 (1).打开项目的pom.xml文件,声明依赖 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_

SSM框架 （Spring+SpringMVC+MyBatis）

SSM框架--详细整合教程(Spring+SpringMVC+MyBatis) springspringmvcmybatis整合教程ssm整合 1.基本概念  1.1.Spring          Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来.它是为了解决企业应用开发的复杂性而创建的.Spri

[JSP]Maven+SSM框架(Spring+SpringMVC+MyBatis)

来源:http://blog.csdn.net/zhshulin/article/details/37956105?utm_source=tuicool&utm_medium=referral(以下博文对原博文有改动和补充) 开发环境: Eclipse Java EE IDE for Web Developers. Version: Mars.2 Release (4.5.2) apache-tomcat-8.0.33 jdk1.8.0_77 MySQL 5.0.11-dev(官网下载需要账号登