SpringMVC 异常处理 - HandlerExceptionResolver

ref: http://blog.csdn.net/u012420654/article/details/52141807

基本概念

在 SpringMVC 中 HandlerExceptionResolver 接口负责统一异常处理。

内部构造

下面来看它的源码：

public interface HandlerExceptionResolver {

ModelAndView resolveException(
HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex);
}

1
2
3
4
5
6

再来看它的继承关系：

AbstractHandlerMethodExceptionResolver

该类是实现了 HandlerExceptionResolver 接口的抽象实现类。关键来看 resolveException 方法：

public ModelAndView resolveException(HttpServletRequest request,
HttpServletResponse response, Object handler, Exception ex) {

// 1.判断是否支持该处理器
if (shouldApplyTo(request, handler)) {

// 省略部分源码...

// 2.预处理响应消息，让请求头取消缓存
prepareResponse(ex, response);

// 3.异常处理，空方法
ModelAndView mav = doResolveException(request, response, handler, ex);
if (mav != null) {
logException(ex, request);
}

return mav;

} else {
return null;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

接着来看 shouldApplyTo 方法：

protected boolean shouldApplyTo(HttpServletRequest request, Object handler) {
if (handler != null) {
// 分别比对 mappedHandlers 、mappedHandlerClasses
if (this.mappedHandlers != null &&
this.mappedHandlers.contains(handler)) {
return true;
}

if (this.mappedHandlerClasses != null) {
for (Class<?> handlerClass : this.mappedHandlerClasses) {
if (handlerClass.isInstance(handler)) {
return true;
}
}
}
}

return (this.mappedHandlers == null &&
this.mappedHandlerClasses == null);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

SimpleMappingExceptionResolver

它继承了 AbstractHandlerMethodExceptionResolver 。实现了真正的异常处理。

来看该类的 doResolveException 方法：

protected ModelAndView doResolveException(HttpServletRequest request,
HttpServletResponse response, Object handler, Exception ex) {

// 1.决定的视图
String viewName = determineViewName(ex, request);

if (viewName != null) {
// 2.决定错误状态码
Integer statusCode = determineStatusCode(request, viewName);
if (statusCode != null) {
3.设置错误状态码
applyStatusCodeIfPossible(request, response, statusCode);
}

// 4.返回错误页面
return getModelAndView(viewName, ex, request);
} else {
return null;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1.决定视图

// 被过滤的异常集合
private Class<?>[] excludedExceptions;

// 被处理的异常集合
private Properties exceptionMappings;

// 默认的错误显示页面
private String defaultErrorView;

protected String determineViewName(Exception ex, HttpServletRequest request) {

String viewName = null;

// 1.判断属于被过滤的异常？
if (this.excludedExceptions != null) {
for (Class<?> excludedEx : this.excludedExceptions) {
if (excludedEx.equals(ex.getClass())) {
return null;
}
}
}

// 2.判断属于被处理的异常？
if (this.exceptionMappings != null) {
// 找到匹配的页面
viewName = findMatchingViewName(this.exceptionMappings, ex);
}

// 3.为空则使用默认的错误页面
if (viewName == null && this.defaultErrorView != null) {
viewName = this.defaultErrorView;
}
return viewName;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

接着来看 findMatchingViewName 方法：

protected String findMatchingViewName(Properties exceptionMappings, Exception ex) {
String viewName = null;
String dominantMapping = null;
int deepest = Integer.MAX_VALUE;

// 遍历 exceptionMappings
for (Enumeration<?> names = exceptionMappings.propertyNames();
names.hasMoreElements();) {

String exceptionMapping = (String) names.nextElement();

// 关键 -> 匹配异常
int depth = getDepth(exceptionMapping, ex);

if (depth >= 0 &&
( depth < deepest ||
(depth == deepest &&
dominantMapping != null &&
exceptionMapping.length() > dominantMapping.length() ) )) {

deepest = depth;
dominantMapping = exceptionMapping;

viewName = exceptionMappings.getProperty(exceptionMapping);
}
}

// 省略代码...

return viewName;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

继续来看 getDepth 方法：

protected int getDepth(String exceptionMapping, Exception ex) {
// 匹配返回 0，不匹配返回 -1 ，depth 越低的好
return getDepth(exceptionMapping, ex.getClass(), 0);
}

private int getDepth(String exceptionMapping, Class<?> exceptionClass, int depth) {
if (exceptionClass.getName().contains(exceptionMapping)) {
return depth;
}

if (exceptionClass == Throwable.class) {
return -1;
}

return getDepth(exceptionMapping, exceptionClass.getSuperclass(), depth + 1);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.决定错误状态码

// 在配置文件中定义
private Map<String, Integer> statusCodes = new HashMap<String, Integer>();

protected Integer determineStatusCode(HttpServletRequest request, String viewName) {
if (this.statusCodes.containsKey(viewName)) {
return this.statusCodes.get(viewName);
}
return this.defaultStatusCode;
}

1
2
3
4
5
6
7
8
9

3.设置错误状态码

public static final String ERROR_STATUS_CODE_ATTRIBUTE =
"javax.servlet.error.status_code";

protected void applyStatusCodeIfPossible(HttpServletRequest request,
HttpServletResponse response, int statusCode) {

if (!WebUtils.isIncludeRequest(request)) {
// 省略代码...

// 设置错误状态码，并添加到 request 的属性
response.setStatus(statusCode);
request.setAttribute(WebUtils.ERROR_STATUS_CODE_ATTRIBUTE, statusCode);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

4.返回错误页面

protected ModelAndView getModelAndView(String viewName, Exception ex,
HttpServletRequest request) {
return getModelAndView(viewName, ex);
}

protected ModelAndView getModelAndView(String viewName, Exception ex) {
ModelAndView mv = new ModelAndView(viewName);
if (this.exceptionAttribute != null) {
// 省略代码...

mv.addObject(this.exceptionAttribute, ex);
}
return mv;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

实例探究

下面来看 springmvc 中常见的统一异常处理方法。

1.实现 HandlerExceptionResolver 接口

首先需要实现 HandlerExceptionResolver 接口。

public class MyExceptionResolver implements HandlerExceptionResolver {
@Override
public ModelAndView resolveException(HttpServletRequest request,
HttpServletResponse response, Object handler, Exception ex) {

// 异常处理...

// 视图显示专门的错误页
ModelAndView modelAndView = new ModelAndView("error");
return modelAndView;
}
}

1
2
3
4
5
6
7
8
9
10
11
12

配置到 Spring 配置文件中，或者加上@Component 注解。

<bean  class="com.resolver.MyExceptionResolver"/>

1

2.添加 @ExceptionHandler 注解

首先来看它的注解定义：

// 只能作用在方法上，运行时有效
Target(ElementType.METHOD)
Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ExceptionHandler {

// 这里可以定义异常类型，为空表示匹配任何异常
Class<? extends Throwable>[] value() default {};
}

1
2
3
4
5
6
7
8
9

在控制器中使用，可以定义不同方法来处理不同类型的异常。

public abstract class BaseController {
// 处理 IO 异常
@ExceptionHandler(IOException.class)
public ModelAndView handleIOException(HttpServletRequest request, HttpServletResponse response, Exception e) {

// 视图显示专门的错误页
ModelAndView modelAndView = new ModelAndView("error");

return modelAndView;
}

// 处理空指针异常
@ExceptionHandler(NullPointerException.class)
public ModelAndView handleException(HttpServletRequest request, HttpServletResponse response, Exception e) {

// 视图显示专门的错误页
ModelAndView modelAndView = new ModelAndView("error");

return modelAndView;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

使用 @ExceptionHandler 注解实现异常处理有个缺陷就是只对该注解所在的控制器有效。

想要让所有的所有的控制器都生效，就要通过继承来实现。

如上所示（定义了一个抽象的基类控制器） ，可以让其他控制器继承它实现异常处理。

public class HelloController extends BaseController

1

3.利用 SimpleMappingExceptionResolver 类

该类实现了 HandlerExceptionResolver 接口，是 springmvc 默认实现的类，通过它可以实现灵活的异常处理。

只需要在 xml 文件中进行如下配置：

<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
<property name="exceptionMappings">
<props>
<prop key="NullPointerException">nullpointpage</prop>
<prop key="IOException">iopage</prop>
<prop key="NumberFormatException">numberpage</prop>
</props>
</property>
<property name="statusCodes">
<props>
<prop key="nullpointpage">400</prop>
<prop key="iopage">500</prop>
</props>
</property>
<property name="defaultErrorView" value="errorpage"/>
<property name="defaultStatusCode" value="404"/>
</bean>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

exceptionMappings：定义 springmvc 要处理的异常类型和对应的错误页面；

statusCodes：定义错误页面和response 中要返回的错误状态码

defaultErrorView：定义默认错误显示页面，表示处理不了的异常都显示该页面。在这里表示 springmvc 处理不了的异常都跳转到 errorpage页面。

defaultStatusCode：定义 response 默认返回的错误状态码，表示错误页面未定义对应的错误状态码时返回该值；在这里表示跳转到 errorpage、numberpage 页面的 reponse 状态码为 404。

4.ajax 异常处理

对于页面 ajax 的请求产生的异常不就适合跳转到错误页面，而是应该是将异常信息显示在请求回应的结果中。

实现方式也很简单，需要继承了 SimpleMappingExceptionResolver ，重写它的异常处理流程（下面会详细分析）。

public class CustomSimpleMappingExceptionResolver extends SimpleMappingExceptionResolver {

@Override
protected ModelAndView doResolveException(HttpServletRequest request,
HttpServletResponse response, Object handler, Exception ex) {

// 判断是否 Ajax 请求
if ((request.getHeader("accept").indexOf("application/json") > -1 ||
(request.getHeader("X-Requested-With") != null &&
request.getHeader("X-Requested-With").indexOf("XMLHttpRequest") > -1))){

try {
response.setContentType("text/html;charset=UTF-8");
response.setCharacterEncoding("UTF-8");
PrintWriter writer = response.getWriter();
writer.write(ex.getMessage());
writer.flush();
writer.close();
} catch (Exception e) {
LogHelper.info(e);
}
return null;
}

return super.doResolveException(request, response, handler, ex);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

配置文件如上，只是将注入的 Bean 替换成我们自己的定义的 CustomSimpleMappingExceptionResolver 。