简介

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。

监听器、过滤器和拦截器

监听器、过滤器和拦截器

监听器

监听器Listener，它是实现了javax.servlet.XXXListener接口的服务器端程序，它也是随web应用的启动而启动，只初始化一次，随web应用的停止而销毁。主要作用是：做一些初始化的内容添加工作、设置一些基本的内容、比如一些参数或者是一些固定的对象等等。

在javax.servlet.XXXListener接口中定义了2种方法：

1. void contextInitialized(ServletContextEvent sce) 监听器的初始化
2. void contextDestroyed(ServletContextEvent sce) 监听器销毁

过滤器

Servlet中的过滤器Filter是实现了javax.servlet.Filter接口的服务器端程序，主要的用途是过滤字符编码、做一些业务逻辑判断等。其工作原理是，只要你在web.xml文件配置好要拦截的客户端请求，它都会帮你拦截到请求，此时你就可以对请求或响应(Request、Response)统一设置编码，简化操作；同时还可以进行逻辑判断，如用户是否已经登录、有没有权限访问该页面等等工作，它是随你的web应用启动而启动的，只初始化一次，以后就可以拦截相关的请求，只有当你的web应用停止或重新部署的时候才能销毁。

在javax.servlet.Filter接口中定义了3个方法：

1. void init(FilterConfig filterConfig) 用于完成过滤器的初始化
2. void destroy() 用于过滤器销毁前，完成某些资源的回收
3. void doFilter(ServletRequest request, ServletResponse response,FilterChain chain) 实现过滤功能，该方法对每个请求增加额外的处理

拦截器

拦截器主要是用在插件上，扩展件上比如spring、struts2等有点类似面向切片的技术，它是基于java反射机制。定义拦截器： 实现HandlerInterceptor 接口，或者继承实现了HandlerInterceptor 接口的类（常用） 。

监听器、过滤器和拦截器的关系及区别

• 过滤器（Filter）：当你有一堆东西的时候，你只希望选择符合你要求的某一些东西。定义这些要求的工具，就是过滤器。 对请求起到过滤的作用，它在监听器之后，作用在servlet之前，对请求进行过滤。

• 拦截器（Interceptor）：在一个流程正在进行的时候，你希望干预它的进展，甚至终止它进行，这是拦截器做的事情。

• 监听器（Listener）：当一个事件发生的时候，你希望获得这个事件发生的详细信息，而并不想干预这个事件本身的进程，这就要用到监听器。对项目起到监听的作用，它能感知到包括request(请求域)，session(会话域)和applicaiton(应用程序)的初始化和属性的变化 。对请求和返回进行拦截，它作用在servlet的内部 。

它们之间的关系，可以用一张图来表示：

使用原则

对整个流程清楚之后，然后就是各自的使用，在使用之前应该有一个使用规则，为什么这个说，因为有些功能比如判断用户是否登录，既可以用过滤器，也可以用拦截器，用哪一个才是合理的呢？那么如果有一个原则，使用起来就会更加合理。实际上这个原则是有的：把整个项目的流程比作一条河，那么监听器的作用就是能够听到河流里的所有声音，过滤器就是能够过滤出其中的鱼，而拦截器则是拦截其中的部分鱼，并且作标记。所以当需要监听到项目中的一些信息，并且不需要对流程做更改时，用监听器；当需要过滤掉其中的部分信息，只留一部分时，就用过滤器；当需要对其流程进行更改，做相关的记录时用拦截器。

监听器实现过程

代码注册方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class IndexListener implements ServletContextListener{
    @Override
    public void contextDestroyed(ServletContextEvent arg0) {
        System.out.println("IndexListener contextDestroyed method");
    }
  
    @Override
    public void contextInitialized(ServletContextEvent arg0) {
        System.out.println("IndexListener contextInitialized method");
    }
}
@Bean
public ServletListenerRegistrationBean servletListenerRegistrationBean(){
    ServletListenerRegistrationBean servletListenerRegistrationBean = new ServletListenerRegistrationBean();
    servletListenerRegistrationBean.setListener(new IndexListener());
    return servletListenerRegistrationBean;
}

注解方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

@WebListener
public class IndexListener2 implements ServletContextListener{
    @Override
    public void contextDestroyed(ServletContextEvent arg0) {
        System.out.println("IndexListener2 contextDestroyed method");
    }

    @Override
    public void contextInitialized(ServletContextEvent arg0) {
        System.out.println("IndexListener2 contextInitialized method");
    }
}
@SpringBootApplication
@ServletComponentScan
public class SpringBootSimpleApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootSimpleApplication.class, args);
    }
}

过滤器实现过程

代码注册方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

public class TestFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        if (......) {
            ......
            response.getWriter().write(writeValueAsString);          
        } else {
            chain.doFilter(request, response);
        }

    }

    @Override
    public void destroy() {

    }

}
@Bean
public FilterRegistrationBean  filterRegistrationBean() {
    FilterRegistrationBean registrationBean = new FilterRegistrationBean();

    TestFilter testFilter = new TestFilter();
    registrationBean.setFilter(testFilter);
    List<String> urlPatterns = new ArrayList<String>();
    urlPatterns.add("/service/extract/json/*");

    registrationBean.setUrlPatterns(urlPatterns);

    return registrationBean;
}

注解方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

import javax.servlet.Filter;  
import javax.servlet.FilterChain;  
import javax.servlet.FilterConfig;  
import javax.servlet.ServletException;  
import javax.servlet.ServletRequest;  
import javax.servlet.ServletResponse;  
import javax.servlet.annotation.WebFilter;  

/** 
 * 实现javax.servlet.Filter,覆盖其三个方法 
 * @author Administrator 
 * 
 */  
@WebFilter(filterName="testFilter",urlPatterns="/*")  
public class TestFilter implements Filter{  
  
    @Override  
    public void destroy() {  
        System.out.println("TestFilter过滤器销毁");  
          
    }  
  
    @Override  
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)  
            throws IOException, ServletException {  
        System.out.println("TestFilter指定过滤器操作......");  
        //执行操作后必须doFilter  
        chain.doFilter(request, response);  
    }  
  
    @Override  
    public void init(FilterConfig arg0) throws ServletException {  
        System.out.println("TestFilter初始化......");  
    }  
  
}  
@SpringBootApplication
@ServletComponentScan
public class SpringBootSimpleApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootSimpleApplication.class, args);
    }
}

拦截器实现过程

1. 创建自己的拦截器实现HandlerInterceptor接口
2. 创建自己的拦截器链，继承WebMvcConfigurerAdapter类，重写addInterceptors方法。
3. 实例化自己的拦截器，并加入到拦截器链中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  
import org.springframework.web.servlet.HandlerInterceptor;  
import org.springframework.web.servlet.ModelAndView;  
  
public class CustomInterceptor implements HandlerInterceptor {  
  
    @Override  
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object object,  
            Exception exception) throws Exception {  
        //在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）  
        System.out.println("3. 整个请求结束之后被调用......CustomInterceptor1......");  
    }  
  
    @Override  
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object object, ModelAndView view)  
            throws Exception {  
        // 请求处理之后进行调用，但是在视图被渲染之前  
        System.out.println("2. 请求处理之后进行调用，但是在视图被渲染之前......CustomInterceptor1......");  
    }  
  
    @Override  
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object object) throws Exception {  
        // 在请求处理之前进行调用  
        System.out.println("1. 在请求处理之前进行调用......CustomInterceptor1......");  
        // 只有返回true才会继续向下执行，返回false取消当前请求  
        return true;  
    }  
  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import org.springframework.context.annotation.Configuration;  
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;  
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;  
  
import com.example.Interceptor.CustomInterceptor;  
import com.example.Interceptor.CustomInterceptor2;  
  
/** 
 * 继承WebMvcConfigurerAdapter，复写addInterceptors方法 
 * @author Administrator 
 * 
 */  
@Configuration  
public class WebAdapter extends WebMvcConfigurerAdapter{  
    /** 
     * 主要方法说明： 
     * addPathPatterns 用于添加拦截规则 
     * excludePathPatterns 用于排除拦截 
     */  
    @Override  
    public void addInterceptors(InterceptorRegistry registry) {  
        //众多的拦截器组成了一个拦截器链
        registry.addInterceptor(new CustomInterceptor()).addPathPatterns("/*");  

        super.addInterceptors(registry);  
    }  
}

默认日志logback配置

日志简介

Spring Boot使用Commons Logging记录所有内部日志，但是它将底层日志实现打开，为Java.Util.Logging，Log4J2和Logback提供默认配置。 在每个案例中，loggers都预先配置，以使用控制台输出，同时还提供可选的文件输出。

默认情况下，如果你使用“starters”，Logback将会被用于记录日志。还包括占用Logback路由，以确保使用Java Util Logging、Commons logging、Log4J或SLF4J的依赖库都能正常工作。

默认日志logback

logback日志简介

SLF4J——Simple Logging Facade For Java，它是一个针对于各类Java日志框架的统一Facade抽象。Java日志框架众多——常用的有java.util.logging, log4j, logback，commons-logging, Spring框架使用的是Jakarta Commons Logging API (JCL)。而SLF4J定义了统一的日志抽象接口，而真正的日志实现则是在运行时决定的——它提供了各类日志框架的绑定。

Logback是log4j框架的作者开发的新一代日志框架，它效率更高、能够适应诸多的运行环境，同时天然支持SLF4J。

默认情况下，Spring Boot会用Logback来记录日志，并用INFO级别输出到控制台。在运行应用程序和其他例子时，可以看到很多INFO级别的日志。

从上图可以看到，日志输出内容元素具体如下：

• 时间日期：精确到毫秒
• 日志级别：ERROR, WARN, INFO, DEBUG or TRACE
• 进程ID
• 分隔符：— 标识实际日志的开始
• 线程名：方括号括起来（可能会截断控制台输出）
• Logger名：通常使用源代码的类名
• 日志内容

用Logback来记录日志，需添加日志依赖

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。

application.properties配置中的日志相关属性

控制台输出

日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出。Spring Boot中默认配置ERROR、WARN和INFO级别的日志输出到控制台。您还可以通过启动您的应用程序–debug标志来启用“调试”模式（开发的时候推荐开启）,以下两种方式皆可：

• 在运行命令后加入–debug标志，如：

1

$ java -jar springTest.jar --debug

• 在application.properties中配置debug=true

该属性置为true的时候，核心Loggers（包含嵌入式容器、hibernate、spring）会输出更多内容，启用debug模式并不会使用debug级别配置您的应用程序来记录所有信息。或者，您可以通过在应用程序中使用-trace标志(或在application.properties中配置trace=true)启动应用程序来启用“跟踪”模式。

文件输出

默认情况下，Spring Boot将日志输出到控制台，不会写到日志文件。如果要编写除控制台输出之外的日志文件，则需在application.properties中设置logging.file或logging.path属性。

• logging.file，设置指定的日志文件，可以是绝对路径，也可以是相对路径。如：logging.file=my.log
• logging.path，设置指定的目录，会在该目录下创建spring.log文件，并写入日志内容，如：logging.path=/var/log

默认情况下，日志文件的大小达到10MB时会切分一次，产生新的日志文件，默认级别为：ERROR、WARN、INFO
日志系统在应用程序生命周期的早期被初始化，并且在通过@propertysource注解加载的属性文件中不会找到这样的日志属性。
日志属性与实际的日志基础结构无关。因此，特定的配置键(例如logback中的 logback.configurationFile )不是由spring boot管理的。

彩色日志输出

  省略...     

日志级别

所有支持日志记录的系统都可以在Spring环境中设置记录级别（例如在application.properties中）
格式为：’logging.level.* = LEVEL’

logging.level：日志级别控制前缀，*为包名或Logger名

LEVEL：选项TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF

root日志可以使用 logging.level.root 配置，application.properties实例：

1
2
3

logging.level.root=WARN
logging.level.org.springframework.web=DEBUG
logging.level.org.hibernate=ERROR

默认情况下，Spring boot对 Thymeleaf INFO 消息进行了重新映射，使它们在调试级别上被记录，这有助于减少标准日志输出中的噪声。有关如何在自己的配置中应用重新映射的详细信息，请参阅LevelRemappingAppender。

自定义日志配置

可以通过在classpath中包含适当的库来激活各种日志系统，并通过在classpath根目录提供适当的配置进行定制。或者在适当的位置提供spring 环境属性logging.config。

还可以强制spring boot使用特定的日志系统通过使用 org.springframework.boot.logging.LoggingSystem 系统属性。 该值应该是一个 LoggingSystem 实现的完全限定类名。 您还可以使用none值完全禁用Spring boot的日志记录配置。

由于日志是在应用程序applicationContext上下文创建之前初始化的，所以不可能在Spring @configuration注解文件中控制来自@propertySource的日志记录。系统属性和常规的Spring boot外部配置文件已经工作得很好。

根据不同的日志系统，你可以按如下规则组织配置文件名，就能被正确加载：

• Logback：logback-spring.xml, logback-spring.groovy, logback.xml, logback.groovy
• Log4j2：log4j2-spring.xml, log4j2.xml
• JDK (Java Util Logging)：logging.properties

在可能的情况下，我们建议您使用-spring变体来进行日志配置( 如使用logback-spring.xml，而不是logback.xml )。如果使用标准配置logback.xml，Spring无法完全控制日志初始化。 Spring boot包含许多对Logback的扩展，可以帮助高级配置，您可以在您的logback-spring.xml文件中使用这些扩展。在标准配置logback.xml中不能使用这些扩展因为它太早被加载，当然如果一定要使用，需定义一个 logging.config 属性。

注：这些扩展不能与Logback的配置扫描一起使用。如果您尝试这样做，对配置文件进行更改将导致类似于以下日志记录之一的错误:

1
2

ERROR in ch.qos.logback.core.joran.spi.Interpreter@4:71 - no applicable action for [springProperty], current ElementPath is [[configuration][springProperty]]
ERROR in ch.qos.logback.core.joran.spi.Interpreter@4:71 - no applicable action for [springProfile], current ElementPath is [[configuration][springProfile]]

logback日志介绍与配置

logback介绍

Logback是由log4j创始人设计的又一个开源日志组件。logback当前分成三个模块：logback-core,logback- classic和logback-access。logback-core是其它两个模块的基础模块。logback-classic是log4j的一个 改良版本。此外logback-classic完整实现SLF4J API使你可以很方便地更换成其它日志系统如log4j或JDK14 Logging。logback-access访问模块与Servlet容器集成提供通过Http来访问日志的功能。 Logback是要与SLF4J结合起来用两个组件的官方网站如下：

•   logback的官方网站： http://logback.qos.ch
  

•   SLF4J的官方网站：http://www.slf4j.org
  

logback取代log4j的理由

Logback和log4j是非常相似的，如果你对log4j很熟悉，那对logback很快就会得心应手。下面列了logback相对于log4j的一些优点：

• 更快的实现 Logback的内核重写，在一些关键执行路径上性能提升10倍以上。而且logback不仅性能提升，初始化内存加载也更小。

• 非常充分的测试 Logback经过了几年，数不清小时的测试，Logback的测试完全不同级别的。在作者的观点，这是简单重要的原因选择logback而不是log4j。

• Logback-classic非常自然实现了SLF4j 因为logback-classic非常自然地实现了SLF4J， 所 以切换到log4j或者其他，非常容易，只需要提供成另一个jar包就OK，根本不需要去动那些通过SLF4JAPI实现的代码。

• 非常充分的文档 官方网站有两百多页的文档。

• 自动重新加载配置文件 当配置文件修改，Logback-classic能自动重新加载配置文件。扫描过程快且安全，它并不需要另外创建一个扫描线程。

• Lilith Lilith是log事件的观察者，和log4j的chainsaw类似。而lilith还能处理大数量的log数据 。

• 谨慎的模式和非常友好的恢复 在谨慎模式下，多个FileAppender实例跑在多个JVM下，能 够安全地写道同一个日志文件，RollingFileAppender会有些限制。Logback的FileAppender和它的子类包括 RollingFileAppender能够非常友好地从I/O异常中恢复。

• 配置文件可以处理不同的情况 开发人员经常需要判断不同的Logback配置文件在不同的环境下（开发，测试，生产）。

• Filters（过滤器） 有些时候，需要诊断一个问题，需要打出日志。在log4j，只有降低日志级别，不过这样会打出大量的日志，会影响应用性能。在Logback，你可以继续 保持那个日志级别而除掉某种特殊情况，如alice这个用户登录，她的日志将打在DEBUG级别而其他用户可以继续打在WARN级别。要实现这个功能只需 加4行XML配置。可以参考MDCFIlter 。

• SiftingAppender（一个非常多功能的Appender） 它可以用来分割日志文件根据任何一个给定的运行参数。如，SiftingAppender能够区别日志事件跟进用户的Session，然后每个用户会有一个日志文件。

• 自动压缩已经打出来的log RollingFileAppender在产生新文件的时候，会自动压缩已经打出来的日志文件。压缩是个异步过程，所以甚至对于大的日志文件，在压缩过程中应用不会受任何影响。

• 堆栈树带有包版本 Logback在打出堆栈树日志时，会带上包的数据。

• 自动去除旧的日志文件 通过设置TimeBasedRollingPolicy或者SizeAndTimeBasedFNATP的maxHistory属性，你可以控制已经产生日志文件的最大数量。

总之，logback比log4j优秀。

logback配置

Logback 配置文件的语法非常灵活。正因为灵活，所以无法用 DTD 或 XML schema 进行定义。尽管如此，可以这样描述配置文件的基本结构：以开头，后面有零个或多个元素，有零个或多个元素，有最多一个元素。

logback配置文件实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
    <!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径-->  
    <property name="LOG_HOME" value="/home" />  
    <!-- 控制台输出 -->   
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder"> 
             <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符--> 
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>   
        </encoder> 
    </appender>
    <!-- 按照每天生成日志文件 -->   
    <appender name="FILE"  class="ch.qos.logback.core.rolling.RollingFileAppender">   
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--日志文件输出的文件名-->
            <FileNamePattern>${LOG_HOME}/TestWeb.log.%d{yyyy-MM-dd}.log</FileNamePattern> 
            <!--日志文件保留天数-->
            <MaxHistory>30</MaxHistory>
        </rollingPolicy>   
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder"> 
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符--> 
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>   
        </encoder> 
        <!--日志文件最大的大小-->
       <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
         <MaxFileSize>10MB</MaxFileSize>
       </triggeringPolicy>
    </appender> 
    
    <!--myibatis log configure--> 
    <logger name="com.apache.ibatis" level="TRACE"/>
    <logger name="java.sql.Connection" level="DEBUG"/>
    <logger name="java.sql.Statement" level="DEBUG"/>
    <logger name="java.sql.PreparedStatement" level="DEBUG"/>
    
    <!-- 日志输出级别 -->
    <root level="INFO">
        <appender-ref ref="STDOUT" />
        <appender-ref ref="FILE" />
    </root> 
</configuration>

logback日志详解

根节点包含的属性

scan:

当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。

scanPeriod:

设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。

debug:

当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。

例如：

1
2
3

<configuration scan="true" scanPeriod="60 seconds" debug="false"> 
    <!-- 其他配置省略-->
</configuration>

根节点的子节点

设置上下文名称：

每个logger都关联到logger上下文，默认上下文名称为“default”。但可以使用设置成其他名字，用于区分不同应用程序的记录。一旦设置，不能修改。

1
2
3
4

<configuration scan="true" scanPeriod="60 seconds" debug="false">                           
    <contextName>myAppName</contextName> 
    <!-- 其他配置省略--> 
</configuration>

设置变量：

用来定义变量值的标签， 有两个属性，name和value；其中name的值是变量的名称，value的值时变量定义的值。通过定义的值会被插入到logger上下文中。定义变量后，可以使“${}”来使用变量。

例如使用定义上下文名称，然后在设置logger上下文时使用。

1
2
3
4
5

<configuration scan="true" scanPeriod="60 seconds" debug="false"> 
    <property name="APP_Name" value="myAppName" /> 
    <contextName>${APP_Name}</contextName> 
    <!-- 其他配置省略--> 
</configuration>

获取时间戳字符串：

有两个属性，key:标识此 的名字；datePattern：设置将当前时间（解析配置文件的时间）转换为字符串的模式，遵循java.txt.SimpleDateFormat的格式。

例如将解析配置文件的时间作为上下文名称：

1
2
3
4
5

<configuration scan="true" scanPeriod="60 seconds" debug="false"> 
    <timestamp key="bySecond" datePattern="yyyyMMdd'T'HHmmss"/> 
    <contextName>${bySecond}</contextName> 
    <!-- 其他配置省略--> 
</configuration>

设置logger节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

package com.logback;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LogbackDemo {
    private static final Logger log = LoggerFactory.getLogger(LogbackDemo.class);

    public static void main(String[] args) {
        log.trace("======trace");
        log.debug("======debug");
        log.info("======info");
        log.warn("======warn");
        log.error("======error");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

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

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

1
2
3

13:30:38.484 [main] INFO com.logback.LogbackDemo - ======info 
13:30:38.500 [main] WARN com.logback.LogbackDemo - ======warn 
13:30:38.500 [main] ERROR com.logback.LogbackDemo - ======error

1
2
3
4
5
6
7
8
9
10
11
12

<configuration>
	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"> 
<!-- encoder 默认配置为PatternLayoutEncoder -->
		<encoder>
			<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
		</encoder>
	</appender> <!-- com.logback为java中的包 -->
	<logger name="com.logback" />
	<root level="DEBUG">
		<appender-ref ref="STDOUT" />
	</root>
</configuration>

1
2
3
4

13:19:15.406 [main] DEBUG com.logback.LogbackDemo - ======debug 
13:19:15.406 [main] INFO com.logback.LogbackDemo - ======info 
13:19:15.406 [main] WARN com.logback.LogbackDemo - ======warn 
13:19:15.406 [main] ERROR com.logback.LogbackDemo - ======error

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<configuration>
	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"> 
        <!-- encoder 默认配置为PatternLayoutEncoder -->
		<encoder>
			<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
		</encoder>
	</appender> <!-- logback为java中的包 -->
	<logger name="com.logback" /> <!--logback.LogbackDemo：类的全路径 -->
	<logger name="com.logback.LogbackDemo" level="INFO" additivity="false">
		<appender-ref ref="STDOUT" />
	</logger>
	<root level="ERROR">
		<appender-ref ref="STDOUT" />
	</root>
</configuration>

1
2
3

14:05:35.937 [main] INFO  com.logback.LogbackDemo - ======info
14:05:35.937 [main] WARN  com.logback.LogbackDemo - ======warn
14:05:35.937 [main] ERROR com.logback.LogbackDemo - ======error

1
2
3
4
5
6

14:09:01.531 [main] INFO  com.logback.LogbackDemo - ======info
14:09:01.531 [main] INFO  com.logback.LogbackDemo - ======info
14:09:01.531 [main] WARN  com.logback.LogbackDemo - ======warn
14:09:01.531 [main] WARN  com.logback.LogbackDemo - ======warn
14:09:01.531 [main] ERROR com.logback.LogbackDemo - ======error
14:09:01.531 [main] ERROR com.logback.LogbackDemo - ======error

1
2
3
4
5
6
7
8
9
10
11

<configuration>  
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">  
        <encoder>  
            <pattern>%-4relative [%thread] %-5level %logger{35} - %msg %n</pattern>  
        </encoder>  
    </appender>  
  
    <root level="DEBUG">  
        <appender-ref ref="STDOUT" />  
    </root>  
</configuration>

1
2
3
4
5
6
7
8
9
10
11
12
13

<configuration>
	<appender name="FILE" class="ch.qos.logback.core.FileAppender">
		<file>testFile.log</file>
		<append>true</append>
		<encoder>
			<pattern>%-4relative [%thread] %-5level %logger{35} - %msg%n</pattern>
		</encoder>
	</appender>

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<configuration>
	<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">

		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
			<fileNamePattern>logFile.%d{yyyy-MM-dd}.log</fileNamePattern>
			<maxHistory>30</maxHistory>
		</rollingPolicy>

		<encoder>
			<pattern>%-4relative [%thread] %-5level %logger{35} - %msg%n</pattern>
		</encoder>
	</appender>

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

<configuration>
	<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
		<file>test.log</file>

		<rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
			<fileNamePattern>tests.%i.log.zip</fileNamePattern>
			<minIndex>1</minIndex>
			<maxIndex>3</maxIndex>
		</rollingPolicy>

		<triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
			<maxFileSize>5MB</maxFileSize>
		</triggeringPolicy>
		<encoder>
			<pattern>%-4relative [%thread] %-5level %logger{35} - %msg%n</pattern>
		</encoder>
	</appender>

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

1
2
3

<encoder>   
   <pattern>%-4relative [%thread] %-5level %logger{35} - %msg%n</pattern>   
</encoder

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<configuration>
	<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
		<filter class="ch.qos.logback.classic.filter.LevelFilter">
			<level>INFO</level>
			<onMatch>ACCEPT</onMatch>
			<onMismatch>DENY</onMismatch>
		</filter>
		<encoder>
			<pattern>
				%-4relative [%thread] %-5level %logger{30} - %msg%n
			</pattern>
		</encoder>
	</appender>
	<root level="DEBUG">
		<appender-ref ref="CONSOLE" />
	</root>
</configuration>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<configuration>
	<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
		<!-- 过滤掉 TRACE 和 DEBUG 级别的日志 -->
		<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
			<level>INFO</level>
		</filter>
		<encoder>
			<pattern>
				%-4relative [%thread] %-5level %logger{30} - %msg%n
			</pattern>
		</encoder>
	</appender>
	<root level="DEBUG">
		<appender-ref ref="CONSOLE" />
	</root>
</configuration>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<configuration>

	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
		<filter class="ch.qos.logback.core.filter.EvaluatorFilter">
			<evaluator> <!-- 默认为 ch.qos.logback.classic.boolex.JaninoEventEvaluator -->
				<expression>return message.contains("billing");</expression>
			</evaluator>
			<OnMatch>ACCEPT </OnMatch>
			<OnMismatch>DENY</OnMismatch>
		</filter>
		<encoder>
			<pattern>
				%-4relative [%thread] %-5level %logger - %msg%n
			</pattern>
		</encoder>
	</appender>

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

<configuration debug="true">

	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
		<filter class="ch.qos.logback.core.filter.EvaluatorFilter">
			<evaluator>
				<matcher>
					<Name>odd</Name>
					<!-- filter out odd numbered statements -->
					<regex>statement [13579]</regex>
				</matcher>

				<expression>odd.matches(formattedMessage)</expression>
			</evaluator>
			<OnMismatch>NEUTRAL</OnMismatch>
			<OnMatch>DENY</OnMatch>
		</filter>
		<encoder>
			<pattern>%-4relative [%thread] %-5level %logger - %msg%n</pattern>
		</encoder>
	</appender>

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