springboot logback日志配置

时间 2019-11-13

原文原文链接

springboot 若是不使用外部tomcat的话，日志是须要本身配置的，否则的话就只有控制台的日志，可是日志又是咱们在项目上了生产环境，出问题时，检查问题的惟一途径，因此咱们要配置详细的日志。怎么配置呢？其实很简单！java

第一步：修改application-dev.properties的配置文件web

logging.config=classpath:xml/logback-boot.xml

上面的路径时咱们放置日志配置文件的路径，咱们不用去单独的引用log包，由于springboot自己就带有log的包spring

这是我文件的路径json

而后配置logback-boot.xml的内容，我是这样写的（坦白说是这样抄的，哈哈）数组

<configuration>
    <!-- %m输出的信息, %p日志级别, %t线程名, %d日期, %c类的全名, %i索引 -->
    <!-- appender是configuration的子节点,是负责写日志的组件 -->
    <!-- ConsoleAppender把日志输出到控制台 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%date{yyyy-MM-dd HH:mm:ss} %highlight(%-5level) (%file:%line\)- %m%n</pattern>
            <!-- 控制台也要使用utf-8，不要使用gbk -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!-- RollingFileAppender:滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其余文件 -->
    <!-- 1.先按日期存日志，日期变了，将前一天的日志文件名重命名为xxx%日期%索引，新的日志仍然是sys.log -->
    <!-- 2.若是日期没有变化，可是当前日志文件的大小超过1kb时，对当前日志进行分割 重名名 -->
    <appender name="syslog" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <File>log/ant-back.log</File>
        <!-- rollingPolicy:当发生滚动时，决定 RollingFileAppender 的行为，涉及文件移动和重命名。 -->
        <!-- TimeBasedRollingPolicy： 最经常使用的滚动策略，它根据时间来制定滚动策略，既负责滚动也负责出发滚动 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 活动文件的名字会根据fileNamePattern的值，每隔一段时间改变一次 -->
            <!-- 文件名：log/sys.2017-12-05.0.log -->
            <fileNamePattern>log/ant-back.%d.%i.log</fileNamePattern>
            <!-- 每产生一个日志文件，该日志文件的保存期限为120天 -->
            <maxHistory>120</maxHistory>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <!-- maxFileSize:这是活动文件的大小，默认值是10MB,本篇设置为100MB -->
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
        <encoder>
            <!-- pattern节点，用来设置日志的输入格式 -->
            <pattern>
                %d %p (%file:%line\)- %m%n
            </pattern>
            <!-- 记录日志的编码 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>
    <!-- 控制台日志输出级别 -->
    <root level="info">
        <appender-ref ref="STDOUT"/>
    </root>
    <!-- 指定项目中某个包，当有日志操做行为时的日志记录级别 -->
    <!-- com.example.ant为根包，也就是只要是发生在这个根包下面的全部日志操做行为的权限都是DEBUG -->
    <!-- 级别依次为【从高到低】：FATAL > ERROR > WARN > INFO > DEBUG > TRACE  -->
    <logger name="com.example.ant" level="FATAL">
        <appender-ref ref="syslog"/>
    </logger>
</configuration>

这样就完事了吗？固然，这样就已经配置结束了，咱们来测试一下。 tomcat

在咱们的根目录生成了一个log文件夹，里面有咱们配置的日志，名字随便起的！springboot

咱们能够在更进一步的优化一下，咱们运行项目时会时常出现异常，那么怎么处理异常呢？app

咱们能够写一个通用的类来捕获异常而且进行返回测试

package com.example.ant.common.exception;

import com.alibaba.fastjson.JSON;
import com.example.ant.common.bean.ResponseModel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.ConversionNotSupportedException;
import org.springframework.beans.TypeMismatchException;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.web.HttpMediaTypeNotAcceptableException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

import java.io.IOException;

/**
 * 描述：全局异常处理类
 *  异常处理拦截器
 * User: 曾远征
 * Date: 2018-09-18
 * Time: 20:15
 */
@CrossOrigin
@ControllerAdvice
@ResponseBody
@Slf4j
public class GlobalExceptionHandler {

    //运行时异常
    @ExceptionHandler(RuntimeException.class)
    public String runtimeExceptionHandler(RuntimeException ex) {
        log.error("运行时异常",ex);
        return exceptionFormat(ex);
    }

    //空指针异常
    @ExceptionHandler(NullPointerException.class)
    public String nullPointerExceptionHandler(NullPointerException ex) {
        log.error("空指针异常",ex);
        return exceptionFormat(ex);
    }

    //类型转换异常
    @ExceptionHandler(ClassCastException.class)
    public String classCastExceptionHandler(ClassCastException ex) {
        log.error("类型转换异常",ex);
        return exceptionFormat(ex);
    }

    //IO异常
    @ExceptionHandler(IOException.class)
    public String iOExceptionHandler(IOException ex) {
        log.error("IO异常",ex);
        return exceptionFormat(ex);
    }

    //未知方法异常
    @ExceptionHandler(NoSuchMethodException.class)
    public String noSuchMethodExceptionHandler(NoSuchMethodException ex) {
        log.error("未知方法异常",ex);
        return exceptionFormat(ex);
    }

    //数组越界异常
    @ExceptionHandler(IndexOutOfBoundsException.class)
    public String indexOutOfBoundsExceptionHandler(IndexOutOfBoundsException ex) {
        log.error("数组越界异常",ex);
        return exceptionFormat(ex);
    }

    //400错误
    @ExceptionHandler({HttpMessageNotReadableException.class})
    public String requestNotReadable(HttpMessageNotReadableException ex) {
        log.error("400..requestNotReadable");
        return exceptionFormat(ex);
    }

    //400错误
    @ExceptionHandler({TypeMismatchException.class})
    public String requestTypeMismatch(TypeMismatchException ex) {
        log.error("400..TypeMismatchException");
        return exceptionFormat(ex);
    }

    //400错误
    @ExceptionHandler({MissingServletRequestParameterException.class})
    public String requestMissingServletRequest(MissingServletRequestParameterException ex) {
        log.error("400..MissingServletRequest");
        return exceptionFormat(ex);
    }

    //405错误
    @ExceptionHandler({HttpRequestMethodNotSupportedException.class})
    public String request405(HttpRequestMethodNotSupportedException ex) {
        log.error("405...异常",ex);
        return exceptionFormat(ex);
    }

    //406错误
    @ExceptionHandler({HttpMediaTypeNotAcceptableException.class})
    public String request406(HttpMediaTypeNotAcceptableException ex) {
        log.error("406...",ex);
        return exceptionFormat(ex);
    }

    //500错误
    @ExceptionHandler({ConversionNotSupportedException.class, HttpMessageNotWritableException.class})
    public String server500(RuntimeException ex) {
        log.error("500...",ex);
        return exceptionFormat(ex);
    }

    //栈溢出
    @ExceptionHandler({StackOverflowError.class})
    public String requestStackOverflow(StackOverflowError ex) {
        log.error("栈溢出异常",ex);
        return exceptionFormat(ex);
    }

    //其余错误
    @ExceptionHandler({Exception.class})
    public String exception(Exception ex) {
        log.error("其余异常",ex);
        return exceptionFormat(ex);
    }

    private <T extends Throwable> String exceptionFormat(T ex) {
        return JSON.toJSONString(ResponseModel.error(ex.getMessage()));
    }
}

ResponseModel类是我本身写的一个通用返回的方法，比较简单，代码以下优化

package com.example.ant.common.bean;

import com.alibaba.fastjson.JSON;
import lombok.Data;

import java.io.Serializable;

/**
 * 描述：统一返回值处理
 * User: 曾远征
 * Date: 2018-09-01
 * Time: 21:06
 */
@Data
public class ResponseModel implements Serializable {


    private boolean status;
    private String msg;
    private Object data;

    public ResponseModel() {
    }

    public static ResponseModel error() {
        return new ResponseModel(false, null, null);
    }

    public static ResponseModel error(String msg) {
        return new ResponseModel(false, msg, null);
    }

    public static ResponseModel success() {
        return new ResponseModel(true, null, null);
    }

    public static ResponseModel success(String msg) {
        return new ResponseModel(true, msg, null);
    }

    public static ResponseModel success(Object data) {
        return new ResponseModel(true, null, JSON.toJSONString(data));
    }

    public static ResponseModel success(String msg, Object data) {
        return new ResponseModel(true, msg, JSON.toJSONString(data));
    }

    public ResponseModel(boolean status, String msg, Object data) {
        this.status = status;
        this.msg = msg;
        this.data = data;
    }

}

这个异常处理只能捕获controller层的异常，为何呢？由于@ControllerAdvice这个注解

咱们来测试一下

如上图，我故意在代码里面写了一个异常。咱们运行项目跑起来

页面提示信息，在看看日志记录

咱们的日志文件也捕获到了，好了，这样就结束了。很是简单。