java日志体系以及系统异常设计规范与原则

一、JAVA常用的日志打印组件

• log4j、
• logback、
• log4j2、
• java.util.looging；

假设Spring 框架要打印日志，应该选择中其中哪一个组件?
发现哪个都不能选，只能基于应用实际使用的日志组件来。不然日志打印就会多份。
怎么找到应用实际使用的日志组件， Apache Commons Loging 解决了这个问题

1.1、Apache Commons Loging （JCL）

Commons Loging 本身只提供日志接口，具体实现在运行时动态寻找对应组件，比如：log4j、jdk14looger 等。但这种动态绑定的方式当系统特别宠大的时候会出现绑定失败的问题。现在比较流行的slf4j 基于静态绑定的方式解决了这个问题；

1.2、slf4j

slf4j 本身也只提供日志接口，与commons loging 不同的是其采用在classPath 加入以下jar包来表示具体采用哪种实现 ：
• slfj-log4j12.jar (表示指定 log4j)
• slf4j-jdk14.jar(表示指定jdk Looging)
• slf4j-jcl.jar(表示指定jcl)
• log4j-slf4j-impl(表示指定log4j2)
• logback-classic(表示指定logback)

log4j的配置

<dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.25</version>
</dependency>

 <!--桥接器，将log4j与slf4j连接起来-->
<dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
       <version>1.7.22</version>
</dependency>

<dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
</dependency>

package com.maltose.studyproject.controller;

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

/**
 * @Author: sgw
 * @Date 2019/11/10 16:06
 * @Description: Slf4j日志
 **/
public class HelloSlf4j {
    private static Logger logger
            = LoggerFactory.getLogger(HelloSlf4j.class);

    public static void main(String[] args) {
        logger.error("abc");
    }
}

正常情况下，就会打印下边的日志

可是由于spring boot默认采用的是logback打印日志，所以如果是spring boot项目的话，会报如下的错

即找到两个日志框架（log4j与logback），所以报错了；
spring boot在spring-boot-starter-logging里包含了logback框架

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-logging</artifactId>
</dependency>

而spring-boot-starter包含了spring-boot-starter-logging，所以只要使用spring boot
就默认使用了logback作为日志框架了

<dependency>
     <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>

那么，想要使用自己的log4j，而不使用spring boot默认的logback，需要使用exclusions节点将spring-boot-starter-logging这个依赖排除掉

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <exclusions>
            <exclusion>
                    <artifactId>spring-boot-starter-logging</artifactId>
                    <groupId>org.springframework.boot</groupId>
            </exclusion>
    </exclusions>
</dependency>

记住，要加上log4j.properties文件，否则报错

此时，日志打印使用的就是log4j了：

1.3、日志框架升级

之前老项目使用的jcl日志框架，现在想要换成slf4j作为日志框架，如果从头开始替换，工作量会非常大，此时，只需引入一个jar即可：jcl-over-slf4j.jar

验证上边的jcl-over-slf4j.jar
先使用老的jcl打印日志，添加jcl依赖：

<dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging-api</artifactId>
            <version>1.1</version>
</dependency>
<dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1</version>
</dependency>
<dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
</dependency>

测试代码：

package com.maltose.studyproject.controller;


import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * @Author: sgw
 * @Date 2019/11/10 17:16
 * @Description: JCL日志
 **/
public class HelloJcl {
    public static void main(String[] args) {
        Log logger = LogFactory.getLog(HelloJcl.class);
        logger.error("error message jcl");
    }
}

结果：

jcl升级日志框架到slf4j：
在上边的基础上，再引入下边的包

<dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
</dependency>
        <!--log4j2-->
<dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.3</version>
</dependency>
        <!--slf4j与log4j2桥接器-->
<dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.3</version>
</dependency>
<dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.3</version>
</dependency>
        <!--并发包，不然log4j2容易报错-->
<dependency>
            <groupId>com.lmax</groupId>
            <artifactId>disruptor</artifactId>
            <version>3.3.2</version>
</dependency>

 <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>1.7.25</version>
</dependency>

添加log4j2.xml:

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="error">
    <Appenders>
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%m"/>
        </Console>
    </Appenders>
    <Loggers>
        <Root level="error">
            <AppenderRef ref="Console"/>
        </Root>
    </Loggers>
</Configuration>

还是运行刚才的代码：

修改log4j2.xml，看日志有没有改变（加上了%d）

日志变了：

说明现在走的就是slf4j下的log4j2的日志框架了；

1.4、log4j2.xml文件解读

有两大块，Appenders与Loggers

1.4.1、Appenders

定义输出源—— 输出到哪里去，用什么方式输出，Appenders节点下有三种配置方式
方式一：Console

<Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d %m"/>
</Console>

target=“SYSTEM_OUT”：即System.out.print();
target=“SYSTEM_ERR”：即System.err.print();

PatternLayout ：模版匹配文件

 <PatternLayout pattern="%d [%-5level][%t] %m (%C:%F:%L) %n"/>

• %d：时间
• %-5：前边5个空格
• t：线程名称
• m：方法名（method）
• C：class名称
• F：File文件名
• L：Line行数
• n：换行

方式二：File

<File name="file" fileName="logs/all.log" append="false">
           <PatternLayout pattern="%d [%-5level][%t] %m (%C:%F:%L) %n"/>
</File>

fileName：日志保存的目录
append：要不要追加日志 false——不追加

再次执行方法：

方式三：RollingFile 滚动保存

 <RollingFile name="rollingfile" fileName="logs/all-2.log" filePattern="logs/$${date:yyyy-MM-dd}/all-%d{yyyy-MM-dd-HH}-%i.zip">
           <PatternLayout pattern="%d [%-5level][%t] %m (%C:%F:%L) %n"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                 <!--每个日志文件2MB，够了2kb就生成新的日志文件-->
                <SizeBasedTriggeringPolicy size="200 MB"/>
            </Policies>
             <!--最多保存10个日志文件-->
            <DefaultRollverStrategy max="10"/>
</RollingFile>

执行方法后：

1.5、error与info日志分别保存到不同目录

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="error">

    <!--Appenders，定义输出源： 输出到哪里去，用什么方式输出-->

    <Appenders>
        <Console name="Console" target="SYSTEM_OUT">
          <!--  <PatternLayout pattern="%d [%-5level][%t] %m (%C:%F:%L) %n"/>-->
            <PatternLayout pattern="%d [%-5level][%t] %m (%C:%F:%L) %n"/>
        </Console>
       <File name="file" fileName="logs/all.log" append="false">
           <PatternLayout pattern="%d [%-5level][%t] %m (%C:%F:%L) %n"/>
       </File>
        <RollingFile name="rollingfile" fileName="logs/all-2.log" filePattern="logs/$${date:yyyy-MM-dd}/all-%d{yyyy-MM-dd-HH}-%i.log">
           <PatternLayout pattern="%d [%-5level][%t] %m (%C:%F:%L) %n"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <!--每个日志文件2kb，够了2kb就生成新的日志文件-->
                <SizeBasedTriggeringPolicy size="2 KB"/>
            </Policies>
            <!--最多保存10个日志文件-->
            <DefaultRollverStrategy max="10"/>
        </RollingFile>

        <!--单独将error日志保存到另一个目录-->
        <RollingFile name="rollingfileError" fileName="logs/error.log" filePattern="logs/$${date:yyyy-MM-dd}-error/all-%d{yyyy-MM-dd-HH}-%i.log">
            <PatternLayout pattern="%d [%-5level][%t] %m (%C:%F:%L) %n"/>
            <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <!--每个日志文件2kb，够了2kb就生成新的日志文件-->
                <SizeBasedTriggeringPolicy size="2 KB"/>
            </Policies>
            <!--最多保存10个日志文件-->
            <DefaultRollverStrategy max="10"/>
        </RollingFile>


    </Appenders>
    <!--具体的日志配置-->
    <Loggers>
       
        <Logger name="com.maltose.studyproject.controller" level="error">
            <AppenderRef ref="rollingfileError"/>
        </Logger>
        <!--如果代码里的日志不符合上边Logger里的配置，就会匹配Root里的配置来打印日志-->
        <Root level="debug">
            <AppenderRef ref="Console"/>
            <AppenderRef ref="file"/>
            <AppenderRef ref="rollingfile"/>
        </Root>
    </Loggers>
</Configuration>

上边注意点：

二、系统异常设计规范与原则

系统异常设计的出发点：

1. 良好的异常信息展示，开发运维人员能快速定位问题。
2. 响应外部调用异常时，应能明确指明是内部异常还是调用条件不满足导至。
3. 响应用户操作异常时，能友好的提示用户。

如何做到以上3点？

2.1、首先我们需要对异常进行分类。

分类一、 内部异常

1. 资源环境导致（系统环境异常、数据库连接超时、第三方服务响应超时）
2. 第三方服务错误响应
3. 第三方响应结果错误
4. 外部传入参数非法
5. 错误的编码逻辑
6. 错误的配置
7. 异常的业务数据（业务数据缺失）

分类二、业务异常

1. 用户操作错误
2. 业务条件不满足

2.2、其次需要在系统中正确的捕获这类异常，并抛出。

2.2.1、方法入参进行合法性验证。

1. 对系统外部提供的接口，是必须要进行参数验证（必须）
2. 系统内部对外层提供接口，进行验证
3. 工具类进行参数验证
4. public 方法要进行验证
5. private 方法(不建议参数验证)

2.2.2、第三方响应结果合法性验证

1. 获取第三方法结果后，根据你们的约定进行验证。

2.2.3、业务处理前，对业务业务前置条件进行验证

1. 业务处理前，验证业务条件（验证佘额、验证这个帐户有没有被公安门锁定）
2. 要考虑性能成本（验证身份证号码是不是存在的）

2.2.4、业务处理后，对处理结果进行验证。

1. 验证对方帐户是不是到帐了，转出帐户是不是成功扣款

2.2.5、对于可能会出现异常的代码进行 try catch 捕获

1. 尝试恢复处理
2. 直接抛出
3. 转换后抛出

2.3、最后 在系统出口统一拦截处理。

统一拦截的目的是确保出去的异常是可控的， 调用方能够明白的异常信息。
这里出口是指系统对外统一响应逻辑，一般我们可分三类场景

2.3.1、WEB Response

1. 内部异常：引导至异常提示页。
2. 业务异常：返回对应提示消息至前端。
3. 未知异常：尝试进行认别，如果认识不了，转换成 编码异常(BUG)。

2.3.2、Http API 接口响应

1. 内部异常：返回接口不可用消息。
2. 参数错误：基于API文档中的异常列表进行进行响应返回。表明参数非法，需要调用方加强参数合法性验证
3. 业务错误：基于掊口约定反回对应code与消息

2.3.3、RPC Service 响应

1. 内部异常：返回服务不可用消息
2. 参数错误：基于接口文档进行响应，直接返回异常堆栈。
3. 业务错误 ：直接返回异常堆栈。

checkedException 与uncheckedException 声明原则

1. 如果是参数非法抛出,返回结果非法（即软件BUG） uncheckedException
2. 如果你认为调用方程序员需要有意识地采取措施，那么抛出检查型异常（checkedException ）。
3. 程序产品有明确的条件约束的要求，可声明检查型业务异常（checkedException ）。

总结异常设计与处理原则

异常的定义技巧

1. 基于分包表示异常的分类，不建议使用继承（service业务异常的话，在service包下新建异常类接口实现Exception（或者在common包下新建各异常的子包，如common下新建serviceException包，systemException包…），所有的service都实现这个接口，这样service层有异常时，一看日志就能定位到是service层的异常,比如service层异常日志会这样打印：com.maltose.studyproject.service.serviceException）
2. 创建异常来类定义业务异常，不建议使用Code来定义
3. 使用枚举来表示业务异常的几种结果，不建议使用code

2.4、全局异常处理实战

2.4.1、场景

新增商品的方法，需要接收两个参数：

price:价格
name:名称

然后对数据进行校验：
价格不可以为空（我们要做的就是：价格为空时，做统一异常处理）
新增时，自动生成ID，然后随商品对象一起返回；

2.4.2、代码

实体类：

package com.leyou.item.pojo;

/**
 * @Author: sgw
 * @Date 2019/12/15 10:51
 * @Description: TODO
 **/
@Data
public class Item {
    private Integer id;
    private String name;
    private Long price;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Long getPrice() {
        return price;
    }

    public void setPrice(Long price) {
        this.price = price;
    }
}

service：

package com.leyou.item.service;

import com.leyou.item.pojo.Item;
import org.springframework.stereotype.Service;

import java.util.Random;

/**
 * @Author: sgw
 * @Date 2019/12/15 10:53
 * @Description: TODO
 **/
@Service
public class ItemService {
    public Item saveItem(Item item){
        int id=new Random().nextInt(100);
        item.setId(id);
        return item;
    }
}

全局异常处理类：

package com.leyou.common.utils.com.leyou.common.advice;

import com.leyou.common.utils.com.leyou.common.advice.com.leyou.common.exception.LyException;
import com.leyou.common.vo.ExceptionResult;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

/**
 * @Author: sgw
 * @Date 2019/12/14 22:20
 * @Description: 拦截所有Controller里的异常
 **/
@ControllerAdvice
public class ControllerHanderException {
    @ExceptionHandler(LyException.class)
    public ResponseEntity<ExceptionResult> handleException(LyException e) {
        return ResponseEntity.status(e.getExceptionEnum().getCode()).body(new ExceptionResult(e.getExceptionEnum()));
    }
}

service服务引用common（不是微服务的话，则忽略此处）：

<dependency>
            <groupId>com.leyou.common</groupId>
            <artifactId>ly-common</artifactId>
            <version>1.0.0-SNAPSHOT</version>
</dependency>

注意，通用异常处理器想生效，靠的是注解@ControllerAdvice，且这个异常处理类写在了common服务里，service引用common；所以common里的异常处理类所在的包名，必须是service扫描的包名完全一致（或者是service扫描包的子包），即下边两个包名必须一致：

枚举：

package com.leyou.common.utils.enums;


/**
 * @Author: sgw
 * @Date 2019/12/15 11:26
 * @Description: 异常枚举
 **/

public enum ExceptionEnum {

    //枚举只能放在做最前边(相当于创建了一个对象，枚举类只能自己创建对象，其他类是不可以创建枚举类的对象的)
    PRICE_CANNOT_BE_NULL(400,"价格不能为空"),
    NMAE_CANNOT_BE_NULL(401,"名称不能为空"),
    ID_CANNOT_BE_NULL(402,"ID不能为空");
    private int code;
    private String msg;

    ExceptionEnum(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }
    ExceptionEnum() {

    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

自定义异常：

package com.leyou.common.utils.com.leyou.common.advice.com.leyou.common.exception;

import com.leyou.common.utils.enums.ExceptionEnum;

/**
 * @Author: sgw
 * @Date 2019/12/15 11:22
 * @Description: 自定义异常
 **/
public class LyException  extends RuntimeException{
    private ExceptionEnum exceptionEnum;

    public LyException() {

    }
    public LyException(ExceptionEnum exceptionEnum) {
        this.exceptionEnum = exceptionEnum;
    }

    public ExceptionEnum getExceptionEnum() {
        return exceptionEnum;
    }

    public void setExceptionEnum(ExceptionEnum exceptionEnum) {
        this.exceptionEnum = exceptionEnum;
    }
}

将异常封装为自定义格式：

package com.leyou.common.vo;

import com.leyou.common.utils.enums.ExceptionEnum;

/**
 * @Author: sgw
 * @Date 2019/12/15 12:04
 * @Description: 封装响应结果
 **/
public class ExceptionResult {
  private int status;
  private String message;
  private Long timestamp;

    public ExceptionResult(ExceptionEnum em) {
        this.status = em.getCode();
        this.message=em.getMsg();
        this.timestamp=System.currentTimeMillis();
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Long getTimestamp() {
        return timestamp;
    }

    public void setTimestamp(Long timestamp) {
        this.timestamp = timestamp;
    }
}

controller抛异常的时候，抛出自定义异常：

package com.leyou.item.web;

import com.leyou.common.utils.com.leyou.common.advice.com.leyou.common.exception.LyException;
import com.leyou.common.utils.enums.ExceptionEnum;
import com.leyou.item.pojo.Item;
import com.leyou.item.service.ItemService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Author: sgw
 * @Date 2019/12/15 10:57
 * @Description: TODO
 **/
@RestController("/item")
public class ItemController {
    @Autowired
    private ItemService itemService;
    @PostMapping
    public ResponseEntity<Item> saveItem(Item item) {
        if (item.getPrice() == null) {
            throw new LyException(ExceptionEnum.PRICE_CANNOT_BE_NULL);
        }
        item = itemService.saveItem(item);
        return ResponseEntity.status(HttpStatus.CREATED).body(item);
    }
}

结果：