SpringMVC异常统一处理

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很关键

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 />静态资源注解

<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>