springmvc异常处理

Springmvc全局异常处理,实现原理

​ Springmvc的异常处理是由下面这个接口提供的，只有一个方法，用来处理异常。称之为异常处理器。

public interface HandlerExceptionResolver {

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

}

​ DispatcherServlet在初始化时，会调用下面这个方法，在这里初始化所有的异常处理器。这里的逻辑是如果容器内存在该类型的实例，就用容器内的，如果不存在就使用默认spring.factories文件里写的默认值。

​ 并且可以选择是搜索所有HandlerExceptionResolver.class类型的bean，还是只搜索名字叫handlerExceptionResolver的bean，由字段detectAllHandlerExceptionResolvers决定，默认搜索全部的。

private void initHandlerExceptionResolvers(ApplicationContext context) {
	this.handlerExceptionResolvers = null;
		
       
	if (this.detectAllHandlerExceptionResolvers) {
		Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils
				.beansOfTypeIncludingAncestors(context, HandlerExceptionResolver.class, true, false);
		if (!matchingBeans.isEmpty()) {
			this.handlerExceptionResolvers = new ArrayList<HandlerExceptionResolver>(matchingBeans.values());
			// We keep HandlerExceptionResolvers in sorted order.
			OrderComparator.sort(this.handlerExceptionResolvers);
		}
	}
	else {
		try {
			HandlerExceptionResolver her =
					context.getBean(HANDLER_EXCEPTION_RESOLVER_BEAN_NAME, HandlerExceptionResolver.class);
			this.handlerExceptionResolvers = Collections.singletonList(her);
		}
		catch (NoSuchBeanDefinitionException ex) {
			// Ignore, no HandlerExceptionResolver is fine too.
		}
	}

	if (this.handlerExceptionResolvers == null) {
		this.handlerExceptionResolvers = getDefaultStrategies(context, HandlerExceptionResolver.class);
		
	}
}

​ doDispatch方法里，将查找controller并调用。渲染结果会调用下面这个方法，用于处理结果返回值。其中参数exception不为空时表示有错误发生的，就用到了异常处理器。

private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
		@Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
		@Nullable Exception exception) throws Exception {

	boolean errorView = false;
	//异常不为空
	if (exception != null) {
		if (exception instanceof ModelAndViewDefiningException) {
			logger.debug("ModelAndViewDefiningException encountered", exception);
			mv = ((ModelAndViewDefiningException) exception).getModelAndView();
		}
		else {
			Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);		
               //处理异常，返回处理结果
			mv = processHandlerException(request, response, handler, exception);
			errorView = (mv != null);
		}
	}

	// Did the handler return a view to render?
	if (mv != null && !mv.wasCleared()) {
		render(mv, request, response);
		if (errorView) {
			WebUtils.clearErrorRequestAttributes(request);
		}
	}
	else {
		if (logger.isTraceEnabled()) {
			logger.trace("No view rendering, null ModelAndView returned.");
		}
	}

	if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
		// Concurrent handling started during a forward
		return;
	}

	if (mappedHandler != null) {
		mappedHandler.triggerAfterCompletion(request, response, null);
	}
}

​ 多个异常处理器会以责任链模式调用，这里可以看出，如果配置多个异常处理器，通过返回值是否为null来判断是否处理完成了。

@Nullable
	protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response,
			@Nullable Object handler, Exception ex) throws Exception {

		// Success and error responses may use different content types
		request.removeAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);

		// 
		ModelAndView exMv = null;
		if (this.handlerExceptionResolvers != null) {
            //责任链模式
			for (HandlerExceptionResolver resolver : this.handlerExceptionResolvers) {
				exMv = resolver.resolveException(request, response, handler, ex);
				if (exMv != null) {
					break;
				}
			}
		}
		if (exMv != null) {
			if (exMv.isEmpty()) {
				request.setAttribute(EXCEPTION_ATTRIBUTE, ex);
				return null;
			}
			// We might still need view name translation for a plain error model...
			if (!exMv.hasView()) {
				String defaultViewName = getDefaultViewName(request);
				if (defaultViewName != null) {
					exMv.setViewName(defaultViewName);
				}
			}
			if (logger.isTraceEnabled()) {
				logger.trace("Using resolved error view: " + exMv, ex);
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Using resolved error view: " + exMv);
			}
			WebUtils.exposeErrorRequestAttributes(request, ex, getServletName());
			return exMv;
		}

		throw ex;
	}

​ 下面介绍ExceptionHandlerExceptionResolver源码，我们经常使用的就是这个，他需要配合

RequestMappingHandlerMapping，RequestMappingHandlerAdapter使用。这是我们最常用的组合。

​ 处理异常的逻辑如下，这里会优先查找controller里面的@ExceptionHandler注解标注的方法，如果没有则使用全局@ControllerAdvice里面的@ExceptionHandler标记的全局处理函数。

	@Override
	protected ModelAndView doResolveHandlerMethodException(HttpServletRequest request,
			HttpServletResponse response, HandlerMethod handlerMethod, Exception exception) {
		//查找该异常类型对应的处理函数
		ServletInvocableHandlerMethod exceptionHandlerMethod = getExceptionHandlerMethod(handlerMethod, exception);
		if (exceptionHandlerMethod == null) {
			return null;
		}

	//这里设置了参数处理器，和返回值处理器		exceptionHandlerMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);	exceptionHandlerMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);

		ServletWebRequest webRequest = new ServletWebRequest(request, response);
		ModelAndViewContainer mavContainer = new ModelAndViewContainer();

		try {
			//开始回掉异常处理函数
			exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, exception);
		}
		catch (Exception invocationEx) {
			logger.error("Failed to invoke @ExceptionHandler method: " + exceptionHandlerMethod, invocationEx);
			return null;
		}

		if (mavContainer.isRequestHandled()) {
			return new ModelAndView();
		}
		else {
			ModelAndView mav = new ModelAndView().addAllObjects(mavContainer.getModel());
			mav.setViewName(mavContainer.getViewName());
			if (!mavContainer.isViewReference()) {
				mav.setView((View) mavContainer.getView());
			}
			return mav;
		}
	}



protected ServletInvocableHandlerMethod getExceptionHandlerMethod(HandlerMethod handlerMethod, Exception exception) {
    //优先解析类里面的处理函数
		if (handlerMethod != null) {
			Class<?> handlerType = handlerMethod.getBeanType();
			ExceptionHandlerMethodResolver resolver = this.exceptionHandlerCache.get(handlerType);
			if (resolver == null) {
				resolver = new ExceptionHandlerMethodResolver(handlerType);
				this.exceptionHandlerCache.put(handlerType, resolver);
			}
			Method method = resolver.resolveMethod(exception);
			if (method != null) {
				return new ServletInvocableHandlerMethod(handlerMethod.getBean(), method);
			}
		}
    //其次查找全局的处理函数
		for (Entry<ControllerAdviceBean, ExceptionHandlerMethodResolver> entry : this.exceptionHandlerAdviceCache.entrySet()) {
			Method method = entry.getValue().resolveMethod(exception);
			if (method != null) {
				return new ServletInvocableHandlerMethod(entry.getKey().resolveBean(), method);
			}
		}
		return null;
	}

​

​ 还有一点，@ExceptionHandler注解能添加exception类型的value值，只有匹配的异常类型才会使用此函数处理。如果没有在注解上标识能处理那种异常，则会解析方法的参数，参数中存在哪种异常就处理哪种。所以下面两种写法是等同的。

​ 如果同时存在，则以注解上的为准。

@ExceptionHandler
public String exception(RuntimeException e) {
	return e.getMessage();
}

@ExceptionHandler(value = RuntimeException.class)
public String exception() {
	return "";
}

​ 还有一种常用的用法，用于接口的异常处理中，返回值是需要转成Json形式的，这里要在处理器上添加@ResponseBody注解，并且返回值是一个可以序列化成Json的对象。

@ExceptionHandler
@ResponseBody
public JsonResource exception(Exception e) {
	return JsonResource.ofFail(e.toString());
}

​ 这种情况下需要配置返回值处理器，查看ExceptionHandlerExceptionResolver内的代码，其在初始化方法里初始化了returnValueHandlers。

public void afterPropertiesSet() {
	if (this.argumentResolvers == null) {
		List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
		this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
	}
	if (this.returnValueHandlers == null) {
		List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
		this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
	}
	initExceptionHandlerAdviceCache();
}


protected List<HandlerMethodReturnValueHandler> getDefaultReturnValueHandlers() {
	List<HandlerMethodReturnValueHandler> handlers = new ArrayList<HandlerMethodReturnValueHandler>();

	// Single-purpose return value types
	handlers.add(new ModelAndViewMethodReturnValueHandler());
	handlers.add(new ModelMethodProcessor());
	handlers.add(new ViewMethodReturnValueHandler());
	handlers.add(new HttpEntityMethodProcessor(getMessageConverters(), this.contentNegotiationManager));

	// Annotation-based return value types
	handlers.add(new ModelAttributeMethodProcessor(false));
	handlers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.contentNegotiationManager));

	// Multi-purpose return value types
	handlers.add(new ViewNameMethodReturnValueHandler());
	handlers.add(new MapMethodProcessor());

	// Custom return value types
	if (getCustomReturnValueHandlers() != null) {
		handlers.addAll(getCustomReturnValueHandlers());
	}

	// Catch-all
	handlers.add(new ModelAttributeMethodProcessor(true));

	return handlers;
}

​ returnValueHandlers不是本文要将的，这里说明一点RequestResponseBodyMethodProcessor是用来处理带有@ResponseBody注解的方法返回值，它的构造方法是要传入MessageConverters，要想将对象转成Json，需要给他配置一个MappingJackson2HttpMessageConverter才可以。

​

​ 如果是xml方式配置，就是下面这样。。

<bean class="org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver">
        <property name="messageConverters">
            <list>
                <ref bean="stringHttpMessageConverter"/>
                <ref bean="jacksonHttpMessageConverter"/>
            </list>
        </property>
    </bean>

​

​ 使用java代码方式也是同理的，就是要将能处理返回值的messageConverter加入到messageConverter列表里。这里是继承它，在构造方法里加入messageConverter即可

@Component
public class HandlerExceptionResolvers extends ExceptionHandlerExceptionResolver {

    public HandlerExceptionResolvers() {
        getMessageConverters().add(new MappingJackson2HttpMessageConverter());
    }
}

总结

一般组合

​ 一般是要使用ExceptionHandlerExceptionResolver + RequestMappingHandlerMapping + RequestMappingHandlerAdapter这一组组合来处理请求的，spring4.x版本默认也是这样。

配置方式

​ 通过在方法上添加@ExceptionHandler注解可以将方法标记为一个异常处理器，并且在Controller里面写的异常处理器优先级大于@ControllerAdvice类里写的。

​ @ExceptionHandler注解上或者方法参数上都可以指定能够处理的异常类型，一般写在参数里就可以。

注意事项

​ 异常处理的返回值会使用返回值处理器做处理，所以也需要配置返回值处理器，和配置RequestMappingHandlerAdapter是一样的。通用做法就是注入MappingJackson2HttpMessageConverter进去。

​