springboot全局异常处理

优雅的全局异常处理

首先搭建好springboot项目
springboot项目怎么搭建 这里就忽略了，既然你都在看怎么处理springboot项目的全局异常，那说明你肯定有一个springboot项目
首先亮一下我的springboot项目结构，

你的结构可以不跟我一样包含以下几个步骤就可以了

第一步
创建异常包exception文件夹
在该文件夹下创建所需要统一处理异常的类
1，创建一个基础的接口类，自定义的错误描述枚举类需实现该接口。

public interface BaseErrorInfoInterface {
    /** 错误码*/
    String getResultCode();

    /** 错误描述*/
    String getResultMsg();
}

自定义枚举类
然后我们这里在自定义一个枚举类，并实现该接口。
代码如下:

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 getResultCode() {
        return resultCode;
    }

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

}

自定义异常类
然后我们在来自定义一个异常类，用于处理我们发生的业务异常。
代码如下:

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.getResultCode());
        this.errorCode = errorInfoInterface.getResultCode();
        this.errorMsg = errorInfoInterface.getResultMsg();
    }
    
    public BizException(BaseErrorInfoInterface errorInfoInterface, Throwable cause) {
        super(errorInfoInterface.getResultCode(), cause);
        this.errorCode = errorInfoInterface.getResultCode();
        this.errorMsg = errorInfoInterface.getResultMsg();
    }
    
    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;
    }

    public String getMessage() {
        return errorMsg;
    }

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

}

自定义数据格式
在工具包下面定义统一的数据传输格式
代码如下:

/**
 * 功能描述：工具类
 *
 * <p> 创建时间：May 14, 2018 7:58:06 PM </p>
 */
public class JsonData implements Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	private String code; // 状态码 0 表示成功，1表示处理中，-1表示失败
	private Object data; // 数据
	private String msg;// 描述

	public JsonData() {
	}

	public JsonData(String code, Object data, String msg) {
		this.code = code;
		this.data = data;
		this.msg = msg;
	}

	public JsonData(BaseErrorInfoInterface errorInfo) {
		this.code = errorInfo.getResultCode();
		this.msg = errorInfo.getResultMsg();
	}

	/**
	 * 失败
	 */
	public static JsonData error(BaseErrorInfoInterface errorInfo) {
		return new JsonData(errorInfo.getResultCode(), "", errorInfo.getResultMsg());

	}
	// 失败，传入描述信息,状态码
	public static JsonData error(String code,String msg) {
		return new JsonData(code, "", msg);
	}


	// 失败，传入描述信息
	public static JsonData error(String msg) {
		return new JsonData("-1", "", msg);
	}


	// 成功，传入数据
	public static JsonData buildSuccess() {
		return new JsonData("0", "", "请求成功");
	}

	// 成功，传入数据
	public static JsonData buildSuccess(Object data) {
		return new JsonData("0", data, "请求成功");
	}

	// 失败，传入描述信息
	public static JsonData buildError(String msg) {
		return new JsonData("0", "", msg);
	}
	// 失败，传入描述信息
	public static JsonData buildError(String msg,String code) {
		return new JsonData(code, "", msg);
	}


	// 成功，传入数据,及描述信息
	public static JsonData buildSuccess(Object data, String msg) {
		return new JsonData("0", data, msg);
	}

	// 成功，传入数据,及状态码


	public String getCode() {
		return code;
	}

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

	public Object getData() {
		return data;
	}

	public void setData(Object data) {
		this.data = data;
	}

	public String getMsg() {
		return msg;
	}

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

	@Override
	public String toString() {
		return "JsonData [code=" + code + ", data=" + data + ", msg=" + msg
				+ "]";
	}

}

自定义全局异常处理类
自定义全局异常处理的类。
代码如下:

import com.xfxerj.xfxwecat.utils.jsonUtil.JsonData;
import lombok.extern.slf4j.Slf4j;
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
@Slf4j
public class GlobalExceptionHandler {
    //private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    
    /**
     * 处理自定义的业务异常
     * @param req
     * @param e
     * @return
     */
    @ExceptionHandler(value = BizException.class)
    @ResponseBody
    public JsonData bizExceptionHandler(HttpServletRequest req, BizException e){
        log.error("发生业务异常！原因是：{}",e.getErrorMsg());
        return JsonData.error(e.getErrorCode(),e.getErrorMsg());
    }

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


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

自己去controller层，或者service层抛出一个异常
访问会抛出异常的接口试一下