SpringMVC异常统一处理

2019-06-23

SpringMVC异常统一处理有三种方式

第一种：SimpleMappingExceptionResolver

使用框架中提供的类，这种方式具有集成简单、有良好的扩展性、对已有代码没有入侵性等优点，但该方法仅能获取到异常信息，若在出现异常时，对需要获取除异常以外的数据的情况不适用。

查看源码发现SimpleMappingExceptionResolver
public class SimpleMappingExceptionResolver extends AbstractHandlerExceptionResolver {...}
public abstract class AbstractHandlerExceptionResolver implements HandlerExceptionResolver, Ordered {...}

不难发现SimpleMappingExceptionResolver实际上是实现HandlerExceptionResolver接口。这个接口是springMVC提供的异常处理的统一接口SimpleMappingExceptionResolver是其简单实现。

<!-- 全局异常拦截器 SimpleMappingExceptionResolver是HandlerExceptionResolver的简单实现类-->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
	<property name="exceptionMappings">
		<props>	
			//未知异常处理
			<prop key="java.lang.Throwable">error/500</prop>
		</props>
	</property>
</bean>

第二种：HandlerExceptionResolver

实现HandlerExceptionResolver进行开发相比第一种来说,HandlerExceptionResolver能准确显示定义的异常处理页面,达到了统一异常处理的目标

public class GlobalHandlerExceptionResolver implements HandlerExceptionResolver {
	private static final Logger LOG = LoggerFactory.getLogger(GlobalHandlerExceptionResolver.class);
	/**
	 * 在这里处理所有得异常信息
	 */
	@Override
	public ModelAndView resolveException(HttpServletRequest req, HttpServletResponse resp, Object o, Exception ex) {
		ex.printStackTrace();
		if (ex instanceof AthenaException) {
			// AthenaException为一个自定义异常
			ex.printStackTrace();
			printWrite(ex.toString(), resp);
			return new ModelAndView();
		}
		// RspMsg为一个自定义处理异常信息的类
		// ResponseCode为一个自定义错误码的接口
		RspMsg unknownException = null;
		if (ex instanceof NullPointerException) {
			unknownException = new RspMsg(ResponseCode.CODE_UNKNOWN, "业务判空异常", null);
		} else {
			unknownException = new RspMsg(ResponseCode.CODE_UNKNOWN, ex.getMessage(), null);
		}
		printWrite(unknownException.toString(), resp);
		return new ModelAndView();
	}

	/**
	 * 将错误信息添加到response中
	 * 
	 * @param msg
	 * @param response
	 * @throws IOException
	 */
	public static void printWrite(String msg, HttpServletResponse response) {
		try {
			PrintWriter pw = response.getWriter();
			pw.write(msg);
			pw.flush();
			pw.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

第三种：@ExceptionHandler

使用注解@ExceptionHandler方式进行开发，每个Controller都可以写入一个这个注解方法，来进行异常控制，或者定义一个超类BaseController中来实现，是一样的

public abstract class BaseController {
	//日志对象
	protected Logger logger = LoggerFactory.getLogger(getClass());
	@ExceptionHandler
	public String exp(HttpServletRequest request, HttpServletResponse response, Exception ex) {
		logger.error("【发现异常】===" + ex.getMessage());
		return "error/500";
	}
}

我们可以使用第二种方法使用@ControllerAdvice注解配合使用

@ControllerAdvice
public class GlobalExceptionHandler extends BaseGlobalExceptionHandler {

	protected Logger logger = LoggerFactory.getLogger(getClass());

	// 比如404的异常就会被这个方法捕获
	@ExceptionHandler(NoHandlerFoundException.class)
	@ResponseStatus(HttpStatus.NOT_FOUND)
	public ModelAndView handle404Error(HttpServletRequest req, HttpServletResponse rsp, Exception e) throws Exception {
		return handleError(req, rsp, e, "error/error", HttpStatus.NOT_FOUND);
	}

	// 500的异常会被这个方法捕获
	@ExceptionHandler(Exception.class)
	@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
	public ModelAndView handleError(HttpServletRequest req, HttpServletResponse rsp, Exception e) throws Exception {
		return handleError(req, rsp, e, "error/error", HttpStatus.INTERNAL_SERVER_ERROR);
	}

	// TODO 你也可以再写一个方法来捕获你的自定义异常
	// TRY NOW!!!
}

保证GlobalExceptionHandler可以被扫描到，注入到Spring的容器中，运行时我们发现可以拦截500的错误，但是404的错误拦截不到

我们查看一下SpringMVC的源码，从源头找DispatcherServlet入口类，核心方法doDispatch

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
		HandlerExecutionChain mappedHandler = null;
		boolean multipartRequestParsed = false;

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

		try {
			ModelAndView mv = null;
			Exception dispatchException = null;

			try {
				processedRequest = checkMultipart(request);
				multipartRequestParsed = processedRequest != request;

				// Determine handler for the current request.
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null || mappedHandler.getHandler() == null) {
					noHandlerFound(processedRequest, response);
					return;
				}

				// Determine handler adapter for the current request.
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

				// Process last-modified header, if supported by the handler.
				String method = request.getMethod();
				boolean isGet = "GET".equals(method);
				if (isGet || "HEAD".equals(method)) {
					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
					if (logger.isDebugEnabled()) {
						String requestUri = urlPathHelper.getRequestUri(request);
						logger.debug("Last-Modified value for [" + requestUri + "] is: " + lastModified);
					}
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}

				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				try {
					// Actually invoke the handler.
					mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
				}
				finally {
					if (asyncManager.isConcurrentHandlingStarted()) {
						return;
					}
				}

				applyDefaultViewName(request, mv);
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}
			catch (Exception ex) {
				dispatchException = ex;
			}
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		catch (Exception ex) {
			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
		}
		catch (Error err) {
			triggerAfterCompletionWithError(processedRequest, response, mappedHandler, err);
		}
		finally {
			if (asyncManager.isConcurrentHandlingStarted()) {
				// Instead of postHandle and afterCompletion
				mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
				return;
			}
			// Clean up any resources used by a multipart request.
			if (multipartRequestParsed) {
				cleanupMultipart(processedRequest);
			}
		}
	}

查看其noHandlerFound源码

/**
 * No handler found -> set appropriate HTTP response status.
 * @param request current HTTP request
 * @param response current HTTP response
 * @throws Exception if preparing the response failed
 */
protected void noHandlerFound(HttpServletRequest request, HttpServletResponse response) throws Exception {
	if (pageNotFoundLogger.isWarnEnabled()) {
		String requestUri = urlPathHelper.getRequestUri(request);
		pageNotFoundLogger.warn("No mapping found for HTTP request with URI [" + requestUri +
				"] in DispatcherServlet with name '" + getServletName() + "'");
	}
	if(throwExceptionIfNoHandlerFound) {
		ServletServerHttpRequest req = new ServletServerHttpRequest(request);
		throw new NoHandlerFoundException(req.getMethod().name(),
				req.getServletRequest().getRequestURI(),req.getHeaders());
	} else {
		response.sendError(HttpServletResponse.SC_NOT_FOUND);
	}
}

变量throwExceptionIfNoHandlerFound很关键

1	private boolean throwExceptionIfNoHandlerFound = false;

发现定义的是false，对于404的这种情况SpringMVC有特殊处理response.sendError(HttpServletResponse.SC_NOT_FOUND);没有抛出异常

我们需要设置throwExceptionIfNoHandlerFound为true让其抛出NoHandlerFoundException由我们自己进行管理

我们可以在web.xml中配置

<servlet>
	<servlet-name>spring</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	<init-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:spring-mvc.xml</param-value>
	</init-param>
	<!-- 4xx 异常拦截打开 -->
	<init-param>
		<param-name>throwExceptionIfNoHandlerFound</param-name>
		<param-value>true</param-value>
	</init-param>
	<load-on-startup>1</load-on-startup>
	<async-supported>true</async-supported>
</servlet>

打开了异常拦截，这一步网上有资料搜索就可以了，下面进行测试

测试发现还是没有拦截到404的错误，也是很郁闷，网上搜了很多资料还是一筹莫展。

关键：在springmvc的配置文件中找到了mvc:default-servlet-handler/，看着就很熟悉是吧，这是由于SpringMVC拦截所有请求，对于静态的资源也不放过，我们要放行静态资源加入这个注解，在springMVC-servlet.xml中配置<mvc:default-servlet-handler />后，会在Spring MVC上下文中定义一个org.springframework.web.servlet.resource.DefaultServletHttpRequestHandler，它会像一个检查员，对进入DispatcherServlet的URL进行筛查，如果发现是静态资源的请求，就将该请求转由Web应用服务器默认的Servlet处理，如果不是静态资源的请求，才由DispatcherServlet继续处理。

对url进行筛选。

查看源码

/**
 * Set whether to throw a NoHandlerFoundException when no Handler was found for this request.
 * This exception can then be caught with a HandlerExceptionResolver or an
 * {@code @ExceptionHandler} controller method.
 * <p>Note that if
 * {@link org.springframework.web.servlet.resource.DefaultServletHttpRequestHandler}
 * is used, then requests will always be forwarded to the default servlet and
 * a NoHandlerFoundException would never be thrown in that case.
 * <p>Default is "false", meaning the DispatcherServlet sends a NOT_FOUND error
 * through the Servlet response.
 * @since 4.0
 */
public void setThrowExceptionIfNoHandlerFound(boolean throwExceptionIfNoHandlerFound) {
	this.throwExceptionIfNoHandlerFound = throwExceptionIfNoHandlerFound;
}

设置这个NoHandlerFoundException是有条件的，当有DefaultServletHttpRequestHandler时则默认转到servlet，绝不会抛出NoHandlerFoundException异常

而<mvc:default-servlet-handler />恰恰是在Spring MVC上下文中定义一个org.springframework.web.servlet.resource.DefaultServletHttpRequestHandler，所以没有抛异常。

要想拦截404这种异常不能使用<mvc:default-servlet-handler />，但是不使用又会导致静态资源的拦截，很为难。我们想到还要有个注解 <mvc:resources />静态资源注解

1	<mvc:resources mapping="/static/**" location="/static/" />

这种方式只是解决了不访问静态资源的时候，404会抛出异常，访问静态资源时找不到的404还是拦截不到，这也是没有办法，SpringMVC的异常处理处理不了系统的所有异常.

我们需要在web.xml中定义其异常时的错误页面

<error-page>
	<error-code>500</error-code>
	<location>/WEB-INF/view/error/500.jsp</location>
</error-page>
<error-page>
	<error-code>404</error-code>
	<location>/WEB-INF/view/error/404.jsp</location>
</error-page>

本文作者： 顾明训
本文链接： https://www.itzones.cn/2019/06/23/SpringMVC异常统一处理/
版权声明： 本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。转载请注明出处！