一、异常分类

这里的异常分类从系统处理异常的角度看，主要分为俩类：业务异常和系统异常

1、业务异常

业务异常主要是一些可预见性异常，处理业务异常，用来提示用户的操作，提高系统的可操作性

常见的业务异常提醒：

请输入XXX
XXX不能为空
XXX重复，请更换

2、系统异常

系统异常主要是一些不可预见性异常，处理系统异常，可以让展示出一个友好的用户界面，不易给用户造成反感。如果是一个金融类系统，在用户界面出现一个系统异常的崩溃界面，很有可能直接导致用户流失。

常见的系统异常提示：

页面丢失404
*
服务器异常500

二、SpringBoot2.0中异常处理

SpringBoot的项目已经对有一定的异常处理了，但是对于我们开发者而言可能就不太合适了，因此我们需要对这些异常进行统一的捕获并处理。SpringBoot中有一个ControllerAdvice的注解，使用该注解表示开启了全局异常的捕获，我们只需在自定义一个方法使用ExceptionHandler注解然后定义捕获异常的类型即可对这些捕获的异常进行统一的处理。

示例代码：

@ControllerAdvice
public class MyExceptionHandler {

    @ExceptionHandler(value =Exception.class)
	public String exceptionHandler(Exception e){
		System.out.println("未知异常！原因是:"+e);
       	return e.getMessage();
    }
}

上述的示例中，我们对捕获的异常进行简单的二次处理，返回异常的信息，虽然这种能够让我们知道异常的原因，但是在很多的情况下来说，可能还是不够人性化，不符合我们的要求。那么我们这里可以通过自定义的异常类以及枚举类来实现我们想要的那种数据吧

自定义基础接口类

package com.mye.hl16springbootexception.exception03;

public interface BaseErrorInfoInterface {

    //错误码
	 String resultCode();
	
	//错误描述
	 String resultMsg();
}

自定义枚举类

package com.mye.hl16springbootexception.exception03;

public enum CommonEnum implements BaseErrorInfoInterface {
	// 数据操作错误定义
	SUCCESS("200", "成功!"), 
	BODY_NOT_MATCH("400","请求的数据格式不符!"),
	SIGNATURE_NOT_MATCH("401","请求的数字签名不匹配!"),
	NOT_FOUND("404", "未找到该资源!"), 
	INTERNAL_SERVER_ERROR("500", "服务器内部错误!"),
	SERVER_BUSY("503","服务器正忙，请稍后再试!")
	;

	//错误码
	private String resultCode;

	//错误描述
	private String resultMsg;

	CommonEnum(String resultCode, String resultMsg) {
		this.resultCode = resultCode;
		this.resultMsg = resultMsg;
	}

	@Override
	public String resultCode() {
		return resultCode;
	}

	@Override
	public String resultMsg() {
		return resultMsg;
	}
}

自定义异常类

package com.mye.hl16springbootexception.exception03;

public class BizException extends RuntimeException {

	private static final long serialVersionUID = 1L;

	/** * 错误码 */
	protected String errorCode;
	/** * 错误信息 */
	protected String errorMsg;

	public BizException() {
		super();
	}

	public BizException(BaseErrorInfoInterface errorInfoInterface) {
		super(errorInfoInterface.resultCode());
		this.errorCode = errorInfoInterface.resultCode();
		this.errorMsg = errorInfoInterface.resultMsg();
	}
	
	public BizException(BaseErrorInfoInterface errorInfoInterface, Throwable cause) {
		super(errorInfoInterface.resultCode(), cause);
		this.errorCode = errorInfoInterface.resultCode();
		this.errorMsg = errorInfoInterface.resultMsg();
	}
	
	public BizException(String errorMsg) {
		super(errorMsg);
		this.errorMsg = errorMsg;
	}
	
	public BizException(String errorCode, String errorMsg) {
		super(errorCode);
		this.errorCode = errorCode;
		this.errorMsg = errorMsg;
	}

	public BizException(String errorCode, String errorMsg, Throwable cause) {
		super(errorCode, cause);
		this.errorCode = errorCode;
		this.errorMsg = errorMsg;
	}
	

	public String getErrorCode() {
		return errorCode;
	}

	public void setErrorCode(String errorCode) {
		this.errorCode = errorCode;
	}

	public String getErrorMsg() {
		return errorMsg;
	}

	public void setErrorMsg(String errorMsg) {
		this.errorMsg = errorMsg;
	}

	@Override
	public String getMessage() {
		return errorMsg;
	}

	@Override
	public Throwable fillInStackTrace() {
		return this;
	}

}

自定义数据格式

package com.mye.hl16springbootexception.exception03;

import com.alibaba.fastjson.JSONObject;

public class ResultBody {
	/** * 响应代码 */
	private String code;

	/** * 响应消息 */
	private String message;

	/** * 响应结果 */
	private Object result;

	public ResultBody() {
	}

	public ResultBody(BaseErrorInfoInterface errorInfo) {
		this.code = errorInfo.resultCode();
		this.message = errorInfo.resultMsg();
	}

	public String getCode() {
		return code;
	}

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

	public String getMessage() {
		return message;
	}

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

	public Object getResult() {
		return result;
	}

	public void setResult(Object result) {
		this.result = result;
	}

	/** * 成功 * * @return */
	public static ResultBody success() {
		return success(null);
	}

	/** * 成功 * @param data * @return */
	public static ResultBody success(Object data) {
		ResultBody rb = new ResultBody();
		rb.setCode(CommonEnum.SUCCESS.resultCode());
		rb.setMessage(CommonEnum.SUCCESS.resultMsg());
		rb.setResult(data);
		return rb;
	}

	/** * 失败 */
	public static ResultBody error(BaseErrorInfoInterface errorInfo) {
		ResultBody rb = new ResultBody();
		rb.setCode(errorInfo.resultCode());
		rb.setMessage(errorInfo.resultMsg());
		rb.setResult(null);
		return rb;
	}

	/** * 失败 */
	public static ResultBody error(String code, String message) {
		ResultBody rb = new ResultBody();
		rb.setCode(code);
		rb.setMessage(message);
		rb.setResult(null);
		return rb;
	}

	/** * 失败 */
	public static ResultBody error( String message) {
		ResultBody rb = new ResultBody();
		rb.setCode("-1");
		rb.setMessage(message);
		rb.setResult(null);
		return rb;
	}

	@Override
	public String toString() {
		return JSONObject.toJSONString(this);
	}

}

自定义全局异常处理类

package com.mye.hl16springbootexception.exception03;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;

@ControllerAdvice
public class GlobalExceptionHandler {
	private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
	
	/** * 处理自定义的业务异常 * @param req * @param e * @return */
    @ExceptionHandler(value = BizException.class)  
    @ResponseBody  
	public  ResultBody bizExceptionHandler(HttpServletRequest req, BizException e){
    	logger.error("发生业务异常！原因是：{}",e.getErrorMsg());
    	return ResultBody.error(e.getErrorCode(),e.getErrorMsg());
    }

	/** * 处理空指针的异常 * @param req * @param e * @return */
	@ExceptionHandler(value =NullPointerException.class)
	@ResponseBody
	public ResultBody exceptionHandler(HttpServletRequest req, NullPointerException e){
		logger.error("发生空指针异常！原因是:",e);
		return ResultBody.error(CommonEnum.BODY_NOT_MATCH);
	}

    /** * 处理其他异常 * @param req * @param e * @return */
    @ExceptionHandler(value =Exception.class)
	@ResponseBody
	public ResultBody exceptionHandler(HttpServletRequest req, Exception e){
    	logger.error("未知异常！原因是:",e);
       	return ResultBody.error(CommonEnum.INTERNAL_SERVER_ERROR);
    }
}

实体类

@Data
public class User implements Serializable {

	private static final long serialVersionUID = 1L;
	/** 编号 */
	 private int id;
	 /** 姓名 */
	 private String name;
	 /** 年龄 */
	 private int age;
}

Controller 控制层

package com.mye.hl16springbootexception.controller;

import com.mye.hl16springbootexception.exception03.BizException;
import com.mye.hl16springbootexception.pojo.User;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping(value = "/api")
public class UserRestController {

	@PostMapping("/user")
    public boolean insert(@RequestBody User user) {
    	System.out.println("开始新增...");
    	//如果姓名为空就手动抛出一个自定义的异常！
        if(user.getName()==null){
            throw  new BizException("-1","用户姓名不能为空！");
        }
        return true;
    }

    @PutMapping("/user")
    public boolean update(@RequestBody User user) {
    	System.out.println("开始更新...");
       //这里故意造成一个空指针的异常，并且不进行处理
        String str=null;
        str.equals("111");
        return true;
    }

    @DeleteMapping("/user")
    public boolean delete(@RequestBody User user)  {
        System.out.println("开始删除...");
        //这里故意造成一个异常，并且不进行处理
        Integer.parseInt("abc123");
        return true;
    }

    @GetMapping("/user")
    public List<User> findByUser(User user) {
    	System.out.println("开始查询...");
        List<User> userList =new ArrayList<>();
        User user2=new User();
        user2.setId(1);
        user2.setName("xuwujing");
        user2.setAge(18);
        userList.add(user2);
        return userList;
    }
    
}

功能测试

首先进行查询，查看程序正常运行是否ok，使用GET 方式进行请求
GET http://localhost:8080/api/user

返回参数为：

{“id”:1,“name”:“xuwujing”,“age”:18}

可以看到程序正常返回，并没有因自定义的全局异常而影响。

然后我们再来测试下自定义的异常是否能够被正确的捕获并处理。

使用POST方式进行请求
POST http://localhost:8080/api/user

body参数为：

{“id”:1,“age”:18}

返回参数为：

{“code”:"-1",“message”:“用户姓名不能为空！”,“result”:null}

可以看出将我们抛出的异常进行数据封装，然后将异常返回出来。

然后我们再来测试下空指针异常是否能够被正确的捕获并处理。在自定义全局异常中，我们除了定义空指针的异常处理，也定义最高级别之一的Exception异常，那么这里发生了空指针异常之后，它是回优先使用哪一个呢？这里我们来测试下

使用PUT方式进行请求
PUT http://localhost:8080/api/user

Body参数为:

{“id”:1,“age”:18}

返回参数为:

{“code”:“400”,“message”:“请求的数据格式不符!”,“result”:null}

我们可以看到这里的的确是返回空指针的异常护理，可以得出全局异常处理优先处理子类的异常

使用DELETE方式进行请求
DELETE http://localhost:8080/api/user

Body参数为:

{“id”:1}

返回参数为:

{“code”:“500”,“message”:“服务器内部错误!”,“result”:null}

注意：

自义定全局异常处理除了可以处理上述的数据格式之外，也可以处理页面的跳转，只需在新增的异常方法的返回处理上填写该跳转的路径并不使用ResponseBody 注解即可。细心的同学也许发现了在GlobalExceptionHandler类中使用的是ControllerAdvice注解，而非RestControllerAdvice注解，如果是用的RestControllerAdvice注解，它会将数据自动转换成JSON格式，这种于Controller和RestController类似，所以我们在使用全局异常处理的之后可以进行灵活的选择处理。

springboot配置系统全局异常映射处理