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

 package cn.com.servyou.gxdqy.exceptions; 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;
    }
}