使用Spring MVC HandlerExceptionResolver处理异常

转载 http://fancyboy2050.iteye.com/blog/1300037

最近使用spring mvc开发一个web系统，发现在controller里发生未捕获异常时不出日志。

分析DispatcherServlet，初始化handlerExceptionResolvers

Java代码  
        /** 
     * Initialize the strategy objects that this servlet uses. 
     * <p>May be overridden in subclasses in order to initialize 
     * further strategy objects. 
     */  
    protected void initStrategies(ApplicationContext context) {  
        initMultipartResolver(context);  
        initLocaleResolver(context);  
        initThemeResolver(context);  
        initHandlerMappings(context);  
        initHandlerAdapters(context);  
// 初始化异常处理支持器  
        initHandlerExceptionResolvers(context);  
        initRequestToViewNameTranslator(context);  
        initViewResolvers(context);  
    }  
  
// 进入初始化处理方法，具体内容就不贴了，主要是先到上下文中搜寻我们自己定义的ExceptionResolvers，如果没有自定义的resolvers，从默认配置中读取。  
private void initHandlerExceptionResolvers(ApplicationContext context)  
  
// 从默认策略中取得默认配置，从DispatcherServlet.properties文件中取得相关的配置策略，但是在spring2.5的mvc jar包中properties文件中没有HandlerExceptionResolver的默认配置，返回一个EmptyList给handlerExceptionResolvers  
protected List getDefaultStrategies(ApplicationContext context, Class strategyInterface)  

分析DispatcherServlet，分发处理请求

Java代码  
// 从dispatch方法中看到，系统对请求进行具体的逻辑处理部分被catch住了一次exception，然后会使用servlet持有的ExceptionResolver进行处理  
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {  
        HttpServletRequest processedRequest = request;  
        HandlerExecutionChain mappedHandler = null;  
        int interceptorIndex = -1;  
  
        // Expose current LocaleResolver and request as LocaleContext.  
        LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();  
        LocaleContextHolder.setLocaleContext(buildLocaleContext(request), this.threadContextInheritable);  
  
        // Expose current RequestAttributes to current thread.  
        RequestAttributes previousRequestAttributes = RequestContextHolder.getRequestAttributes();  
        ServletRequestAttributes requestAttributes = new ServletRequestAttributes(request);  
        RequestContextHolder.setRequestAttributes(requestAttributes, this.threadContextInheritable);  
  
        if (logger.isTraceEnabled()) {  
            logger.trace("Bound request context to thread: " + request);  
        }  
          
        try {  
            ModelAndView mv = null;  
            boolean errorView = false;  
  
            try {  
                processedRequest = checkMultipart(request);  
  
                // Determine handler for the current request.  
                mappedHandler = getHandler(processedRequest, false);  
                if (mappedHandler == null || mappedHandler.getHandler() == null) {  
                    noHandlerFound(processedRequest, response);  
                    return;  
                }  
  
                // Apply preHandle methods of registered interceptors.  
                HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();  
                if (interceptors != null) {  
                    for (int i = 0; i < interceptors.length; i++) {  
                        HandlerInterceptor interceptor = interceptors[i];  
                        if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) {  
                            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);  
                            return;  
                        }  
                        interceptorIndex = i;  
                    }  
                }  
  
                // Actually invoke the handler.  
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());  
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());  
  
                // Do we need view name translation?  
                if (mv != null && !mv.hasView()) {  
                    mv.setViewName(getDefaultViewName(request));  
                }  
  
                // Apply postHandle methods of registered interceptors.  
                if (interceptors != null) {  
                    for (int i = interceptors.length - 1; i >= 0; i--) {  
                        HandlerInterceptor interceptor = interceptors[i];  
                        interceptor.postHandle(processedRequest, response, mappedHandler.getHandler(), mv);  
                    }  
                }  
            }  
            catch (ModelAndViewDefiningException ex) {  
                logger.debug("ModelAndViewDefiningException encountered", ex);  
                mv = ex.getModelAndView();  
            }  
// 这里catch住controller抛出的异常，使用持有的ExceptionResolver处理，当没有配置自己的处理器时，程序会将异常继续往上抛出，最终交给我们的容器处理  
            catch (Exception ex) {  
                Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);  
                mv = processHandlerException(processedRequest, response, handler, ex);  
                errorView = (mv != null);  
            }  
  
            // Did the handler return a view to render?  
            if (mv != null && !mv.wasCleared()) {  
                render(mv, processedRequest, response);  
                if (errorView) {  
                    WebUtils.clearErrorRequestAttributes(request);  
                }  
            }  
            else {  
                if (logger.isDebugEnabled()) {  
                    logger.debug("Null ModelAndView returned to DispatcherServlet with name '" +  
                            getServletName() + "': assuming HandlerAdapter completed request handling");  
                }  
            }  
  
            // Trigger after-completion for successful outcome.  
            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);  
        }  
// 当没有配置ExceptionResolver时，异常将到达这里，最终抛出  
        catch (Exception ex) {  
            // Trigger after-completion for thrown exception.  
            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);  
            throw ex;  
        }  
        catch (Error err) {  
            ServletException ex = new NestedServletException("Handler processing failed", err);  
            // Trigger after-completion for thrown exception.  
            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);  
            throw ex;  
        }  
  
        finally {  
            // Clean up any resources used by a multipart request.  
            if (processedRequest != request) {  
                cleanupMultipart(processedRequest);  
            }  
  
            // Reset thread-bound context.  
            RequestContextHolder.setRequestAttributes(previousRequestAttributes, this.threadContextInheritable);  
            LocaleContextHolder.setLocaleContext(previousLocaleContext, this.threadContextInheritable);  
  
            // Clear request attributes.  
            requestAttributes.requestCompleted();  
            if (logger.isTraceEnabled()) {  
                logger.trace("Cleared thread-bound request context: " + request);  
            }  
        }  
    }  

转载：http://fuliang.iteye.com/blog/947191

Spring MVC的确很强大，在每一个你想的到和想不到的地方都会留下钩子，来插入自定义的实现，透明替换默认实现，
拦截器堆栈结构设计的非常强大，多种试图的解析，url mapping的多种实现，Locale resolver、Theme resolver
、multipart file resolver，Excepiton hanlder Resolver等等，能让Spring MVC从1.0到3.0经历巨大变化，
仍能向后兼容，并支持很酷的RESTful风格和强大的简化xml配置的注解。
这些功能我们在项目中经常用到，但是Excepiton hanlder Resolver可能是个生僻一点的东东，因为我们通常对错误
的处理通常不是非常的复杂，很多情况下只是根据异常或者http error code跳转到错误页面,这个是JSP/servlet就可
以搞定，在web.xml配置一下即可。

今天遇到一个事情，让我想用到HandlerExceptionResolver这个东东来处理异常。今天准备把自助系统进入上线状态，
所以把log的级别从DEBUG调到INFO，结果没有catch的Runtime异常在log记录，后来跟踪了一下原来Spring把异常处理的log，
直接使用的是debug，而不是error，所以log级别设置为INFO导致异常没有记录，看了一下spring的源代码：

Java代码  
// Check registerer HandlerExceptionResolvers...  
ModelAndView exMv = null;  
for (Iterator it = this.handlerExceptionResolvers.iterator(); exMv == null && it.hasNext();) {  
HandlerExceptionResolver resolver = (HandlerExceptionResolver) it.next();  
exMv = resolver.resolveException(request, response, handler, ex);  
}  
if (exMv != null) {  
if (logger.isDebugEnabled()) {  
logger.debug("Handler execution resulted in exception - forwarding to resolved error view: " + exMv, ex);  
}  
WebUtils.exposeErrorRequestAttributes(request, ex, getServletName());  
return exMv;  
}  

可以看到可以插入自己的HandlerExceptionResover来搞定这个问题，我们可以在resolveException方法任意处理异常和log。也可以
把错误信息个性化后传到view层显示。
我们只有简单的需求，就是把没有catch的异常记入log，将异常的完整信息放在错误页面的一个隐藏的区域，方便查找出现错误的原因。
首先我们实现HandlerExceptionResolver

Java代码  
package com.qunar.advertisement.exception;  
  
import java.util.HashMap;  
import java.util.Map;  
  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  
  
import org.apache.log4j.Logger;  
import org.springframework.web.servlet.HandlerExceptionResolver;  
import org.springframework.web.servlet.ModelAndView;  
  
import com.qunar.advertisement.utils.StringPrintWriter;  
  
public class QADHandlerExceptionResolver implements HandlerExceptionResolver{  
    private static Logger logger = Logger.getLogger(QADHandlerExceptionResolver.class);  
    @Override  
    public ModelAndView resolveException(HttpServletRequest request,  
            HttpServletResponse response, Object handler, Exception ex) {  
        logger.error("Catch Exception: ",ex);//把漏网的异常信息记入日志  
        Map<String,Object> map = new HashMap<String,Object>();  
        StringPrintWriter strintPrintWriter = new StringPrintWriter();  
        ex.printStackTrace(strintPrintWriter);  
        map.put("errorMsg", strintPrintWriter.getString());//将错误信息传递给view  
        return new ModelAndView("error",map);  
    }  
  
}  

我们还需要一个辅助的类StringPrintWriter，因为ex.printStackTrace参数只有个PrintWriter类型的，java自带的StringWriter
不可用,所以我们需要自己实现一个装饰器的StringPrintWriter。

Java代码  
package com.qunar.advertisement.utils;  
  
import java.io.PrintWriter;  
import java.io.StringWriter;  
  
public class StringPrintWriter extends PrintWriter{  
  
    public StringPrintWriter(){  
        super(new StringWriter());  
    }  
     
    public StringPrintWriter(int initialSize) {  
          super(new StringWriter(initialSize));  
    }  
     
    public String getString() {  
          flush();  
          return ((StringWriter) this.out).toString();  
    }  
     
    @Override  
    public String toString() {  
        return getString();  
    }  
}  

我们只需要在xml中配置一下就可以了:

Xml代码  
<bean class="com.qunar.advertisement.exception.QADHandlerExceptionResolver">  
</bean>  

我们在错误页面隐藏区域显示错误信息：

Html代码  
<div style="display:none;">  
     <c:out value="${errorMsg}"></c:out>  
</div>  