SpringMVC 坑路9 -> 异常处理

最新推荐文章于 2022-10-18 11:15:27 发布

显魄-Simple

最新推荐文章于 2022-10-18 11:15:27 发布

阅读量468

点赞数

分类专栏： Java javaee springmvc

本文链接：https://blog.youkuaiyun.com/qq_33811662/article/details/82284405

版权

Java 同时被 3 个专栏收录

77 篇文章

订阅专栏

javaee

32 篇文章

订阅专栏

springmvc

13 篇文章

订阅专栏

异常处理简介

Spring MVC 对异常处理的支持有三种方式：

1：使用 Spring MVC 提供的 SimpleMappingExceptionResolver
2：实现 Spring MVC 的异常处理接口 HandlerExceptionResolver 自定义自己的异常处理器
3：用注解的方式实现一个专门用于处理异常的 Controller--ExceptionHandler，通常用来在 Controller 内部实现更个性化点异常处理方式，灵活性更高。

默认异常处理

使用 SimpleMappingExceptionResolver 实现异常处理

<bean class="org.springframework.web.Servlet.handler.SimpleMappingExceptionResolver">
    <!-- 定义默认的异常处理页面，当该异常类型的注册时使用 -->
    <property name="defaultErrorView" value="error"></property>
    <!-- 定义异常处理页面用来获取异常信息的变量名，默认为 exception -->
    <property name="exceptionAttribute" value="ex"></property>
    <!-- 定义需要特殊处理的异常，用类名或完全路径名作为 key，异常以页名作为值 -->
    <property name="exceptionMappings">
        <props>
            <!-- 创建自己所要自定义的异常类 -->
            <prop key="xx.exception.BusinessException">business_error</prop>
            <prop key="xx.exception.ParameterException">parameter_error</prop>
        </props>
    </property>
</bean>

注：出了错过后，异常信息会以 ex 为 key 存放在 request 属性里面，因此在错误页面就可以通过 request 的属性取到异常对象了。

自定义异常处理

public class MyExceptionHandler implements HandlerExceptionResolver{
    public ModelAndView resolveException(
                HttpServletRequest request,
                HttpServletResponse response,
                Object handler,
                Exception ex){
        Map<String,Object> model = new HashMap<String,Object>();
        model.put("ex",ex);
        // 根据不同错误跳转不同页面
        if(ex instanceof BusinessException){
            return new ModelAndView("business_error",model);
        }else if(ex instanceof ParameterException){
            return new ModelAndView("parameter_error",model);
        }else{
            return new ModelAndView("error",model);
        }
    }
}

上述类需要在 spring 的配置文件中配置，示例如下：

<bean id="exceptionHandler" class="xx.exception.MyExceptionHandler"/>

说明：

1：上述示例的 resolveException 方法的第四个参数，就是具体的例外类型
2：如果该方法返回了 null，则 Spring 会继续寻找其他的实现了 HandlerExceptionResolver 接口的 Bean。也就是说，Spring 会搜索所有注册在其环境中实现了 HandlerExceptionResolver 接口的 Bean，逐个执行，知道返回了一个 ModelAndView  对象。

注解式异常处理

使用 @ExceptionHandler 注解实现异常处理
该方法需要定义在 Controller 内部，然后创建一个方法并用 @ExceptionHandler 注解来修饰用来处理异常，这个方法基本和 @RequestMapping 修饰的方法差不多，只是可以多一个类型为 Exception 参数，@ExceptionHandler 中可以添加一个或多个异常的类型，如果为空的话则认为可以触发所有的异常类型错误。

public class BaseController{
    // 处理当前 Controller 的内部发生的异常
    @ExceptionHandler
    public String exp(HttpServletRequest request,Exception ex){
        request.setAttribute("ex",ex);
        // 根据不同错误跳转不同页面
        if(ex instanceof BusinessException){
            return new ModelAndView("business_error",model);
        }else if(ex instanceof ParameterException){
            return new ModelAndView("parameter_error",model);
        }else{
            return new ModelAndView("error",model);
        }
    }
}

异常处理优先级

三种方式同时存在的异常处理优先级

1：优先在自己 Controller 里面寻找 @ExceptionHandler，看能不能处理
2：如果不能，然后在 Spring 中，寻找实现 HandlerExceptionResolver 的 Bean
3：对于多个都能处理的 Bean，则按照配置的先后顺序进行处理
4：只要有一个能处理，不返回 null，那么就结束

三种方式对比

Spring MVC 集成异常处理 3 种方式都可以达到统一异常处理的目标。从 3 种方式的优缺点比较，若只需要简单的集成异常处理，推荐使用 SimpleMappingExceptionResolver 即可；若需要集成的异常处理能够更具个性化，提供给用户更详细的异常信息，推荐自定义实现 HandlerExceptionResolver 接口的方式；若不喜欢 Spring 配置文件或要实现“零配置”，且能接受对原生代码的适当入侵，则建议使用 @ExceptionHandler 注解方式。

拓展

注解式零配置全局拦截异常：

定义返回 Code 类：

public class CodeMsg {
    private int code;
    private String msg;
    // 通用异常
    // 0表示请求成功
    public static CodeMsg SUCCESS = new CodeMsg(0, "success");
    public static CodeMsg SERVER_ERROR = new CodeMsg(400100, "服务端异常");
    public static CodeMsg BIND_ERROR = new CodeMsg(400101, "参数校验异常:%s");
    // 其他异常 xxxx

    public CodeMsg fillArgs(Object... args) {
        int code = this.code;
        String message = String.format(this.msg, args);
        return new CodeMsg(code, message);
    }

    private CodeMsg(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

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

    public int getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }
}

定义 Json 返回类：

public class Result<T> {
    private int code;
    private String msg;
    private T data;

    private Result(T data) {
        this.code = 0;
        this.msg = "success";
        this.data = data;
    }
    private Result(CodeMsg codeMsg) {
        if(codeMsg == null) {
            return;
        }
        this.code = codeMsg.getCode();
        this.msg = codeMsg.getMsg();
    }
    public static <T> Result<T> success(T data){
        return new Result<T>(data);
    }

    public static <T> Result<T> error(CodeMsg codeMsg){
        return new Result<T>(codeMsg);
    }
    public int getCode() {
        return code;
    }
    public String getMsg() {
        return msg;
    }
    public T getData() {
        return data;
    }
    public Result<T> setCode(int code){
        this.code = code;
        return this;
    }
}

示例异常类：

public class GlobalException extends RuntimeException{

    private static final long serialVersionUid = 1L;

    private CodeMsg codeMsg;

    public GlobalException(CodeMsg codeMsg) {
        super(codeMsg.toString());
        this.codeMsg = codeMsg;
    }

    public CodeMsg getCodeMsg() {
        return codeMsg;
    }

}

全局异常拦截类：

import java.util.List;
import javax.servlet.http.HttpServletRequest;
import org.springframework.validation.BindException;
import org.springframework.validation.ObjectError;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
@ControllerAdvice
@ResponseBody
public class GlobalExceptionHandler {
    @ExceptionHandler(value = Exception.class)
    public Result<String> exceptionHandler(HttpServletRequest request, Exception e) {
        e.printStackTrace();
        if (e instanceof GlobalException) {
            GlobalException ex = (GlobalException)e;
            return Result.error(ex.getCodeMsg());
        } else if (e instanceof BindException) {
            BindException ex = (BindException) e;
            List<ObjectError> errors = ex.getAllErrors();
            ObjectError error = errors.get(0);
            String msg = error.getDefaultMessage();
            return Result.error(CodeMsg.BIND_ERROR.fillArgs(msg));
        } else {
            return Result.error(CodeMsg.SERVER_ERROR);
        }
    }
}