SpringMvc 全局异常处理器定义，友好的返回后端错误信息

package cn.com.servyou.gxdqy.exceptions;  5 import com.google.common.collect.Maps;
import org.apache.log4j.Logger;
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.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

import java.io.IOException;
import java.util.Map;

/**
 * @author : hao
 * @project : daieweb
 * @description :
 * @time : 2018/5/30 18:25
 */
@ControllerAdvice
public class WebExceptionHandler {

    private static Logger logger = Logger.getLogger(WebExceptionHandler.class);


    private static Map<String, String> messageMap = Maps.newHashMap();

    static {

        messageMap.put("runtimeException", "运行时异常");
        messageMap.put("nullPointerException", "空指针异常");
        messageMap.put("classCastException", "类型转换异常");
        messageMap.put("iOException", "IO异常");
        messageMap.put("noSuchMethodException", "未知方法异常");
        messageMap.put("indexOutOfBoundsException", "数组越界异常");
        messageMap.put("httpMessageNotReadableException", "参数格式错误或没有无参构造器");
        messageMap.put("typeMismatchException", "参数类型异常");
        messageMap.put("missingServletRequestParameterException", "缺少参数异常");
        messageMap.put("httpRequestMethodNotSupportedException", "请求类型异常");
        messageMap.put("httpMediaTypeNotAcceptableException", "请求后缀异常或MediaType前后不匹配");
        messageMap.put("conversionNotSupportedException", "类型注入可能非接口异常");
        messageMap.put("httpMessageNotWritableException", "结果转换异常可能存在bean属性为空");
    }

    @ExceptionHandler(RuntimeException.class)
    @ResponseBody
    public ResponseResult<Object> runtimeExceptionHandler(RuntimeException runtimeException) {
        logger.error(runtimeException.getMessage(), runtimeException);
        return RestResultGenerator.genResult(messageMap.get("runtimeException") + ":" + runtimeException.getMessage());
    }

    @ExceptionHandler(NullPointerException.class)
    @ResponseBody
    public ResponseResult<Object> nullPointerExceptionHandler(NullPointerException nullPointerException) {
        logger.error(nullPointerException.getMessage(), nullPointerException);
        return RestResultGenerator.genResult(messageMap.get("nullPointerException") + ":" + nullPointerException.getMessage());
    }

    @ExceptionHandler(ClassCastException.class)
    @ResponseBody
    public ResponseResult<Object> classCastExceptionHandler(ClassCastException classCastException) {
        logger.error(classCastException.getMessage(), classCastException);
        return RestResultGenerator.genResult(messageMap.get("classCastException") + ":" + classCastException.getMessage());
    }

    @ExceptionHandler(IOException.class)
    @ResponseBody
    public ResponseResult<Object> iOExceptionHandler(IOException iOException) {
        logger.error(iOException.getMessage(), iOException);
        return RestResultGenerator.genResult(messageMap.get("iOException") + ":" + iOException.getMessage());
    }

    @ExceptionHandler(NoSuchMethodException.class)
    @ResponseBody
    public ResponseResult<Object> noSuchMethodExceptionHandler(NoSuchMethodException noSuchMethodException) {
        logger.error(noSuchMethodException.getMessage(), noSuchMethodException);
        return RestResultGenerator.genResult(messageMap.get("noSuchMethodException") + ":" + noSuchMethodException.getMessage());
    }

    @ExceptionHandler(IndexOutOfBoundsException.class)
    @ResponseBody
    public ResponseResult<Object> indexOutOfBoundsExceptionHandler(IndexOutOfBoundsException indexOutOfBoundsException) {
        logger.error(indexOutOfBoundsException.getMessage(), indexOutOfBoundsException);
        return RestResultGenerator.genResult(messageMap.get("indexOutOfBoundsException") + ":" + indexOutOfBoundsException.getMessage());
    }

    @ExceptionHandler({HttpMessageNotReadableException.class})
    @ResponseBody
    public ResponseResult<Object> requestNotReadable(HttpMessageNotReadableException httpMessageNotReadableException) {
        logger.error(httpMessageNotReadableException.getMessage(), httpMessageNotReadableException);
        return RestResultGenerator.genResult(messageMap.get("httpMessageNotReadableException") + ":" + httpMessageNotReadableException.getMessage());
    }

    @ExceptionHandler({TypeMismatchException.class})
    @ResponseBody
    public ResponseResult<Object> requestTypeMismatch(TypeMismatchException typeMismatchException) {
        logger.error(typeMismatchException.getMessage(), typeMismatchException);
        return RestResultGenerator.genResult(messageMap.get("typeMismatchException") + ":" + typeMismatchException.getMessage());
    }

    @ExceptionHandler({MissingServletRequestParameterException.class})
    @ResponseBody
    public ResponseResult<Object> requestMissingServletRequest(MissingServletRequestParameterException missingServletRequestParameterException) {
        logger.error(missingServletRequestParameterException.getMessage(), missingServletRequestParameterException);
        return RestResultGenerator.genResult(messageMap.get("missingServletRequestParameterException") + ":" + missingServletRequestParameterException.getMessage());
    }

    @ExceptionHandler({HttpRequestMethodNotSupportedException.class})
    @ResponseBody
    public ResponseResult<Object> request405(HttpRequestMethodNotSupportedException httpRequestMethodNotSupportedException) {
        logger.error(httpRequestMethodNotSupportedException.getMessage(), httpRequestMethodNotSupportedException);
        return RestResultGenerator.genResult(messageMap.get("httpRequestMethodNotSupportedException") + ":" + httpRequestMethodNotSupportedException.getMessage());
    }

    @ExceptionHandler({HttpMediaTypeNotAcceptableException.class})
    @ResponseBody
    public ResponseResult<Object> request406(HttpMediaTypeNotAcceptableException httpMediaTypeNotAcceptableException) {
        logger.error(httpMediaTypeNotAcceptableException.getMessage(), httpMediaTypeNotAcceptableException);
        return RestResultGenerator.genResult(messageMap.get("httpMediaTypeNotAcceptableException") + ":" + httpMediaTypeNotAcceptableException.getMessage());
    }

    @ExceptionHandler({ConversionNotSupportedException.class})
    @ResponseBody
    public ResponseResult<Object> server500(ConversionNotSupportedException conversionNotSupportedException) {
        logger.error(conversionNotSupportedException.getMessage(), conversionNotSupportedException);
        return RestResultGenerator.genResult(messageMap.get("conversionNotSupportedException") + ":" + conversionNotSupportedException.getMessage());
    }


    @ExceptionHandler({HttpMessageNotWritableException.class})
    @ResponseBody
    public ResponseResult<Object> server500(HttpMessageNotWritableException httpMessageNotWritableException) {
        logger.error(httpMessageNotWritableException.getMessage(), httpMessageNotWritableException);
        return RestResultGenerator.genResult(messageMap.get("conversionNotSupportedException") + ":" + httpMessageNotWritableException.getMessage());
    }
}

异常结果封装：

import java.util.List;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class RestResultGenerator {
    private static final Logger LOGGER = LoggerFactory.getLogger(RestResultGenerator.class);

    public RestResultGenerator() {
    }

    public static <T> ResponseResult<List<T>> genResult(PagerBean<T> data) {
        ResponseResult result = new ResponseResult();
        result.setSuccess(true);
        result.setData(data.getData());
        result.setTotal(data.getTotal());
        result.setPageIndex(data.getPageIndex());
        result.setPageSize(data.getPageSize());
        return result;
    }

    public static <T> ResponseResult<T> genResult(T data, String message) {
        ResponseResult result = new ResponseResult();
        result.setSuccess(true);
        result.setData(data);
        result.setMessage(message);
        return result;
    }

    public static <T> ResponseResult<T> genResult(String error) {
        ResponseResult result = new ResponseResult();
        if(StringUtils.isEmpty(error)) {
            result.setSuccess(true);
        } else {
            result.setSuccess(false);
        }

        result.setError(error);
        return result;
    }
}

　　

返回结果bean:

@JsonInclude(Include.NON_EMPTY) //为空的属性不参与序列化
public class ResponseResult<T> {
    private boolean success = true;
    private String error;
    private T data;
    private String message;
    private long total;
    private int pageSize;
    private int pageIndex;

    public ResponseResult() {
    }

    public long getTotal() {
        return this.total;
    }

    public void setTotal(long total) {
        this.total = total;
    }

    public int getPageSize() {
        return this.pageSize;
    }

    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    public int getPageIndex() {
        return this.pageIndex;
    }

    public void setPageIndex(int pageIndex) {
        this.pageIndex = pageIndex;
    }

    public String getError() {
        return this.error;
    }

    public void setError(String error) {
        this.error = error;
    }

    public T getData() {
        return this.data;
    }

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

    public String getMessage() {
        return this.message;
    }

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

    public boolean isSuccess() {
        return this.success;
    }

    public void setSuccess(boolean success) {
        this.success = success;
    }
}