1、简介

在SpringBoot项目中，由于我们项目中难免会出现各种异常，一个个处理并不一定能包括全部异常，这时候我们需要一个全局类来处理项目中所抛出的异常。

2、实现步骤

a、定义一个类

  1. import com.ck.syscheck.utils.JsonResult;
  2. import org.slf4j.Logger;
  3. import org.slf4j.LoggerFactory;
  4. import org.springframework.beans.TypeMismatchException;
  5. import org.springframework.beans.ConversionNotSupportedException;
  6. import org.springframework.http.converter.HttpMessageNotReadableException;
  7. import org.springframework.http.converter.HttpMessageNotWritableException;
  8. import org.springframework.web.HttpMediaTypeNotAcceptableException;
  9. import org.springframework.web.HttpRequestMethodNotSupportedException;
  10. import org.springframework.web.bind.MissingServletRequestParameterException;
  11. import org.springframework.web.bind.annotation.ControllerAdvice;
  12. import org.springframework.web.bind.annotation.ExceptionHandler;
  13. import org.springframework.web.bind.annotation.ResponseBody;
  15. import java.io.IOException;
  17. /**
  18.  * 定义全局异常类
  19.  */
  20. @ControllerAdvice
  21. @ResponseBody
  22. public class GlobalExceptionHandler {
  24.     private static final String logExceptionFormat = "Capture Exception By GlobalExceptionHandler: Code: %s Detail: %s";
  25.     private static Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);
  27.     /**
  28.      * 运行时异常
  29.      *
  30.      * @param ex
  31.      * @return
  32.      */
  33.     @ExceptionHandler(RuntimeException.class)
  34.     public String runtimeExceptionHandler(RuntimeException ex) {
  35.         return resultFormat(1, ex);
  36.     }
  38.     /**
  39.      * 空指针异常
  40.      *
  41.      * @param ex
  42.      * @return
  43.      */
  44.     @ExceptionHandler(NullPointerException.class)
  45.     public String nullPointerExceptionHandler(NullPointerException ex) {
  46.         System.err.println("NullPointerException:");
  47.         return resultFormat(2, ex);
  48.     }
  50.     /**
  51.      * 类型转换异常
  52.      *
  53.      * @param ex
  54.      * @return
  55.      */
  56.     @ExceptionHandler(ClassCastException.class)
  57.     public String classCastExceptionHandler(ClassCastException ex) {
  58.         return resultFormat(3, ex);
  59.     }
  61.     /**
  62.      * IO异常
  63.      *
  64.      * @param ex
  65.      * @return
  66.      */
  67.     @ExceptionHandler(IOException.class)
  68.     public String iOExceptionHandler(IOException ex) {
  69.         return resultFormat(4, ex);
  70.     }
  72.     /**
  73.      * 未知方法异常
  74.      *
  75.      * @param ex
  76.      * @return
  77.      */
  78.     @ExceptionHandler(NoSuchMethodException.class)
  79.     public String noSuchMethodExceptionHandler(NoSuchMethodException ex) {
  80.         return resultFormat(5, ex);
  81.     }
  83.     /**
  84.      * 数组越界异常
  85.      *
  86.      * @param ex
  87.      * @return
  88.      */
  89.     @ExceptionHandler(IndexOutOfBoundsException.class)
  90.     public String indexOutOfBoundsExceptionHandler(IndexOutOfBoundsException ex) {
  91.         return resultFormat(6, ex);
  92.     }
  94.     /**
  95.      * 400错误
  96.      *
  97.      * @param ex
  98.      * @return
  99.      */
  100.     @ExceptionHandler({HttpMessageNotReadableException.class})
  101.     public String requestNotReadable(HttpMessageNotReadableException ex) {
  102.         System.out.println("400..requestNotReadable");
  103.         return resultFormat(7, ex);
  104.     }
  106.     /**
  107.      * 400错误
  108.      *
  109.      * @param ex
  110.      * @return
  111.      */
  112.     @ExceptionHandler({TypeMismatchException.class})
  113.     public String requestTypeMismatch(TypeMismatchException ex) {
  114.         System.out.println("400..TypeMismatchException");
  115.         return resultFormat(8, ex);
  116.     }
  118.     /**
  119.      * 400错误
  120.      *
  121.      * @param ex
  122.      * @return
  123.      */
  124.     @ExceptionHandler({MissingServletRequestParameterException.class})
  125.     public String requestMissingServletRequest(MissingServletRequestParameterException ex) {
  126.         System.out.println("400..MissingServletRequest");
  127.         return resultFormat(9, ex);
  128.     }
  130.     /**
  131.      * 405错误
  132.      *
  133.      * @param ex
  134.      * @return
  135.      */
  136.     @ExceptionHandler({HttpRequestMethodNotSupportedException.class})
  137.     public String request405(HttpRequestMethodNotSupportedException ex) {
  138.         return resultFormat(10, ex);
  139.     }
  141.     /**
  142.      * 406错误
  143.      *
  144.      * @param ex
  145.      * @return
  146.      */
  147.     @ExceptionHandler({HttpMediaTypeNotAcceptableException.class})
  148.     public String request406(HttpMediaTypeNotAcceptableException ex) {
  149.         System.out.println("406...");
  150.         return resultFormat(11, ex);
  151.     }
  153.     /**
  154.      * 500错误
  155.      *
  156.      * @param ex
  157.      * @return
  158.      */
  159.     @ExceptionHandler({ConversionNotSupportedException.class, HttpMessageNotWritableException.class})
  160.     public String server500(RuntimeException ex) {
  161.         System.out.println("500...");
  162.         return resultFormat(12, ex);
  163.     }
  165.     /**
  166.      * 栈溢出
  167.      *
  168.      * @param ex
  169.      * @return
  170.      */
  171.     @ExceptionHandler({StackOverflowError.class})
  172.     public String requestStackOverflow(StackOverflowError ex) {
  173.         return resultFormat(13, ex);
  174.     }
  176.     /**
  177.      * 除数不能为0
  178.      *
  179.      * @param ex
  180.      * @return
  181.      */
  182.     @ExceptionHandler({ArithmeticException.class})
  183.     public String arithmeticException(ArithmeticException ex) {
  184.         return resultFormat(13, ex);
  185.     }
  188.     /**
  189.      * 其他错误
  190.      *
  191.      * @param ex
  192.      * @return
  193.      */
  194.     @ExceptionHandler({Exception.class})
  195.     public String exception(Exception ex) {
  196.         return resultFormat(14, ex);
  197.     }
  199.     /**
  200.      * 格式化结构，将其转换为JSon格式
  201.      * 这里使用alibaba的fastjson依赖
  202.      *
  203.      * @param code
  204.      * @param ex
  205.      * @param <T>
  206.      * @return
  207.      */
  208.     private <T extends Throwable> String resultFormat(Integer code, T ex) {
  209.         ex.printStackTrace();
  210.         log.error(String.format(logExceptionFormat, code, ex.getMessage()));
  211.         return JsonResult.failed(code, ex.getMessage());
  212.     }
  214. }

必要注解：
@ControllerAdvice： 使用 @ControllerAdvice，不用任何的配置，只要把这个类放在项目中，Spring能扫描到的地方。就可以实现全局异常的回调。
把@ControllerAdvice注解内部使用@ExceptionHandler、@InitBinder、@ModelAttribute注解的方法应用到所有的 @RequestMapping注解的方法。

  2. package org.springframework.web.bind.annotation;
  4. import java.lang.annotation.Annotation;
  5. import java.lang.annotation.Documented;
  6. import java.lang.annotation.ElementType;
  7. import java.lang.annotation.Retention;
  8. import java.lang.annotation.RetentionPolicy;
  9. import java.lang.annotation.Target;
  10. import org.springframework.core.annotation.AliasFor;
  11. import org.springframework.stereotype.Component;
  13. @Target({ElementType.TYPE})
  14. @Retention(RetentionPolicy.RUNTIME)
  15. @Documented
  16. @Component
  17. public @interface ControllerAdvice {
  18.     @AliasFor("basePackages")
  19.     String[] value() default {};
  21.     @AliasFor("value")
  22.     String[] basePackages() default {};
  24.     Class<?>[] basePackageClasses() default {};
  26.     Class<?>[] assignableTypes() default {};
  28.     Class<? extends Annotation>[] annotations() default {};
  29. }


@ExceptionHandler注解：标识异常类型对应的处理方法_

  2. import java.lang.annotation.Documented;
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Retention;
  5. import java.lang.annotation.RetentionPolicy;
  6. import java.lang.annotation.Target;
  8. @Target({ElementType.METHOD})
  9. @Retention(RetentionPolicy.RUNTIME)
  10. @Documented
  11. public @interface ExceptionHandler {
  12.     Class<? extends Throwable>[] value() default {};
  13. }

b、定义一个JSON格式化工具类

该类用来处理抛出的异常信息

  1. import com.alibaba.fastjson.JSON;
  2. import lombok.Data;
  3. import java.io.Serializable;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6. /**
  7.  * json格式化数据
  8.  */
  9. @Data
  10. public class JsonResult implements Serializable {
  11.     /**
  12.      * 返回码 非0即失败
  13.      */
  14.     private int code;
  15.     /**
  16.      * 消息提示
  17.      */
  18.     private String msg;
  19.     /**
  20.      * 返回的数据
  21.      */
  22.     private Map<String, Object> data;
  24.     public JsonResult() {
  25.     }
  27.     public JsonResult(int code, String msg, Map<String, Object> data) {
  28.         this.code = code;
  29.         this.msg = msg;
  30.         this.data = data;
  31.     }
  33.     public static String success() {
  34.         return success(new HashMap(0));
  35.     }
  37.     public static String success(Map<String, Object> data) {
  38.         return JSON.toJSONString(new JsonResult(0, "解析成功", data));
  39.     }
  41.     public static String failed() {
  42.         return failed("解析失败");
  43.     }
  45.     public static String failed(String msg) {
  46.         return failed(-1, msg);
  47.     }
  49.     public static String failed(int code, String msg) {
  50.         return JSON.toJSONString(new JsonResult(code, msg, new HashMap(0)));
  51.     }
  53. }

注意：这里的JSON格式化工具使用的是阿里的fastjson依赖

  1. <dependency>
  2.     <groupId>com.alibaba</groupId>
  3.     <artifactId>fastjson</artifactId>
  4.     <version>1.2.58</version>
  5. </dependency>

c、浏览器输入错误的URL测试

结果信息展示，当在浏览器访问抛出异常时，页面出现的信息（以下仅仅以一个案例为栗）。
实际需要POST请求，结果给了GET请求，导致出现以下错误。
image.png