spring mvc 异常统一处理方式

import javax.servlet.http.HttpServletRequest;   
import javax.servlet.http.HttpServletResponse;   
  
import org.springframework.web.servlet.HandlerExceptionResolver;   
import org.springframework.web.servlet.ModelAndView;   
  
public class ExceptionHandler implements HandlerExceptionResolver {   
  
    @Override  
    public ModelAndView resolveException(HttpServletRequest request,   
            HttpServletResponse response, Object handler, Exception ex) {   
        // TODO Auto-generated method stub   
        return new ModelAndView("exception");   
    }   
  
}

<bean id="exceptionResolver" class="com.tiantian.xxx.web.handler.ExceptionHandler"/>

import org.springframework.stereotype.Controller;   
import org.springframework.web.bind.annotation.ExceptionHandler;   
import org.springframework.web.bind.annotation.RequestMapping;   
  
import com.tiantian.blog.web.servlet.MyException;   
  
@Controller  
public class GlobalController {   
  
       
    /**  
     * 用于处理异常的  
     * @return  
     */  
    @ExceptionHandler({MyException.class})   
    public String exception(MyException e) {   
        System.out.println(e.getMessage());   
        e.printStackTrace();   
        return "exception";   
    }   
       
    @RequestMapping("test")   
    public void test() {   
        throw new MyException("出错了！");   
    }   
       
       
}

/**  
     * 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)

// 从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);   
            }   
        }   
    }

此段代码ZZ from http://tdcq.iteye.com/blog/890957   
<!-- 全局异常配置 start -->     
     <bean id="exceptionResolver" class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">     
         <property name="exceptionMappings">     
             <props>     
                 <prop key="java.lang.Exception">errors/error</prop>     
                 <prop key="java.lang.Throwable">errors/err</prop>     
             </props>     
         </property>     
         <property name="statusCodes">     
             <props>     
                 <prop key="errors/error">500</prop>     
                 <prop key="errors/404">404</prop>     
             </props>     
         </property>     
         <!-- 设置日志输出级别，不定义则默认不输出警告等错误日志信息 -->     
         <property name="warnLogCategory" value="WARN"></property>     
         <!-- 默认错误页面，当找不到上面mappings中指定的异常对应视图时，使用本默认配置 -->     
         <property name="defaultErrorView" value="errors/error"></property>     
         <!-- 默认HTTP状态码 -->     
         <property name="defaultStatusCode" value="500"></property>     
     </bean>     
     <!-- 全局异常配置 end -->

用spring mvc做了个项目，但是出现异常的情况下居然没有日志输出，然后各种尝试。。。正如上面介绍的：设置日志输出级别，不定义则默认不输出警告等错误日志信息！！【当然，try catch的异常没问题】 
敬请留意。