从零搭建 Spring Boot 后端项目（十一）

最新推荐文章于 2022-04-22 17:43:29 发布
最新推荐文章于 2022-04-22 17:43:29 发布
阅读量4.5k 收藏 6
点赞数 9
分类专栏： 后端模板 文章标签： spring boot 日志 slf4j logback
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22136439/article/details/107566953
版权
简介

日志能记录程序的运行轨迹，方便查找关键信息，也方便快速定位解决问题。尤其是项目线上问题，不允许远程调试的情况下，只能依赖日志定位问题，如果日志写的好，那就能快速找到问题所在。反之，日志没写好，反而会影响程序的运行性能和稳定性。日志的用途大致可以分为：

  • 问题追踪：辅助排查和定位线上问题，优化程序运行性能
  • 状态监控：通过日志分析，可以监控系统的运行状态
  • 安全审计：审计主要体现在安全上，可以发现非授权的操作
框架选择

SLF4J——Simple Logging Facade For Java，它是一个针对于各类Java日志框架的统一Facade抽象。Java日志框架众多——常用的有java.util.logging, log4j, logback，commons-logging, Spring框架使用的是Jakarta Commons Logging API (JCL)。Logback是log4j框架的作者开发的新一代日志框架，它效率更高、能够适应诸多的运行环境，同时天然支持SLF4J。所以尽管框架组合选择的方式很多，但选择SLF4J + Logback的组合，性能高，可扩展性强，很多开源项目都是此选项。SpringBoot默认情况下也是。所以我们使用默认的SLF4J + Logback组合就好

何时记录日志
  • 系统初始化： 系统或者服务的启动参数。核心模块或者组件初始化过程中往往依赖一些关键配置，根据参数不同会提供不一样的服务。务必在这里记录INFO日志，打印出参数以及启动完成态服务表述
  • 系统核心操作： 核心操作是正常系统正常运行的重要指标，建议关键点用INFO级别日志，其它考虑使用DEBUG级别，因为如果日志打印过多也会影响性能
  • 与业务流程不符时： 此时即是我们的业务场景不可能发生的情况，但是发生了，这时可以记录成日志，主要还是看开发人员的容忍程度了
  • 抛出异常时： 质量非常高的报错，根据业务的情况使用warn或者error级别，此项目需要在统一异常中添加日志记录
  • 第三方服务调用： 微服务架构体系中有一个重要的点就是第三方永远不可信，对于第三方服务远程调用建议打印请求和响应的参数，方便在和各个终端定位问题，不会因为第三方服务日志的缺失变得手足无措
日志格式
  • 日志时间：精确到毫秒，格式：yyyy-MM-dd HH:mm:ss.SSS
  • 日志级别：TRACE < DEBUG < INFO < WARN < ERROR
  • 线程ID：即PID
  • 分隔符：— 标识实际日志的开始
  • 线程名：方括号括起来（可能会截断控制台输出）
  • Logger名：通常使用源代码的类名，例如：c.e.b.BackendTemplateApplication，c.e.b是上三层的头字母
  • 日志内容
  • 异常堆栈（不一定有）

注：上面的格式其实就是Spring Boot日志默认的格式

例如：

//SpringBoot日志默认格式
2020-07-22 16:53:51.532 INFO 14912 --- [ main] c.e.b.BackendTemplateApplication: Starting BackendTemplateApplication...
日志级别

平时主要是用以下几种，分别讲一下怎么选择使用

  • TRACE ：追踪程序推进，如果要写的话，trace会特别多，所以一般都不输出
  • DEBUG：输出调试性质内容，主要用于开发、测试阶段，这种级别的日志也特别多，因为有很多调试信息，比如参数信息，调试细节信息，返回值信息等等，主要方便开发时分析错误使用，一般生产环境下不输出，一是影响性能，二是信息太多容易掩盖重要信息
  • INFO：主要记录系统关键信息，旨在保留系统正常工作期间关键运行指标，例如：初始化系统配置、业务状态变化信息，建议在生产环境中输出，并且INFO输出的信息可看作是软件产品的一部分，所以需要谨慎对待输出，不可太多，也不可无用
  • WARN：主要输出警告性质的内容，WARN代表可恢复的异常，此次失败不影响下次业务的执行
  • ERROR：主要针对于一些不可预知的信息，诸如：错误、异常等，输出时应该尽可能的详细，比如，入参，错误提示，异常对象等，这样才方便分析错误
其它规范

  • 日志输出需使用点位符输出，而不是用字符拼接

    //如果日志级别是 warn，上述日志不会打印，但是会执行字符串拼接操作,浪费了系统资源
logger.debug("Processing trade with id: " + id + " and symbol: " + symbol);

    改成

    logger.debug("Processing trade with id: [{}] and symbol : [{}] ", id, symbol);

  • 不要记录太多无用信息，不利于定位错误，且容易占太多磁盘资源，甚至撑爆磁盘

  • 尽量不要在日志中调用对象的获取方法，除非肯定该对象一定不为空，否则容易出NPE异常

  • 本地开发环境，可使用日志输出到控制台上，测试、生产可再写入文件中

  • 生产还可以考虑异步写入文件，这样不会因为日志的写入，而浪费性能，但AOP+异步只能是方法或类级别，方法内日志记录不到，看个人选择

  • 一个对象中通常只使用一个Logger对象，Logger应该是static final的

    private static final Logger log = LoggerFactory.getLogger(Main.class);

  • 尽量不要把日志输出写在循环内，容易影响运行时间

步骤

  • 在application-dev.properties配置文件下，增加以下配置，其实正常情况不用这么多配置，这里写了很多都是默认值，给出的原因是，方便以后改配置功能。这里需要注意的是，logs//backend_template.log 这里配置的日志目录，是一个相对路径，如果在IDE中运行，则和backend_template/src平级，打包成jar包后运行，则和jar包平级，可自行配置，配置后程序会自行创建该目录及文件

    # 日志
# 最小能打印出的日志级别，root级别即所有日志
logging.level.root=INFO
# 日志文件保存目录
logging.file.name=logs//backend_template.log
# 启动时是否清除日志
logging.file.clean-history-on-start=false
# 日志的最大尺寸，超过后分割
logging.file.max-size=10MB
# 日志总大小，0为不设限
logging.file.total-size-cap=0
# 限制日志保留天数，到期自动删除
logging.file.max-history=15
# 控制台日志输出格式
logging.pattern.console=%clr(%d{${LOG_DATEFORMAT_PATTERN:-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} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}
# 文件日志输出格式
logging.pattern.file=%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd HH:mm:ss.SSS}} ${LOG_LEVEL_PATTERN:-%5p} ${PID:- } --- [%t] %-40.40logger{39} : %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}
# appender的log level输出样式
logging.pattern.level=%5p
# 滚动文件名称
logging.pattern.rolling-file-name=${LOG_FILE} + ".%d{yyyy-MM-dd}.%i.gz"
# 时间格式
logging.pattern.dateformat=yyyy-MM-dd HH:mm:ss:SSS

  • 接下来就可以在类中写日志了，值得注意的是，在导入Logger类的包时，不要导错了，要导slf4j包下的Logger，而不是其它的日志包，要不然到时出错了还不方便改错，示例如下

    // 导入slf4j包
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
// 类中使用Log
private static final Logger log = LoggerFactory.getLogger(Main.class);
log.info("The request path is: [{}]",path);

  • 那们我们现在开始来分别在系统初始化、系统核心操作、与业务流程不符、抛出异常时的情况下，来打印日志，这里是因为我们没有第三方服务调用，所示没办法演示，但不是说不重要，反而第三服务相当重要，一定要记录日志，因为第三方服务永远都不可信，记录下来好判断错误

  • 首先是系统初始化时的日志，在本模板中，用到了Redis和Swagger2，在这些配置参数里，初始化时最重要的莫过于Redis 的hostname和端口和是否启用Swagger当然你也可以打印其它，你觉得重要的信息，方法一致，将com.example.backend_template.config.RedisConfigurer.java改为如下即可

    package com.example.backend_template.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import redis.clients.jedis.JedisPoolConfig;

/**
 * @ClassName RedisConfigurer Redis的配置类
 * @Description
 * @Author L
 * @Date Create by 2020/6/26
 */
@Configuration
@EnableCaching      //开启缓存
public class RedisConfigurer extends CachingConfigurerSupport {

    private static final Logger log = LoggerFactory.getLogger(RedisConfigurer.class);

    @Bean
    @ConfigurationProperties(prefix = "spring.redis")
    public JedisPoolConfig getRedisConfig() {
        JedisPoolConfig config = new JedisPoolConfig();
        return config;
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.redis")
    public JedisConnectionFactory getConnectionFactory() {
        JedisConnectionFactory factory = new JedisConnectionFactory();
        JedisPoolConfig config = getRedisConfig();
        factory.setPoolConfig(config);
        log.info("The hostname of the redis connection is：{}, and the port is: {}",factory.getHostName(),factory.getPort());
        return factory;
    }

    public RedisTemplate<?, ?> getRedisTemplate() {
        RedisTemplate<?, ?> template = new StringRedisTemplate(getConnectionFactory());
        return template;
    }
}

  • 将com.example.backend_template.config.Swagger2Config.java类改为如下代码

    package com.example.backend_template.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
 * @ClassName Swagger2Config swagger的配置内容即是创建一个Docket实例
 * @Description 
 * @Author L
 * @Date Create by 2020/6/30
 */
@Configuration
@EnableSwagger2 //启用swagger2
public class Swagger2Config {

    //是否开启 swagger-ui 功能，默认为false
    @Value("${swagger.enable:false}")
    private Boolean enable;

    private static final Logger log = LoggerFactory.getLogger(Swagger2Config.class);

    @Bean
    public Docket createRestApi() {
        log.info("Whether to open the Swagger service: {}",enable);
        return new Docket(DocumentationType.SWAGGER_2)
                .enable(enable)
                .pathMapping("/")
                .apiInfo(apiInfo())
                .select()
                //需要Swagger描述的接口包路径，如果不想某接口暴露，可在接口上加@ApiIgnore注解
                .apis(RequestHandlerSelectors.basePackage("com.example.backend_template.controller"))
                .paths(PathSelectors.any())
                .build();
    }

    //配置在线文档的基本信息
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("BackendTemplate项目")
                .description("使基于SpringBoot的后端开发变得简单")
                .version("1.0")
                .build();
    }
}

  • 完成这两个操作后，再次启动我们的项目，不论控制台和日志文件里，就会有如下两行系统初始化数据了，这样就可以很方便从日志信息中，知道系统关键配置信息

    2020-07-24 15:34:40,998  INFO 9864 --- [           main] c.e.b.config.RedisConfigurer             : The hostname of the redis connection is：localhost, and the port is: 6379
2020-07-24 15:34:41,538  INFO 9864 --- [           main] c.e.b.config.Swagger2Config              : Whether to open the Swagger service: true

  • 接下来记录系统核心操作，其中controller层的操作即可认为是核心操作，可记录重要入参与返回值，根据业务的不同，可以选择是INFO级别还是DEBUG级别
    修改com.example.backend_template.config.RedisController.java类为如下代码

    package com.example.backend_template.controller;

import com.example.backend_template.config.Swagger2Config;
import com.example.backend_template.service.RedisService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

/**
 * @ClassName RedisController
 * @Description 
 * @Author L
 * @Date Create by 2020/6/26
 */
@Api(tags = "redis简单测试接口")
@RestController
@RequestMapping("redis")
public class RedisController {

    @Resource
    private RedisService redisService;

    private static final Logger log = LoggerFactory.getLogger(RedisController.class);

    @ApiOperation("向redis中存储`name`值")
    @ApiImplicitParam(name = "name",value = "名称值",defaultValue = "L",required = true)
    @PostMapping("/setRedis")
    public Boolean setRedis(@RequestBody String name) {
        log.info("The name value stored in Redis is: {}",name);
        return redisService.set("name", name);
    }

    @ApiOperation("向redis中取`name`值")
    @GetMapping("/getRedis")
    public String getRedis() {
        String name = redisService.get("name");
        log.info("The name value obtained from Redis is: {}",name);
        return name;
    }
}

  • 接下来启动项目，用postman发起post请求访问http://localhost:8080/redis/setRedis，其中Body值设为{“L”}，并再次发起get请求访问 http://localhost:8080/redis/getRedis，两次操作都成功后，控制台和日志中就会出现如下两条记录

    2020-07-24 16:16:57,268  INFO 19660 --- [nio-8080-exec-1] c.e.b.controller.RedisController         : The name value stored in Redis is: {"L"}
2020-07-24 16:19:33,650  INFO 6396 --- [nio-8080-exec-2] c.e.b.controller.RedisController         : The name value obtained from Redis is: {"L"}

  • 与业务流程不符就不演示了，主要是和自已预想状态不一致时记录日志，这里重点说一下抛出异常时的日志记录，因为日志的一大重要功能就是，在线上无法调试，只能通过日志来调试，一个好的日志可以快速的找出错误，所以这里尤为重要，因为我们是统一异常，要GlobalExceptionHandler类，我们要把可能报的错都记录下来，这样方便调试，修改com.example.backend_template.exception.GlobalExceptionHandler.java类的内容为如下

    package com.example.backend_template.exception;

import com.example.backend_template.utils.ResultData;
import com.example.backend_template.utils.ResultUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.ConversionNotSupportedException;
import org.springframework.beans.TypeMismatchException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.validation.BindException;
import org.springframework.web.HttpMediaTypeNotAcceptableException;
import org.springframework.web.HttpMediaTypeNotSupportedException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingPathVariableException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.ServletRequestBindingException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.context.request.async.AsyncRequestTimeoutException;
import org.springframework.web.multipart.support.MissingServletRequestPartException;
import org.springframework.web.servlet.NoHandlerFoundException;

/**
 * @ClassName GlobalExceptionHandler 全局统一处理异常
 * @Description
 * @Author L
 * @Date Create by 2020/7/7
 */
@ControllerAdvice
public class GlobalExceptionHandler {

    private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    /**
     * 该请求控制器存在，但请求HTTP方法与该控制器提供不符
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
    protected ResponseEntity<Object> handleHttpRequestMethodNotSupported(HttpRequestMethodNotSupportedException ex, WebRequest request) {
        ResultData<Object> errorBody = ResultUtils.fail(405, "Http Request Method Not Supported!",ex.getLocalizedMessage());
        log.error("Throw [{}] exception: {}","Http Request Method Not Supported",ex.getLocalizedMessage());
        return new ResponseEntity<>(errorBody, HttpStatus.METHOD_NOT_ALLOWED);
    }

    /**
     * content-type 内容设置类型不支持
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(HttpMediaTypeNotSupportedException.class)
    protected ResponseEntity<Object> handleHttpMediaTypeNotSupported(HttpMediaTypeNotSupportedException ex, WebRequest request) {
        ResultData<Object> errorBody = ResultUtils.fail(415, "Http Media Type Not Supported!",ex.getLocalizedMessage());
        log.error("Throw [{}] exception: {}","Http Media Type Not Supported",ex.getLocalizedMessage());
        return new ResponseEntity<>(errorBody, HttpStatus.UNSUPPORTED_MEDIA_TYPE);
    }

    /**
     * content-type 内容设置类型不能接受
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(HttpMediaTypeNotAcceptableException.class)
    protected ResponseEntity<Object> handleHttpMediaTypeNotAcceptable(HttpMediaTypeNotAcceptableException ex, WebRequest request) {
        ResultData<Object> errorBody = ResultUtils.fail(406, "Http Media Type Not Acceptable!",ex.getLocalizedMessage());
        log.error("Throw [{}] exception: {}","Http Media Type Not Acceptable",ex.getLocalizedMessage());
        return new ResponseEntity<>(errorBody, HttpStatus.NOT_ACCEPTABLE);
    }

    /**
     * 缺少路径参数
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(MissingPathVariableException.class)
    protected ResponseEntity<Object> handleMissingPathVariable(MissingPathVariableException ex, WebRequest request) {
        ResultData<Object> errorBody = ResultUtils.fail(500, "Missing Path Variable!",ex.getLocalizedMessage());
        log.error("Throw [{}] exception: {}","Missing Path Variable",ex.getLocalizedMessage());
        return new ResponseEntity<>(errorBody, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    /**
     * 缺少请求参数
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(MissingServletRequestParameterException.class)
    protected ResponseEntity<Object> handleMissingServletRequestParameter(MissingServletRequestParameterException ex, WebRequest request) {
        ResultData<Object> errorBody = ResultUtils.fail(400, "Missing Servlet Request Parameter!",ex.getLocalizedMessage());
        log.error("Throw [{}] exception: {}","Missing Servlet Request Parameter",ex.getLocalizedMessage());
        return new ResponseEntity<>(errorBody, HttpStatus.BAD_REQUEST);
    }

    /**
     * Servlet请求绑定出错
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(ServletRequestBindingException.class)
    protected ResponseEntity<Object> handleServletRequestBindingException(ServletRequestBindingException ex, WebRequest request) {
        ResultData<Object> errorBody = ResultUtils.fail(400, "Servlet Request Binding!",ex.getLocalizedMessage());
        log.error("Throw [{}] exception: {}","Servlet Request Binding",ex.getLocalizedMessage());
        return new ResponseEntity<>(errorBody, HttpStatus.BAD_REQUEST);
    }

    /**
     * 转换不支持
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(ConversionNotSupportedException.class)
    protected ResponseEntity<Object> handleConversionNotSupported(ConversionNotSupportedException ex, WebRequest request) {
        ResultData<Object> errorBody = ResultUtils.fail(500, "Conversion Not Supported!",ex.getLocalizedMessage());
        log.error("Throw [{}] exception: {}","Conversion Not Supported",ex.getLocalizedMessage());
        return new ResponseEntity<>(errorBody, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    /**
     * 参数类型匹配失败
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(TypeMismatchException.class)
    protected ResponseEntity<Object> handleTypeMismatch(TypeMismatchException ex, WebRequest request) {
        ResultData<Object> errorBody = ResultUtils.fail(400, "Type Mismatch!",ex.getLocalizedMessage());
        log.error("Throw [{}] exception: {}","Type Mismatch",ex.getLocalizedMessage());
        return new ResponseEntity<>(errorBody, HttpStatus.BAD_REQUEST);
    }

    /**
     * HTTP 信息请求不可读
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(HttpMessageNotReadableException.class)
    protected ResponseEntity<Object> handleHttpMessageNotReadable(HttpMessageNotReadableException ex, WebRequest request) {
        ResultData<Object> errorBody = ResultUtils.fail(400, "Http Message Not Readable!", ex.getLocalizedMessage());
        log.error("Throw [{}] exception: {}","Http Message Not Readable",ex.getLocalizedMessage());
        return new ResponseEntity<>(errorBody, HttpStatus.BAD_REQUEST);
    }

    /**
     * HTTP 信息请求不可写
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(HttpMessageNotWritableException.class)
    protected ResponseEntity<Object> handleHttpMessageNotWritable(HttpMessageNotWritableException ex, WebRequest request) {
        ResultData<Object> errorBody = ResultUtils.fail(500, "Http Message Not Writable!",ex.getLocalizedMessage());
        log.error("Throw [{}] exception: {}","Http Message Not Writable",ex.getLocalizedMessage());
        return new ResponseEntity<>(errorBody, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    /**
     * 参数校验出错
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    protected ResponseEntity<Object> handleMethodArgumentNotValid(MethodArgumentNotValidException ex, WebRequest request) {
        ResultData<Object> errorBody = ResultUtils.fail(400, "Method Argument Not Valid!", ex.getLocalizedMessage());
        log.error("Throw [{}] exception: {}","Method Argument Not Valid",ex.getLocalizedMessage());
        return new ResponseEntity<>(errorBody, HttpStatus.BAD_REQUEST);
    }

    /**
     * 丢失了一部分请求信息
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(MissingServletRequestPartException.class)
    protected ResponseEntity<Object> handleMissingServletRequestPart(MissingServletRequestPartException ex, WebRequest request) {
        ResultData<Object> errorBody = ResultUtils.fail(400, "Missing Servlet Request Part!",ex.getLocalizedMessage());
        log.error("Throw [{}] exception: {}","Missing Servlet Request Part",ex.getLocalizedMessage());
        return new ResponseEntity<>(errorBody, HttpStatus.BAD_REQUEST);
    }

    /**
     * 参数绑定出错
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(BindException.class)
    protected ResponseEntity<Object> handleBindException(BindException ex, WebRequest request) {
        ResultData<Object> errorBody = ResultUtils.fail(400, "Bind Exception!",ex.getLocalizedMessage());
        log.error("Throw [{}] exception: {}","Bind Exception",ex.getLocalizedMessage());
        return new ResponseEntity<>(errorBody, HttpStatus.BAD_REQUEST);
    }

    /**
     * 根据请求url找不到控制器，即404异常
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(NoHandlerFoundException.class)
    protected ResponseEntity<Object> handleNoHandlerFoundException(NoHandlerFoundException ex, WebRequest request) {
        ResultData<Object> errorBody = ResultUtils.fail(404, "No Handler Found!",ex.getLocalizedMessage());
        log.error("Throw [{}] exception: {}","No Handler Found",ex.getLocalizedMessage());
        return new ResponseEntity<>(errorBody, HttpStatus.NOT_FOUND);
    }

    /**
     * 异步请求超时
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(AsyncRequestTimeoutException.class)
    protected ResponseEntity<Object> handleAsyncRequestTimeoutException(AsyncRequestTimeoutException ex, WebRequest request) {
        ResultData<Object> errorBody = ResultUtils.fail(503, "Async Request Timeout!",ex.getLocalizedMessage());
        log.error("Throw [{}] exception: {}","Async Request Timeout",ex.getLocalizedMessage());
        return new ResponseEntity<>(errorBody, HttpStatus.SERVICE_UNAVAILABLE);
    }

    /**
     * 其它未统一的异常，都由以下handle处理，生产可写网络异常
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(Exception.class)
    protected ResponseEntity<Object> handleAllExceptions(Exception ex, WebRequest request) {
        ResultData<Object> errorBody = ResultUtils.fail(500, "Server Error!",ex.getLocalizedMessage());
        log.error("Throw [{}] exception: {}","Server Error",ex.getLocalizedMessage());
        return new ResponseEntity<>(errorBody, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    //以下是自定义异常
    /**
     * 没有找到该用户
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(UserNotFoundException.class)
    protected ResponseEntity<Object> handleUserNotFoundException(UserNotFoundException ex, WebRequest request) {
        ResultData<Object> errorBody = ResultUtils.fail(404, "User Not Found",ex.getLocalizedMessage());
        log.error("Throw [{}] exception: {}","User Not Found",ex.getLocalizedMessage());
        return new ResponseEntity<>(errorBody, HttpStatus.NOT_FOUND);
    }
}

  • 如果系统抛出异常，信息就会打印在控制台，以及储存在日志文件中，格式如下

    2020-07-24 17:03:58,449 ERROR 13600 --- [nio-8080-exec-1] c.e.b.exception.GlobalExceptionHandler   : Throw [User Not Found] exception: This user was not found!

至此日志规范就完成了，如果是业务开发，只需要向上面几步一样，在相应的地方添加日志记录就行了

项目地址

项目介绍：从零搭建 Spring Boot 后端项目
代码地址：https://github.com/xiaoxiamo/backend-template

下一篇

十二、数据库版本控制

小夏陌
关注
  • 9
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
商城-下单-订单系统接口
shenzhen_zsw的专栏
06-18 7457
商城-购物车-订单系统接口1.订单系统接口1.1.导入订单服务1.2.Swagger-UI1.2.1.什么是OpenAPI1.2.2.什么是swagger？1.2.3.快速入门1）引入依赖2）编写配置3）接口声明4）启动测试1.3.测试接口1.3.1.创建订单接口1.3.2.生成ID的方式1.3.2.查询订单接口1.3.3.更新订单状态1.3.4.分页查询订单1.3.5.生成微信付款链接微信支付工...
从零搭建 Spring Boot 后端项目（六）
小夏陌的博客
07-20 4481
简介 这一小节主要是为了，统一请求结果格式 步骤 在提倡前后端分离的当下，统一返回结果就显得尤其重要，在com.example.backend_template.utils下新增ResultData类package com.example.backend_template.utils; /** * @ClassName ResultData 封装结果集成统一的json样式 * @Description TODO * @Author L * @Date Create by 2020/7/2 */
Swagger（全） SpringBoot整合与使用
Hello World!
04-22 2694
Swagger 首先是一个规范、完整和统一的接口文档维护规范/标准。在这个标准下，Swagger官方提供了很多基于该标准的自动化接口维护工具，用于生成、描述、调用和可视化接口文档的Web 服务。
API接口在线管理（Swagger和SosoApi）
tanwenfang的博客
02-26 2万+
1.Swagger 1.1. Swagger介绍 1.1.1. 简介 Swagger是全球最大的API开发框架，这个框架以“开放API声明（OpenAPI Specification,OSA）”为基础，支持整个API生命周期的开发。它可以和SpringMVC整合，并且通过结合Swagger-ui组件，将controller层的方法进行可视化的展示，像方法注释，方法参数，方法返回值等都...
搭建一个简单springboot后端框架
世态人情 可作书读 可作戏看
01-08 1669
前言 框架知识是每个程序员都应该或多或少都要有所了解，作为后端开发更是以后进阶架构师必备的知识储备；以此为出发点，我们可以从搭建一个简单的后端框架开始，了解相关的技术点和搭建思路。 我们可以从创建项目、引入相关依赖、配置相关信息、测试四个方面来构思和搭建这个简单的后端框架，照例，废话不多说，整起ing。。。 创建项目 第一先创建一个springboot工程，到springboot的官方网站创建项目 Spring Initializr，如下界面配置，这里创建的项目会在pom.xml文件中设置了maven；设置
从零搭建 Spring Boot 后端项目（九）
小夏陌的博客
07-20 5428
单元测试 简介 单元测试是先mock一些正常边界异常条件来对接口进行操作，并且期望接口返回什么内容，最后接口实现了之后再重新测试一遍。单元测试要测试任何可能的错误，单元测试不是用来证明你是对的，而是为了证明你没有错。在TDD(Test-Driven Development)开发模式中，重点强调在开发功能代码之前，先编写测试代码。单元测试不仅仅用来保证当前代码的正确性，更重要的是用来保证代码修复、改进或重构之后的正确性。当然这里没有，而是给一个单元测试的模板，要注意的是，我们不要为了单测而单测。 JUnit
springboot2.1.1 配置swagger,并解决拦截器问题
huanghuang9426的博客
07-05 1009
pom.xml <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>3.0.0-SNAPSHOT</version> </dependency> <depen
2.SpringBoot项目结构及启动
boywcx的博客
09-11 589
(1).SpringBoot项目结构分析 新建项目结构如图所示： CxdemoApplication  ：启动类，只要调用main方法便可以启动项目。 src/main/java  ：主要编写业务。如controller，service，pojo，utils等等 src/main/resources  ：存放配置文件。如application.properties。 src/main...
Spring Boot学习笔记 - 整合Swagger2自动生成RESTful API文档
Ricky
01-04 1万+
在App后端开发中经常需要对移动客户端（Android、iOS）提供RESTful API接口，在后期版本快速迭代的过程中，修改接口实现的时候都必须同步修改接口文档，而文档与代码又处于两个不同的媒介，除非有严格的管理机制，不然很容易导致代码与接口文档不一致现象。本文将介绍RESTful API的重磅好伙伴Swagger2，它可以轻松的整合到Spring生态链中，并与Spring MVC程序配合组织出
SpringBoot（七）：SpringBoot整合Swagger2
热门推荐
Saytime
07-10 7万+
相信各位在公司写API文档数量应该不少，当然如果你还处在自己一个人开发前后台的年代，当我没说，如今为了前后台更好的对接，还是为了以后交接方便，都有要求写API文档。 手写Api文档的几个痛点： 文档需要更新的时候，需要再次发送一份给前端，也就是文档更新交流不及时。接口返回结果不明确不能直接在线测试接口，通常需要使用工具，比如postman接口文档太多，不好管理 Swagg
springboot出现异常整合
zsx18273117003的博客
06-16 2044
1.缺少注解@SpringBootApplication 异常：org.springframework.context.ApplicationContextException: Unable to start web server; nested exception is org.springframework.context.ApplicationContextException: Unabl...
swagger加请求头(测试带token的请求)
来日可期的博客
09-10 2万+
现在大家一般都是使用SpringBoot写RESTful接口, 但是在测试带有token的请求的时候, 就有点难受了. 传统的PostMan就有点让人炸毛了. 但是现在Swagger出现了.(SpringBoot简直和Swagger是天作之和) swagger的整合细节就不在这里说了, 下面进入正题: @Configuration public class Swagger2Config {...
记一次SpringBoot项目启动卡住问题排查记录
Java笔记虾
11-26 6050
点击上方“后端技术精选”，选择“置顶公众号”技术文章第一时间送达！作者：陈凯玲来源：https://url.cn/5UWhBvB一个spring boot开发的项目，spring boot版本是1.5.7，携带的spring版本是4.1.3。开发反馈，突然在本地启动不起来了，表象特征就是在本地IDEA上运行时，进程卡住也不退出，应用启动时加载相关组件的日志也不输出。症状如下图：问题分析因为没有有用...
搭建SpringBoot纯后端服务
u012639878的博客
08-15 1309
在IDEA中创建一个SpringBoot应用，按照下面的步骤一步步点就行了。 等待几分钟之后，启动！ 启动的时候，如果遇到报错信息： An incompatible version [1.2.10] of the Apache Tomcat Native library is installed, while Tomcat request [1.2.14] 就到Tomcat的官网上去下载对应版本的tcnative-1.dll文件，然后放到或者替换掉，C:\Windows\Syst
从零搭建 Spring Boot 后端项目
小夏陌的博客
07-20 3万+
一个基于 Spring Boot 的后端开发模板，主要用于减少平时重复的工作量，以及使开发有良好的开发规范。
从零搭建 Spring Boot 后端项目（一）
小夏陌的博客
07-20 5302
简介 这一小节主要是初始化项目，以及创建好相应的目录结构 步骤 点击创建 选择Spring Initializr 后，选择Jdk 版本 新建项目时，需输入公司名称和项目名称，其它默认或选择自己所需都可 这个页面可选择我们项目需要的各种组件，例如像mybatis，redis等，只要选择Spring Initializr就会自动帮我们整合，非常方便，但这里之后我们手动整合这些，所以选择一个Spring Web就行 这里输入项目名称和项目的本地地址，点击Finish完成即可 初始化后的项目结构如图所示
从零搭建 Spring Boot 后端项目（二）
小夏陌的博客
07-20 4967
简介 这一小节主要是整合mybatis、Druid连接池、PageHelper分页 步骤 在之前的开发依赖界面中，我们可以选择所需要的依赖，当然我们也可以手动添加依赖，以在项目中整合mybatis、Druid连接池、PageHelper分页，在pom.xml 文件中<dependencies>添加如下依赖 <!-- mysql数据库驱动--> <dependency> <groupId>mysql&l
从零搭建 Spring Boot 后端项目（三）
小夏陌的博客
07-20 4634
简介 这一小节主要是，整合Redis，需要提前在开发机上安装好Redis才进行以下操作 步骤 这里我用的是Windows下的 redis 3.0，可以自行下载安装适合自己系统的redis 添加Redis依赖 <!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-
从零搭建 Spring Boot 后端项目（四）
小夏陌的博客
07-20 4629
简介 这一小节主要是，整合 Spring Security 步骤 新建数据库与表 Create DATABASE `backend_template`; USE backend_template; CREATE TABLE `user` ( `id` bigint(11) NOT NULL AUTO_INCREMENT, `username` varchar(255) NOT NULL, `password` varchar(255) NOT NULL, PRIMARY KEY
spring boot 后端搭建流程
最新发布
03-26
1. 创建项目：使用IDE或者Maven命令创建Spring Boot项目。 2. 配置数据库：在application.properties或application.yml中配置数据库信息。 3. 定义实体类：创建实体类，使用注解定义表、字段等信息。 4. 定义...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小夏陌

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值