Spring MVC中使用logback的日志配置
springboot项目配置logback日志系统的实现
springboot项⽬配置logback⽇志系统的实现记录springboot项⽬配置logback⽇志⽂件管理:logback依赖jar包SpringBoot项⽬配置logback理论上需要添加logback-classic依赖jar包:<dependency><groupId>ch.qos.logback</groupId><artifactId>logback-classic</artifactId><version>1.2.3</version></dependency>但是因为SpringBoot项⽬默认就是使⽤的就是logback⽇志系统,创建SpringBoot项⽬时引⼊的spring-boot-starter或者spring-boot-starter-web依赖jar包中已经包含了spring-boot-starter-logging的依赖,⾥⾯同时包含多种⽇志系统依赖,如下图所⽰:包括logback和log4j,所以,⽆需额外添加依赖,直接配置logback.xml就可以了。
此外,如果需要切换为log4j2,那么需要在spring-boot-starter-web依赖中排除springboot⾃带的commons‐logging,然后在引⼊log4j2的依赖jar包,如下所⽰:<!--排除 commons‐logging--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId><exclusions><exclusion><groupId>commons‐logging</groupId><artifactId>commons‐logging</artifactId></exclusion></exclusions></dependency><!--引⼊log4j2 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-log4j2</artifactId></dependency>logback的默认配置前⾯说到SpringBoot项⽬默认使⽤logback,那么对于logback的配置情况,SpringBoot⼜是如何定义的呢?⾸先,SpringBoot会从resource包下查找logback-test.xml或logback.xml,如果这两个都不存在,则会调⽤BasicConfigurator,创建⼀个最⼩化的基本配置。
SpringBoot日志配置方法(超详细)
SpringBoot⽇志配置⽅法(超详细)默认⽇志 Logback :默认情况下,Spring Boot会⽤Logback来记录⽇志,并⽤INFO级别输出到控制台。
在运⾏应⽤程序和其他例⼦时,你应该已经看到很多INFO级别的⽇志了。
从上图可以看到,⽇志输出内容元素具体如下:时间⽇期:精确到毫秒⽇志级别:ERROR, WARN, INFO, DEBUG or TRACE进程ID分隔符:— 标识实际⽇志的开始线程名:⽅括号括起来(可能会截断控制台输出)Logger名:通常使⽤源代码的类名⽇志内容添加⽇志依赖假如maven依赖中添加了 spring-boot-starter-logging :1 2 3 4<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-logging</artifactId> </dependency>但是呢,实际开发中我们不需要直接添加该依赖。
你会发现 spring-boot-starter 其中包含了 spring-boot-starter-logging ,该依赖内容就是 Spring Boot 默认的⽇志框架 logback 。
⼯程中有⽤到了 Thymeleaf ,⽽ Thymeleaf 依赖包含了 spring-boot-starter ,最终我只要引⼊ Thymeleaf 即可。
1 2 3 4<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency>控制台输出⽇志级别从低到⾼分为:1TRACE < DEBUG < INFO < WARN < ERROR < FATAL 。
SpringMVC目录结构配置
SpringMVC目录结构配置SpringMVC是一种常见的Java Web框架,它遵循MVC(Model-View-Controller)设计模式,用于构建灵活可扩展的Web应用程序。
SpringMVC的目录结构对于项目的开发和维护非常重要,下面会详细介绍SpringMVC的标准目录结构以及配置方式。
1.标准目录结构1.1 src/main/java:主要用于存放Java源代码。
1.2 src/main/resources:主要用于存放配置文件和资源文件。
1.3 src/main/webapp:主要用于存放Web应用的静态资源。
1.4 src/test/java:主要用于存放测试用例的Java源代码。
1.5 src/test/resources:主要用于存放测试用例的配置文件和资源文件。
2.详细解析2.1 src/main/java目录src/main/java目录是存放Java源代码的默认目录,它包括以下几个子目录:- config:用于存放Spring配置类,如配置数据库连接、配置事务管理等。
- interceptor:用于存放SpringMVC的拦截器。
- model:用于存放数据模型相关的实体类。
- util:用于存放工具类。
- web:用于存放SpringMVC的控制器。
2.2 src/main/resources目录src/main/resources目录是存放配置文件和资源文件的默认目录,它包括以下几个子目录:- static:用于存放静态资源文件,如CSS、JavaScript、图片等。
- templates:用于存放模板文件,如HTML、Thymeleaf模板等。
- application.properties:存放项目的配置信息,如数据库配置、端口配置等。
- logback.xml:存放日志配置,如日志级别、输出路径等。
- mapper:存放MyBatis的Mapper.xml文件。
spring集成logback(maven项目)
这里其实也说明了原因,看SLF4J开头的2行日志,其实这个不是根本原因,上面在引入logback支持的3个基本jar时有个坑,这也是开源故意还是有意就不知道了(jcl-over-slf4j不算必须的jar),注意看logback-classic引入,里面的scope节点设置的是test,这个的意思是什么呢?下面补充下maven的scope标签的知识:<scope>test</scope><!--依赖范围。
在项目发布过程中,帮助决定哪些构件被包括进来。
欲知详情请参考依赖机制。
- compile :默认范围,用于编译- provided:类似于编译,但支持你期待jdk或者容器提供,类似于classpath- runtime: 在执行时需要使用- test: 用于test任务时使用- system: 需要外在提供相应的元素。
通过systemPath来取得- systemPath: 仅用于范围为system。
提供相应的路径- optional: 当项目自身被依赖时,标注依赖是否传递。
用于连续依赖时使用-->设置的是test,说明不会把jar加到项目的lib下,我自己也检查了maven install出来的项目war包,确实里面是没有这个包的。
2、SLF4J: Class path contains multiple SLF4J bindings.看到没,这时候虽然是开始打印日志了,达到了目的,但是还有警告提示,这里实际上是告诉你,2个jar里都有这个StaticLoggerBinder,这就是个赌jar的加载顺序和版本的问题,可能换个版本,方法就不一定兼容了,可能那次不是调用的logback-classic-1.2.3.jar里的方法就会包classNotFound了或其他错了。
这个问题很蛋疼,说实话slf4j-log4j12都不知道怎么来的,在pom里没有引入这个,开源项目因为有大概10个jar是自己封装的,怀疑是他们封装的jar里包含了这个,准备用exclusions去掉他们的jar对这个jar的依赖的,但是jar太多,实在懒得一个个反编译jar看。
springMVC配置(XML配置详解)
springMVC配置(XML配置详解)原⽂出⾃:web.xml配置:servlet><servlet-name>dispatcher</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><description>加载/WEB-INF/spring-mvc/⽬录下的所有XML作为Spring MVC的配置⽂件</description><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/spring-mvc/*.xml</param-value></init-param><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>dispatcher</servlet-name><url-pattern>*.htm</url-pattern></servlet-mapping>这样,所有的.htm的请求,都会被DispatcherServlet处理;初始化 DispatcherServlet 时,该框架在 web 应⽤程序WEB-INF ⽬录中寻找⼀个名为[servlet-名称]-servlet.xml的⽂件,并在那⾥定义相关的Beans,重写在全局中定义的任何Beans,像上⾯的web.xml中的代码,对应的是dispatcher-servlet.xml;当然也可以使⽤<init-param>元素,⼿动指定配置⽂件的路径;dispatcher-servlet.xml 配置:<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:mvc="/schema/mvc"xmlns:p="/schema/p"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd/schema/aop/schema/aop/spring-aop-3.0.xsd/schema/tx/schema/tx/spring-tx-3.0.xsd/schema/mvc/schema/mvc/spring-mvc-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd"><!--使Spring⽀持⾃动检测组件,如注解的Controller--><context:component-scan base-package="com.minx.crm.web.controller"/><bean id="viewResolver"class="org.springframework.web.servlet.view.InternalResourceViewResolver"p:prefix="/WEB-INF/jsp/"p:suffix=".jsp" /></beans>第⼀个Controller:package com.minx.crm.web.controller;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;@Controllerpublic class IndexController {@RequestMapping("/index")public String index() {return "index";}}@Controller注解标识⼀个控制器,@RequestMapping注解标记⼀个访问的路径(/index.htm),return "index"标记返回视图(index.jsp);注:如果@RequestMapping注解在类级别上,则表⽰⼀相对路径,在⽅法级别上,则标记访问的路径;从@RequestMapping注解标记的访问路径中获取参数:Spring MVC ⽀持RESTful风格的URL参数,如:@Controllerpublic class IndexController {@RequestMapping("/index/{username}")public String index(@PathVariable("username") String username) {System.out.print(username);return "index";}}在@RequestMapping中定义访问页⾯的URL模版,使⽤{}传⼊页⾯参数,使⽤@PathVariable 获取传⼊参数,即可通过地址:http://localhost:8080/crm/index/tanqimin.htm 访问;根据不同的Web请求⽅法,映射到不同的处理⽅法:使⽤登陆页⾯作⽰例,定义两个⽅法分辨对使⽤GET请求和使⽤POST请求访问login.htm时的响应。
Java日志框架对比:Log4j、Logback和SLF4J的选择
Java日志框架对比:Log4j、Logback和SLF4J的选择引言:在开发Java应用程序时,日志是一个非常重要的组成部分。
它可以帮助我们记录应用程序的运行状态、调试问题以及监控系统性能。
为了更好地管理和利用日志信息,我们需要选择一个适合的日志框架。
本文将对比三个流行的Java日志框架:Log4j、Logback和SLF4J,帮助读者了解它们的特点和适用场景,以便做出正确的选择。
一、Log4jLog4j是一个广泛使用的Java日志框架,它提供了强大的日志记录功能和灵活的配置选项。
Log4j具有以下几个主要特点:1. 简单易用:Log4j的API设计简单直观,容易上手。
开发人员可以通过几行代码快速集成Log4j到应用程序中,并开始记录日志。
2. 高度可配置:Log4j提供了丰富的配置选项,可以根据需求灵活地配置日志输出格式、日志级别、目标设备等。
这使得开发人员可以根据具体需求进行精细化的日志管理。
3. 强大的过滤器机制:Log4j支持多种过滤器,可以根据日志的级别、来源、内容等进行过滤,从而实现对日志信息的精确控制。
4. 多种输出方式:Log4j支持将日志输出到控制台、文件、数据库等多种目标设备,开发人员可以根据实际需求选择合适的输出方式。
尽管Log4j在过去是Java日志领域的翘楚,但它的维护和更新已经相对较少。
因此,随着时间的推移,Log4j的性能和功能可能无法满足现代应用程序的需求。
二、LogbackLogback是由Log4j的创始人开发的下一代Java日志框架,它在Log4j的基础上进行了改进和优化。
Logback具有以下几个主要特点:1. 高性能:相比于Log4j,Logback在性能上有了显著提升。
它通过精细的设计和优化,可以更高效地处理日志记录,减少对应用程序性能的影响。
2. 灵活的配置:Logback提供了与Log4j相似的配置选项,可以根据需要自定义日志输出格式、级别、目标设备等。
SpringBootLogback异步打印Web请求参数
SpringBootLogback异步打印Web请求参数Spring Boot是一种用于构建独立的、生产级的Spring应用程序的框架,它提供了许多开箱即用的功能和约定,让开发人员可以快速进行Web应用程序的开发。
而Logback是一种强大的日志框架,它支持异步日志记录,并且具有高性能和灵活的配置选项。
在Web应用程序中,往往需要记录和分析用户的请求参数,以便进行问题排查、性能优化等工作。
而通过Logback的异步日志记录功能,可以将这些请求参数的日志记录为异步任务,在后台线程中进行处理,不影响主线程的性能。
下面是一个简单的实现示例:首先,需要在pom.xml文件中添加logback和spring-boot-starter-web依赖:```xml<dependencies><!-- Logback --><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-classic</artifactId></dependency><!-- Spring Boot Web --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency></dependencies>```接下来,创建一个自定义的LoggingFilter,来记录请求参数:```javaimport ch.qos.logback.classic.LoggerContext;import ch.qos.logback.classic.spi.ILoggingEvent;import ch.qos.logback.core.Appender;import ch.qos.logback.core.ConsoleAppender;import ch.qos.logback.core.filter.Filter;import org.slf4j.LoggerFactory;protected void beforeRequest(HttpServletRequest request, String message)super.beforeRequest(request, message);logRequestParams(request);}private void logRequestParams(HttpServletRequest request)//获取请求参数StringBuilder params = new StringBuilder(;request.getParameterMap(.forEach((name, values) ->for (String value : values)params.append(name).append("=").append(value).append(",");}});//记录请求参数LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(;Appender<ILoggingEvent> appender =loggerContext.getLogger("ROOT").getAppender("CONSOLE");if (appender instanceof ConsoleAppender)ConsoleAppender<ILoggingEvent> consoleAppender = (ConsoleAppender<ILoggingEvent>) appender;//添加过滤器,只打印带有请求参数的日志consoleAppender.addFilter(new Filter<ILoggingEventpublic FilterReply decide(ILoggingEvent event)return event.getMessage(.contains("Request parameters: [") ? FilterReply.ACCEPT : FilterReply.DENY;}});//打印请求参数loggerContext.getLogger("ROOT").info("Request parameters: [{}]", params.toString();}}```然后,在应用程序的配置文件application.properties中添加如下配置,开启异步日志记录和请求参数的打印:```properties#开启异步日志记录logging.main.async=true#开启请求参数的打印logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread] %logger{36} - %msg%n``````javaimport org.springframework.boot.SpringApplication;importorg.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.scheduling.annotation.EnableAsync;public class Applicationpublic static void main(String[] args)}```现在,当有用户请求到达时,LoggingFilter会将请求参数的日志记录为异步任务,并打印在控制台上。
SpringBoot-日志的配置和使用详解(SLF4j、Logback)
SpringBoot-⽇志的配置和使⽤详解(SLF4j、Logback)1,基本介绍(1)市⾯上常见的⽇志框架有很多。
通常情况下,⽇志是由⼀个抽象层+实现层的组合来搭建的,⽽⽤户通常来说不应该直接使⽤具体的⽇志实现类,应该使⽤⽇志的抽象层。
抽象层:JCL(Jakarta Commons Logging)、SLF4j(Simple Logging Facade for Java)、jboss-logging 实现层:Log4j 、JUL(java.util.logging)、Log4j2、Logback(2)SpringBoot 默认选择的是 SLF4J + Logback 的组合,如果不需要更改为其他⽇志系统(如 Log4j2 等),则⽆需多余的配置,LogBack 默认会将⽇志打印到控制台上。
由于新建的 Spring Boot 项⽬⼀般都会引⽤ spring-boot-starter 或者 spring-boot-starter-web,⽽这两个起步依赖中都已经包含了对于 spring-boot-starter-logging 的依赖,所以,我们⽆需额外添加依赖。
2,基本⽤法(1)这⾥我们打印出 5 种不同级别的⽇志,可以看到控制台会输出相关⽇志信息:12 3 4 5 6 7 8 9 10 11 12 13 14@RestControllerpublic class HelloController {Logger logger = LoggerFactory.getLogger(getClass()); @GetMapping("/test")public void test(){logger.trace("Trace ⽇志...");logger.debug("Debug ⽇志...");("Info ⽇志...");logger.warn("Warn ⽇志...");logger.error("Error ⽇志...");}}(2)如果项⽬有使⽤ Lombok 的话,直接使⽤ @Slf4j 注解可以省去从⽇志⼯⼚⽣成⽇志对象这⼀步,直接进⾏⽇志记录。
logback-spring.xml日志文件输出sql语句
logback-spring.xml⽇志⽂件输出sql语句sql输出只能在debug级别才能输出,在需要输出的⽇志⽂件配置项中,将⽇志级别设置为debug⽇志输出级别也设置为debug注意,开启debug⽇志会写⼊⼤量⽇志,建议适⽤于开发调试。
本地调试时,不需要再⽇志⽂件输出sql,可将⽇志级别更改为info,针对特定包下的代码调试可设置如下:完整xml如下:1 <?xml version="1.0" encoding="UTF-8"?>2 <configuration scan="true" scanPeriod="60 seconds">3 <property name="LOG_HOME" value="/datalog/shopping/shopping-goods/"/>4 <property name="FORMAT" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{25} - %msg%n"/>5 <property name="RollingMaxHistory" value="10"/>6 <property name="RollingFileNamePattern" value="${LOG_HOME}/%d{yyyy-MM-dd}.%i"/>789 <!-- 彩⾊⽇志依赖的渲染类 -->10 <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter"/>11 <conversionRule conversionWord="wex"12 converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter"/>13 <conversionRule conversionWord="wEx"14 converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter"/>15 <!-- 彩⾊⽇志格式 -->16 <property name="CONSOLE_LOG_PATTERN"17 value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} % 181920 <!-- 控制台输出 -->21 <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">22 <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">23 <pattern>${CONSOLE_LOG_PATTERN}</pattern>24 <charset>utf8</charset>25 </encoder>26 </appender>272829 <!-- ⽣成INFO⽇志⽂件 -->30 <appender name="INFO-FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">31 <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">32 <!--⽇志⽂件输出的⽂件名-->33 <FileNamePattern>${RollingFileNamePattern}/info/%d{yyyy-MM-dd}.%i-info.log</FileNamePattern>34 <!--⽇志⽂件最⼤的⼤⼩-->35 <maxFileSize>500MB</maxFileSize>36 <!--⽇志⽂件保留天数-->37 <MaxHistory>${RollingMaxHistory}</MaxHistory>38 </rollingPolicy>39 <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">40 <!--格式化输出:%d表⽰⽇期,%thread表⽰线程名,%-5level:级别从左显⽰5个字符宽度%msg:⽇志消息,%n是换⾏符-->41 <pattern>${FORMAT}</pattern>42 </encoder>43 <!-- 打印⽇志级别 -->44 <filter class="ch.qos.logback.classic.filter.LevelFilter">45 <level>debug</level>46 <onMatch>ACCEPT</onMatch>47 <onMismatch>DENY</onMismatch>48 </filter>49 </appender>5051 <!-- ⽣成ERROR⽇志⽂件 -->52 <appender name="ERROR-FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">53 <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">54 <!--⽇志⽂件输出的⽂件名-->55 <FileNamePattern>${RollingFileNamePattern}/error/%d{yyyy-MM-dd}.%i-error.log</FileNamePattern>56 <!--⽇志⽂件最⼤的⼤⼩-->57 <maxFileSize>500MB</maxFileSize>58 <!--⽇志⽂件保留天数-->59 <MaxHistory>${RollingMaxHistory}</MaxHistory>60 </rollingPolicy>61 <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">62 <!--格式化输出:%d表⽰⽇期,%thread表⽰线程名,%-5level:级别从左显⽰5个字符宽度%msg:⽇志消息,%n是换⾏符-->63 <pattern>${FORMAT}</pattern>64 </encoder>65 <!-- 打印⽇志级别 -->66 <filter class="ch.qos.logback.classic.filter.LevelFilter">67 <level>ERROR</level>68 <onMatch>ACCEPT</onMatch>69 <onMismatch>DENY</onMismatch>70 </filter>71 </appender>7273 <!-- ⽇志输出级别 -->74 <root level="debug">75 <appender-ref ref="STDOUT"/>76 <appender-ref ref="INFO-FILE"/>77 <appender-ref ref="ERROR-FILE"/>78 </root>798081 <logger name="druid.sql" level="INFO"/>82 <logger name="com.shopping.goods.mapper" level="DEBUG">83 <appender-ref ref="STDOUT" />84 <appender-ref ref="INFO-FILE" />8586 </logger>878889 <!-- 减少nacos⽇志 -->90 <logger name="com.alibaba.nacos" level="ERROR"/>9192 </configuration>。
logback 常用配置详解(三) filter
logback 常用配置详解(三)<filter><filter>:过滤器,执行一个过滤器会有返回个枚举值,即DENY,NEUTRAL,ACCEPT其中之一。
返回DENY,日志将立即被抛弃不再经过其他过滤器;返回NEUTRAL,有序列表里的下个过滤器过接着处理日志;返回ACCEPT,日志会被立即处理,不再经过剩余过滤器。
过滤器被添加到<Appender>中,为<Appender>添加一个或多个过滤器后,可以用任意条件对日志进行过滤。
<Appender>有多个过滤器时,按照配置顺序执行。
下面是几个常用的过滤器:LevelFilter:级别过滤器,根据日志级别进行过滤。
如果日志级别等于配置级别,过滤器会根据onMath 和 onMismatch接收或拒绝日志。
有以下子节点:<level>:设置过滤级别<onMatch>:用于配置符合过滤条件的操作<onMismatch>:用于配置不符合过滤条件的操作例如:将过滤器的日志级别配置为INFO,所有INFO级别的日志交给appender 处理,非INFO级别的日志,被过滤掉。
Xml代码1.<configuration>2.<appender name="CONSOLE"class="ch.qos.logback.core.ConsoleAppender">3.<filter class="ch.qos.logback.classic.filter.LevelFilter">4.<level>INFO</level>5.<onMatch>ACCEPT</onMatch>6.<onMismatch>DENY</onMismatch>7.</filter>8.<encoder>9.<pattern>10. %-4relative [%thread] %-5level %logger{30} - %msg%n11. </pattern>12. </encoder>13. </appender>14. <root level="DEBUG">15. <appender-ref ref="CONSOLE"/>16. </root>17.</configuration>ThresholdFilter:临界值过滤器,过滤掉低于指定临界值的日志。
logback配置文件详解
logback配置⽂件详解logback介绍和配置详解logback是Java的开源框架,性能⽐log4j要好。
是springboot⾃带的⽇志框架。
该框架主要有3个模块:logback-core:核⼼代码块(不介绍)log back-classic:实现了slf4j的api,加⼊该依赖可以实现log4j的api。
log back-access:访问模块与servlet容器集成提供通过http来访问⽇志的功能(也就是说不需要访问服务器,直接在⽹页上就可以访问⽇志⽂件)。
⼀、logback的使⽤引⼊maven依赖<dependency><groupId>ch.qos.logback</groupId><artifactId>logback-classic</artifactId></dependency>logback.xml格式详解configuration根节点<configuration>,包含下⾯三个属性: scan: 当此属性设置为true时,配置⽂件如果发⽣改变,将会被重新加载,默认值为true。
scanPeriod: 设置监测配置⽂件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒。
当scan为true时,此属性⽣效。
默认的时间间隔为1分钟。
debug: 当此属性设置为true时,将打印出logback内部⽇志信息,实时查看logback运⾏状态。
默认值为false。
<configuration scan="true" scanPeriod="60 seconds" debug="false"> <!--其他配置省略--></configuration> ⼦节点contextName⽤来设置上下⽂名称Property⼦节点<property> :⽤来定义变量值,它有两个属性name和value,通过<property>定义的值会被插⼊到logger上下⽂中,可以使“${}”来使⽤变量。
logback的使用和logback.xml详解
logback的使⽤和logback.xml详解⼀、logback的介绍logback-core:其它两个模块的基础模块logback-classic:它是log4j的⼀个改良版本,同时它完整实现了slf4j API使你可以很⽅便地更换成其它⽇志系统如log4j或JDK14 Logginglogback-access:访问模块与Servlet容器集成提供通过Http来访问⽇志的功能⼆、logback取代log4j的理由:1. 更快的实现:Logback的内核重写了,在⼀些关键执⾏路径上性能提升10倍以上。
⽽且logback不仅性能提升了,初始化内存加载也更⼩了。
2. ⾮常充分的测试:Logback经过了⼏年,数不清⼩时的测试。
Logback的测试完全不同级别的。
3. Logback-classic⾮常⾃然实现了SLF4j:Logback-classic实现了SLF4j。
在使⽤SLF4j中,你都感觉不到logback-classic。
⽽且因为logback-classic⾮常⾃然地实现了slf4j ,所以切换到log4j或者其他,⾮常容易,只需要提供成另⼀个jar包就OK,根本不需要去动那些通过SLF4JAPI实现的代码。
4. ⾮常充分的⽂档官⽅⽹站有两百多页的⽂档。
5. ⾃动重新加载配置⽂件,当配置⽂件修改了,Logback-classic能⾃动重新加载配置⽂件。
扫描过程快且安全,它并不需要另外创建⼀个扫描线程。
这个技术充分保证了应⽤程序能跑得很欢在JEE环境⾥⾯。
6. Lilith是log事件的观察者,和log4j的chainsaw类似。
⽽lilith还能处理⼤数量的log数据。
7. 谨慎的模式和⾮常友好的恢复,在谨慎模式下,多个FileAppender实例跑在多个JVM下,能够安全地写道同⼀个⽇志⽂件。
RollingFileAppender会有些限制。
Logback的FileAppender和它的⼦类包括 RollingFileAppender能够⾮常友好地从I/O异常中恢复。
如何在logback日志配置里获取服务器ip和端口
如何在logback⽇志配置⾥获取服务器ip和端⼝⽬录logback⽇志配置获取服务器ip和端⼝1、新建⼀个类继承ClassicConverter2、在配置⽂件logback.xml增加如下配置3、在需要⽤到ip的位置这样写: %ip4、获取端⼝号,同理让Logback⽇志中显⽰主机名与IP地址及⼀切你想显⽰的1、创建2、重新⽅法3、配置logback.xmllogback⽇志配置获取服务器ip和端⼝1、新建⼀个类继承ClassicConverter在⽅法中获取服务器ippackage mon;import ch.qos.logback.classic.pattern.ClassicConverter;import ch.qos.logback.classic.spi.ILoggingEvent;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import .InetAddress;import .UnknownHostException;/*** @author xiaoming* @date 2019/5/14 11:37* @description*/public class LogIpConfig extends ClassicConverter {private static final Logger logger = LoggerFactory.getLogger(LogIpConfig .class);private static String webIP;static {try {webIP = InetAddress.getLocalHost().getHostAddress();} catch (UnknownHostException e) {logger.error("获取⽇志Ip异常", e);webIP = null;}}@Overridepublic String convert(ILoggingEvent event) {return webIP;}}2、在配置⽂件logback.xml增加如下配置<conversionRule conversionWord="ip" converterClass="mon.LogIpConfig" />3、在需要⽤到ip的位置这样写: %ip"host": "%ip" 这样写,本地⽇志输⼊的时候内容是: "host": "127.0.0.1"4、获取端⼝号,同理package mon;import ch.qos.logback.classic.pattern.ClassicConverter;import ch.qos.logback.classic.spi.ILoggingEvent;import ng3.ObjectUtils;import ng3.StringUtils;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import javax.management.MBeanServer;import javax.management.MBeanServerFactory;import javax.management.ObjectName;import java.util.HashSet;import java.util.Iterator;import java.util.List;import java.util.Set;/*** @author xiaoming* @date 2019/5/14 11:37* @description*/public class LogPortConfig extends ClassicConverter {private static final Logger logger = LoggerFactory.getLogger(LogPortConfig.class);private static String webPort;static {try {List<MBeanServer> serverList = MBeanServerFactory.findMBeanServer(null);for (MBeanServer server : serverList) {Set<ObjectName> names = new HashSet<ObjectName>();names.addAll(server.queryNames(new ObjectName("Catalina:type=Connector,*"), null));Iterator<ObjectName> it = names.iterator();while (it.hasNext()) {ObjectName oName = (ObjectName) it.next();String pValue = (String) server.getAttribute(oName, "protocol");if (StringUtils.equals("HTTP/1.1", pValue)) {webPort = ObjectUtils.toString(server.getAttribute(oName, "port"));}}}} catch (Exception e) {logger.error("获取port失败,影响logback的⽂件拼接", e);webPort = null;}}@Overridepublic String convert(ILoggingEvent event) {return webPort;}}<conversionRule conversionWord="port" converterClass="mon.LogPortConfig" />%ip:%port让Logback⽇志中显⽰主机名与IP地址及⼀切你想显⽰的1、创建⼀个类继承⾃ch.qos.logback.classic.pattern.ClassicConverter2、重新⽅法@Overridepublic String convert(ILoggingEvent event) {}3、配置logback.xml<conversionRule conversionWord="sulong" converterClass="SulongClass" /><!--配置⽇志的格式--><property name="CONSOLE_LOG_PATTERN" value="%sulong %date{yyyy-MM-dd HH:mm:ss} | %highlight(%-5level) | %yellow(%thread) | %green(%logger) | %msg%n"/>以上为个⼈经验,希望能给⼤家⼀个参考,也希望⼤家多多⽀持。
JPA使用logback输出SQL日志到文件
JPA使⽤logback输出SQL⽇志到⽂件通常的logback配置⽂件是这样:<?xml version="1.0" encoding="UTF-8"?><configuration debug="false"><!--输出到控制台--><appender name="console" class="ch.qos.logback.core.ConsoleAppender"><encoder><pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern></encoder></appender><!--输出到⽂件--><appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender"><rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"><fileNamePattern>logback.%d{yyyy-MM-dd}.log</fileNamePattern></rollingPolicy><encoder><pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern></encoder></appender><root level="info"><appender-ref ref="console"/><appender-ref ref="file"/></root></configuration>我们使⽤的是spring boot⾃带的logback所以pom⽂件不⽤做调整,只需要加上JPA相关代码即可。
spring-bootlogback日志常用配置解释(日志压缩和限制日志总体大小)
spring-bootlogback⽇志常⽤配置解释(⽇志压缩和限制⽇志总体⼤⼩)1)引⼊spring-boot默认⽇志系统就是logback⽇志框架spring-boot引⼊logback的maven依赖关系树如下:2)配置在application.properties⽂件中#backlog settinglogging.config=logback-spring.xml或者在 application-dev.yml⽂件中logging:config: classpath:logback-spring.xmllogback-spring.xml配置详解<?xml version="1.0" encoding="UTF-8"?><configuration scan="false" scanPeriod="10 seconds">scan:当此属性设置为true时,配置⽂件如果发⽣改变,将会被重新加载,默认值为true。
(这个功能可以在不重启运⾏环境下,调整打印⽇志的细节,⽅便定位问题)scanPeriod:设置监测配置⽂件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒。
当scan为true时,此属性⽣效。
默认的时间间隔为1分钟。
debug:当此属性设置为true时,将打印出logback内部⽇志信息,实时查看logback运⾏状态。
默认值为false。
Logger 可以被分配级别。
级别包括:TRACE、DEBUG、INFO、WARN 和 ERROR级别排序为: TRACE < DEBUG < INFO < WARN < ERROR<!-- -->logger:⽇志所处的包level:⽇志打印级别<logger name="org.springframework" level="WARN"/><logger name="org.apache.activemq" level="INFO"/><logger name="org.apache.zookeeper" level="INFO"/>com.alibaba.dubbo是dubbo服务的包,在如何是info⼀下的级别会产⽣⼤量的启动⽇志,调成WARN减少⽇志输出<logger name="com.alibaba.dubbo" level="WARN"/>com.ztev.audit.dao是本项⽬的dao层的包,把这个包的打印⽇志级别调成 DEBUG级别可以看到sql执⾏<logger name="com.ztev.audit.dao" level="DEBUG"/><logger name="com.ztev.cardNoVin.dao" level="DEBUG"/><!--⽂件输出的格式设置 --><appender name="FILE"class="ch.qos.logback.core.rolling.RollingFileAppender"><!-- ⽂件输出的⽇志的格式 --><encoder><pattern>[ %-5level] [%date{yyyy-MM-dd HH:mm:ss}] %logger{96} [%line] - %msg%n</pattern><charset>UTF-8</charset><!-- 此处设置字符集,防⽌中⽂乱码 --></encoder>样例:[ INFO ] [2017-06-09 15:15:59] .NioSelectorPool [179] - Using a shared selector for servlet[ %-5level] [%date{yyyy-MM-dd HH:mm:ss}] %logger{96} [%line] %msg%n、level⽇志级别时间打印⽇志所处包.类出现代码⾏⽇志信息<!-- 配置⽇志所⽣成的⽬录以及⽣成⽂件名的规则在logs/mylog-2016-10-31.0.log --><rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"><fileNamePattern>logs/mylog-%d{yyyy-MM-dd}.%i.log</fileNamePattern><timeBasedFileNamingAndTriggeringPolicyclass="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP"><!-- 最⼤64MB 超过最⼤值,会重新建⼀个⽂件--><maxFileSize>64 MB</maxFileSize></timeBasedFileNamingAndTriggeringPolicy></rollingPolicy><filter>:过滤器,执⾏⼀个过滤器会有返回个枚举值,即DENY,NEUTRAL,ACCEPT其中之⼀。
springboot使用logback文件查看错误日志过程详解
springboot使⽤logback⽂件查看错误⽇志过程详解这篇⽂章主要介绍了springboot使⽤logback⽂件查看错误⽇志过程详解,⽂中通过⽰例代码介绍的⾮常详细,对⼤家的学习或者⼯作具有⼀定的参考学习价值,需要的朋友可以参考下<?xml version="1.0" encoding="UTF-8"?><!-- 从⾼到地低 OFF 、 FATAL 、 ERROR 、 WARN 、 INFO 、 DEBUG 、 TRACE 、 ALL --><!-- ⽇志输出规则根据当前ROOT 级别,⽇志输出时,级别⾼于root默认的级别时会输出 --><!-- 以下每个配置的 filter 是过滤掉输出⽂件⾥⾯,会出现⾼级别⽂件,依然出现低级别的⽇志信息,通过filter 过滤只记录本级别的⽇志--><!-- 属性描述 scan:性设置为true时,配置⽂件如果发⽣改变,将会被重新加载,默认值为true scanPeriod:设置监测配置⽂件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒。
当scan为true时,此属性⽣效。
默认的时间间隔为1分钟。
debug:当此属性设置为true时,将打印出logback内部⽇志信息,实时查看logback运⾏状态。
默认值为false。
--><configuration scan="true" scanPeriod="60 seconds" debug="false"><springProperty scope="context" name="logLevel" source="log.level"/><property name="logPath" value="G:/idjavacode/industry3/doc"></property><!-- 定义⽇志⽂件输⼊位置 --><property name="log_dir" value="${logPath}/vegetable-shop-api" /><!--<property name="log_dir" value="./logs/order-admin-api" />--><!-- ⽇志最⼤的历史 30天 --><property name="maxHistory" value="365"/><!-- ConsoleAppender 控制台输出⽇志 --><appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"><!-- 对⽇志进⾏格式化 --><encoder><pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level- %caller{1} -%msg%n</pattern><charset>UTF-8</charset></encoder></appender><!-- ERROR级别⽇志 --><!-- 滚动记录⽂件,先将⽇志记录到指定⽂件,当符合某个条件时,将⽇志记录到其他⽂件 RollingFileAppender--><appender name="INFO" class="ch.qos.logback.core.rolling.RollingFileAppender"><!-- 过滤器,只记录WARN级别的⽇志 --><filter class="ch.qos.logback.classic.filter.LevelFilter"><level>DEBUG</level></filter><!-- 最常⽤的滚动策略,它根据时间来制定滚动策略.既负责滚动也负责出发滚动 --><rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy"><!--⽇志输出位置可相对、和绝对路径 --><fileNamePattern>${log_dir}/%d{yyyy-MM-dd}/logback_vegetable-shop-api_info-log-%d{yyyy-MM-dd}.%i.log</fileNamePattern><maxFileSize>10MB</maxFileSize><maxHistory>360</maxHistory><totalSizeCap>20GB</totalSizeCap></rollingPolicy><encoder><pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level-%caller{1} - %msg%n</pattern><charset>GBK</charset></encoder></appender><appender name="ERROR" class="ch.qos.logback.core.rolling.RollingFileAppender"><filter class="ch.qos.logback.classic.filter.LevelFilter"><level>ERROR</level><onMatch>ACCEPT</onMatch><onMismatch>DENY</onMismatch></filter><encoder><pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level-%caller{1} - %msg%n</pattern><charset>GBK</charset></encoder> <!--滚动策略--><rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy"> <!--路径--><fileNamePattern>${log_dir}/%d{yyyy-MM-dd}/vegetable-shop-api_error-log-%d{yyyy-MM-dd}.%i.log</fileNamePattern><maxFileSize>10MB</maxFileSize><maxHistory>360</maxHistory><totalSizeCap>20GB</totalSizeCap></rollingPolicy></appender><logger name="java.sql.PreparedStatement" level="DEBUG" /><logger name="java.sql.Connection" level="DEBUG" /><logger name="java.sql.Statement" level="DEBUG" /><logger name="com.ibatis" level="INFO" /><logger name="mon.jdbc.SimpleDataSource" level="INFO" /><logger name="mon.jdbc.ScriptRunner" level="INFO"/><logger name="com.ibatis.sqlmap.engine.impl.SqlMapClientDelegate" level="DEBUG" /><logger name="org.springframework" level="INFO" /><!-- root级别 DEBUG --><root level="${logLevel}"><!-- 控制台输出 --><appender-ref ref="STDOUT" /><!-- ⽂件输出 --><appender-ref ref="INFO" /><appender-ref ref="ERROR" /></root></configuration>这⼀份logback描述的并不是太完整在yml⽂件中进⾏配置的⽂件是:# logbacklog:path:level: INFO以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。
JavaSpringBootlombok日志配置输出格式
JavaSpringBootlombok⽇志配置输出格式pom.xml<dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.10</version></dependency>logback-spring.xml<?xml version="1.0" encoding="UTF-8"?><!-- ⽇志级别从低到⾼分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL,如果设置为WARN,则低于WARN的信息都不会输出 --><!-- scan:当此属性设置为true时,配置⽂档如果发⽣改变,将会被重新加载,默认值为true --><!-- scanPeriod:设置监测配置⽂档是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒。
当scan为true时,此属性⽣效。
默认的时间间隔为1分钟。
--><!-- debug:当此属性设置为true时,将打印出logback内部⽇志信息,实时查看logback运⾏状态。
默认值为false。
--><configuration scan="true" scanPeriod="10 seconds"><contextName>logback-spring</contextName><!-- 定义⽇志存储的路径,不要配置相对路径 --><property name="FILE_PATH_DEBUG" value="debug/%d{yyyy-MM-dd}.%i.log" /><property name="FILE_PATH_INFO" value="info/%d{yyyy-MM-dd}.%i.log" /><property name="FILE_PATH_WARN" value="warn/%d{yyyy-MM-dd}.%i.log" /><property name="FILE_PATH_ERROR" value="error/%d{yyyy-MM-dd}.%i.log" /><!-- name的值是变量的名称,value的值时变量定义的值。
一次Logback日志无法在Linux上输出的解决过程
⼀次Logback⽇志⽆法在Linux上输出的解决过程之前,在Linux上查看⽇志,⼀直是⽤:tail -f catalina.out 的⽅式,只能实时看,没有记录⽂件,很不⽅便于是决定把"⽼项⽬"(是spring MVC的项⽬,spring boot的绕道)的⽇志全部切换成logback的(⾄于为什么要选logback,有疑问的请⾃⾏百度),并以⽇志⽂件存留先说⼀下,⽼项⽬之前启动⼀直是有⼀个警告的:(A)SLF4J: Class path contains multiple SLF4J bindings. 就是有冲突⽇志⽂件,但是由于不影响项⽬启动,所以没有多管。
但是现在就是要管⼀管TA,由于⽼项⽬pom⽂件有点⼤,也有好多冗余,就不再说⼀些细节,提供⼀些解决问题的思考⽅向:最开始的警告是这样的:ERROR StatusLogger No Log4j context configuration provided. This is very unusual.SLF4J: Class path contains multiple SLF4J bindings.SLF4J: Found binding in [jar:file:/opt/min_meerkat_test/meerkat/apache-tomcat-7.0.79/webapps/meerkat-web/WEB-INF/lib/log4j-slf4j-impl-2.4.1.jar!/org/slf4j/impl/StaticLoggerBinder.class] SLF4J: Found binding in [jar:file:/opt/min_meerkat_test/meerkat/apache-tomcat-7.0.79/webapps/meerkat-web/WEB-INF/lib/logback-classic-1.2.3.jar!/org/slf4j/impl/StaticLoggerBinder.class] SLF4J: Found binding in [jar:file:/opt/min_meerkat_test/meerkat/apache-tomcat-7.0.79/webapps/meerkat-web/WEB-INF/lib/slf4j-log4j12-1.6.6.jar!/org/slf4j/impl/StaticLoggerBinder.class] SLF4J: See /codes.html#multiple_bindings for an explanation.SLF4J: Actual binding is of type [org.apache.logging.slf4j.Log4jLoggerFactory]ERROR StatusLogger No log4j2 configuration file found. Using default configuration: logging only errors to the console.第⼀步:直接在pom.xm⽤ <exclusion> 标签找到有引⼊其他⽇志依赖的,给“剔除”掉这⾥多说⼀下,有些⼀层依赖的,像下⾯zookeeper依赖这样的,剔除⽐较简单剔除如下: <dependency><groupId>org.apache.zookeeper</groupId><artifactId>zookeeper</artifactId><version>3.4.12</version><!--排除这个slf4j-log4j12--><exclusions><exclusion><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId></exclusion><exclusion><groupId>log4j</groupId><artifactId>log4j</artifactId></exclusion></exclusions></dependency>但是有的是嵌套多层的,就⽐较⿇烦了,⽐如下⾯这种:剔除就⿇烦⼀点,如下:<dependency><groupId>org.apache.hive</groupId><artifactId>hive-common</artifactId><version>${hive.version}</version><exclusions><exclusion><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-1.2-api</artifactId></exclusion><exclusion><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-slf4j-impl</artifactId></exclusion><exclusion><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-web</artifactId></exclusion></exclusions></dependency><dependency><groupId>org.apache.hive</groupId><artifactId>hive-jdbc</artifactId><version>${hive.version}</version><exclusions><exclusion><groupId>org.apache.hive</groupId><artifactId>hive-common</artifactId></exclusion></exclusions></dependency>PS:就是先把整个 hive-common 给剔除掉,但是这样对⼀些功能是有影响的,所以再单独引⼊ hive-common依赖,再在⾥⾯把不想要的⽇志包剔除掉其他的类似处理思路,如果依赖⽐较少,IDEA有⼀种很快发现重复依赖的⽅式:左侧maven最上⽅的⼀排图标⾥⾯,有⼀个Show Dependencies,点开看,⼗分⽅便!第⼆步:通过第⼀步的“剔除”,正常是应该把其他⾮logback的都⼲掉了的,但是有⼀些,或者项⽬乱七⼋糟的的依赖多了,你是发现不了的,那么还有⼀种⽅式,强⾏把其他⽇志的输出“适配”到SLF4j上,⽬前发现有这⼏种:<!-- log4j 输出到 slf4j --><dependency><groupId>org.slf4j</groupId><artifactId>log4j-over-slf4j</artifactId><version>${slf4j.version}</version></dependency><!-- common-logging 输出到 slf4j --><dependency><groupId>org.slf4j</groupId><artifactId>jcl-over-slf4j</artifactId><version>${slf4j.version}</version></dependency><!-- java.util.logging 输出到 slf4j --><dependency><groupId>org.slf4j</groupId><artifactId>jul-to-slf4j</artifactId><version>${slf4j.version}</version></dependency>就是把其他⽇志的输出强⾏⽤统⼀的SLF4j来打印,但是这样做会引发另⼀个警告:SLF4J: Detected both log4j-over-slf4j.jar AND slf4j-log4j12.jar on the class path, preempting StackOverflowError.翻译⼀下就是:在类路径上检测到log4j-over-slf4j.jar和slf4j-log4j12.jar,防⽌堆栈溢出错误这⾥补充⼀点,笔者⽤第⼀步的⽅式剔除能找到的其他⽇志后,启动时发现还是警告:SLF4J: Class path contains multiple SLF4J bindings.SLF4J: Found binding in [jar:file:/D:/mavenStore/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:/D:/mavenStore/repository/org/slf4j/slf4j-log4j12/1.6.6/slf4j-log4j12-1.6.6.jar!/org/slf4j/impl/StaticLoggerBinder.class]//SLF4J: Actual binding is of type [ch.qos.logback.classic.util.ContextSelectorStaticBinder]所以额外⼜引⼊了 log4j-over-slf4j 这个依赖,引⼊后,原来项⽬⽤ log4j 引⼊写⽇志的地⽅都会报错,需要⼀⼀修改过来!(笔者就是当发现项⽬开始报错时,就发现转机来了,后⾯处理的思路就清晰了。
lombok中日志的用法
lombok中日志的用法
在使用Lombok框架时,可以通过注解来简化日志记录的代码。
下面是使用Lombok进行日志记录的一些示例用法:
1. 引入依赖:首先,在项目的构建文件中引入Lombok的依赖,如Maven项目的pom.xml文件中添加以下依赖。
2. 添加Lombok注解:在需要记录日志的类上添加`@Slf4j`注解。
3. 使用日志打印:在需要打印日志的地方,可以直接使用`log`对象进行日志记录,而无需手动创建Logger对象。
这样就可以通过Lombok框架简化了日志记录的代码。
需要注意的是,使用Lombok要确保IDE(如IntelliJ IDEA)已经安装了相应的Lombok插件,并且在项目的构建工具中正确配置了Lombok的支持。
另外,还需要在项目的日志配置文件中设置相应的日志级别和输出格式等配置。
希望这些信息能对您有帮助!。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Spring MVC中使用logback的日志配置
分类:LOGBACK2014-06-11 16:51 1280人阅读评论(0) 收藏举报一开始在SpringMVC中就配置了logback.xml,但是由于放置的路径不正确,不知道怎么启动这个日志系统。
后来在网上看了别人的说明,logback.xml配置都差不多,只需要放置src包下面就会自动启动日志了。
需要导入的jar包有:logback-core-0.9.29.jar,
logback-classic-0.9.29.jar,slf4j-api-1.6.1.jar
下面来看看logback.xml里面的内容配置:
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<!-- 日志保存路径为tomcat下面的logs下面的mobileLog文件夹,logback会自动创建文件夹,这样设置了就可以输出日志文件了-->
<substitutionProperty name="logbase"
value="${catalina.base}/logs/mobileLog/" />
<!-- 这个是要配置输出文件的-->
<jmxConfigurator />
<appender name="stdout"
class="ch.qos.logback.core.ConsoleAppender">
<layout class="ch.qos.logback.classic.PatternLayout">
<pattern>%date [%thread] %-5level %logger{80} - %msg%n</pattern> </layout>
</appender>
<!-- 文件输出日志(文件大小策略进行文件输出,超过指定大小对文件备份) -->
<appender name="logfile"
class="ch.qos.logback.core.rolling.RollingFileAppender">
<Encoding>UTF-8</Encoding>
<rollingPolicy
class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<File>${logbase}%d{yyyy-MM-dd}.log.html</File>
<FileNamePattern>${logbase}.%d{yyyy-MM-dd}.log.html.zip</FileNa mePattern>
</rollingPolicy>
<triggeringPolicy
class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
<MaxFileSize>2MB</MaxFileSize>
</triggeringPolicy>
<layout class="ch.qos.logback.classic.html.HTMLLayout">
<pattern>%date%level%thread%10logger%file%line%msg</pattern>
</layout>
</appender>
<!-- Output by Email -->
<!-- <appender name="Email"
class=".SMTPAppender">
<SMTPHost>stmp host name</SMTPHost> <To>Email Address</To>
<To>Email Address</To>
<From>Email Address</From> <Subject>TESTING Email Function: %logger{20} -
%m</Subject> <layout
class="ch.qos.logback.classic.html.HTMLLayout">
<pattern>%date%level%thread%10logger%file%line%msg</pattern> </layout> </appender> -->
<!-- Output to Database -->
<!-- <appender name="DB"
class="ch.qos.logback.classic.db.DBAppender"> <connectionSource class="ch.qos.logback.core.db.DriverManagerConnectionSource"> <driverClass>com.mysql.jdbc.Driver</driverClass>
<url>jdbc:mysql://localhost:3306/test</url> <user>root</user>
<password>trend_dev</password>
</connectionSource> </appender> -->
<root>
<level value="ERROR" />
<appender-ref ref="stdout" />
<appender-ref ref="logfile" />
</root>
</configuration>
使用的时候可以这样定义变量:Logger logger = LoggerFactory.getLogger(AdministratorController.class);需要import两个内容:
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
后面的使用就简单啦~
logger.debug(" 日志记录");
(" 日志记录");
logger.error(" 日志记录");
设置好后,可以输出到文件中,也可以输出到输出框中。