spring mvc 異常統一處理方式

時間  2019-11-11
標籤 spring mvc 異常 統一 處理 方式 欄目 Spring 简体版
原文   原文鏈接

springMVC提供的異常處理主要有兩種方式，一種是直接實現本身的HandlerExceptionResolver，另外一種是使用註解的方式實現一個專門用於處理異常的Controller——ExceptionHandler。java

 

一、實現本身的HandlerExceptionResolver，HandlerExceptionResolver是一個接 口，springMVC自己已經對其有了一個自身的實現——DefaultExceptionResolver,該解析器只是對其中的一些比較典型的異常 進行了攔截處理。web

 

  1. import javax.servlet.http.HttpServletRequest;   
  2. import javax.servlet.http.HttpServletResponse;   
  3.   
  4. import org.springframework.web.servlet.HandlerExceptionResolver;   
  5. import org.springframework.web.servlet.ModelAndView;   
  6.   
  7. public class ExceptionHandler implements HandlerExceptionResolver {   
  8.   
  9.     @Override  
  10.     public ModelAndView resolveException(HttpServletRequest request,   
  11.             HttpServletResponse response, Object handler, Exception ex) {   
  12.         // TODO Auto-generated method stub   
  13.         return new ModelAndView("exception");   
  14.     }   
  15.   
  16. }  

 

 上述的resolveException的第4個參數表示對哪一種類型的異常進行處理，若是想同時對多種異常進行處理，能夠把它換成一個異常數組。spring

定義了這樣一個異常處理器以後就要在applicationContext中定義這樣一個bean對象，如：數組

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

 

二、使用@ExceptionHandler進行處理mvc

使用@ExceptionHandler進行處理有一個很差的地方是進行異常處理的方法必須與出錯的方法在同一個Controller裏面app

如：ide

  1. import org.springframework.stereotype.Controller;   
  2. import org.springframework.web.bind.annotation.ExceptionHandler;   
  3. import org.springframework.web.bind.annotation.RequestMapping;   
  4.   
  5. import com.tiantian.blog.web.servlet.MyException;   
  6.   
  7. @Controller  
  8. public class GlobalController {   
  9.   
  10.        
  11.     /**  
  12.      * 用於處理異常的  
  13.      * @return  
  14.      */  
  15.     @ExceptionHandler({MyException.class})   
  16.     public String exception(MyException e) {   
  17.         System.out.println(e.getMessage());   
  18.         e.printStackTrace();   
  19.         return "exception";   
  20.     }   
  21.        
  22.     @RequestMapping("test")   
  23.     public void test() {   
  24.         throw new MyException("出錯了！");   
  25.     }   
  26.        
  27.        
  28. }  

 

這裏在頁面上訪問test方法的時候就會報錯，而擁有該test方法的Controller又擁有一個處理該異常的方法，這個時候處理異常的方法就會被調用post

  

當發生異常的時候，上述兩種方式都使用了的時候，第一種方式會將第二種方式覆蓋ui

 http://gaojiewyh.iteye.com/blog/1297746this

 

 

最近使用spring mvc開發一個web系統，發如今controller裏發生未捕獲異常時不出日誌。

分析DispatcherServlet，初始化handlerExceptionResolvers

  1.         /**  
  2.      * Initialize the strategy objects that this servlet uses.  
  3.      * <p>May be overridden in subclasses in order to initialize  
  4.      * further strategy objects.  
  5.      */  
  6.     protected void initStrategies(ApplicationContext context) {   
  7.         initMultipartResolver(context);   
  8.         initLocaleResolver(context);   
  9.         initThemeResolver(context);   
  10.         initHandlerMappings(context);   
  11.         initHandlerAdapters(context);   
  12. // 初始化異常處理支持器   
  13.         initHandlerExceptionResolvers(context);   
  14.         initRequestToViewNameTranslator(context);   
  15.         initViewResolvers(context);   
  16.     }   
  17.   
  18. // 進入初始化處理方法，具體內容就不貼了，主要是先到上下文中搜尋咱們本身定義的ExceptionResolvers，若是沒有自定義的resolvers，從默認配置中讀取。   
  19. private void initHandlerExceptionResolvers(ApplicationContext context)   
  20.   
  21. // 從默認策略中取得默認配置，從DispatcherServlet.properties文 件中取得相關的配置策略，可是在spring2.5的mvc jar包中properties文件中沒有 HandlerExceptionResolver的默認配置，返回一個EmptyList給handlerExceptionResolvers   
  22. protected List getDefaultStrategies(ApplicationContext context, Class strategyInterface)  
        分析DispatcherServlet，分發處理請求
  1. // 從dispatch方法中看到，系統對請求進行具體的邏輯處理部分被catch住了一次exception，而後會使用servlet持有的ExceptionResolver進行處理   
  2. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {   
  3.         HttpServletRequest processedRequest = request;   
  4.         HandlerExecutionChain mappedHandler = null;   
  5.         int interceptorIndex = -1;   
  6.   
  7.         // Expose current LocaleResolver and request as LocaleContext.   
  8.         LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();   
  9.         LocaleContextHolder.setLocaleContext(buildLocaleContext(request), this.threadContextInheritable);   
  10.   
  11.         // Expose current RequestAttributes to current thread.   
  12.         RequestAttributes previousRequestAttributes = RequestContextHolder.getRequestAttributes();   
  13.         ServletRequestAttributes requestAttributes = new ServletRequestAttributes(request);   
  14.         RequestContextHolder.setRequestAttributes(requestAttributes, this.threadContextInheritable);   
  15.   
  16.         if (logger.isTraceEnabled()) {   
  17.             logger.trace("Bound request context to thread: " + request);   
  18.         }   
  19.            
  20.         try {   
  21.             ModelAndView mv = null;   
  22.             boolean errorView = false;   
  23.   
  24.             try {   
  25.                 processedRequest = checkMultipart(request);   
  26.   
  27.                 // Determine handler for the current request.   
  28.                 mappedHandler = getHandler(processedRequest, false);   
  29.                 if (mappedHandler == null || mappedHandler.getHandler() == null) {   
  30.                     noHandlerFound(processedRequest, response);   
  31.                     return;   
  32.                 }   
  33.   
  34.                 // Apply preHandle methods of registered interceptors.   
  35.                 HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();   
  36.                 if (interceptors != null) {   
  37.                     for (int i = 0; i < interceptors.length; i++) {   
  38.                         HandlerInterceptor interceptor = interceptors[i];   
  39.                         if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) {   
  40.                             triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);   
  41.                             return;   
  42.                         }   
  43.                         interceptorIndex = i;   
  44.                     }   
  45.                 }   
  46.   
  47.                 // Actually invoke the handler.   
  48.                 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());   
  49.                 mv = ha.handle(processedRequest, response, mappedHandler.getHandler());   
  50.   
  51.                 // Do we need view name translation?   
  52.                 if (mv != null && !mv.hasView()) {   
  53.                     mv.setViewName(getDefaultViewName(request));   
  54.                 }   
  55.   
  56.                 // Apply postHandle methods of registered interceptors.   
  57.                 if (interceptors != null) {   
  58.                     for (int i = interceptors.length - 1; i >= 0; i--) {   
  59.                         HandlerInterceptor interceptor = interceptors[i];   
  60.                         interceptor.postHandle(processedRequest, response, mappedHandler.getHandler(), mv);   
  61.                     }   
  62.                 }   
  63.             }   
  64.             catch (ModelAndViewDefiningException ex) {   
  65.                 logger.debug("ModelAndViewDefiningException encountered", ex);   
  66.                 mv = ex.getModelAndView();   
  67.             }   
  68. // 這裏catch住controller拋出的異常，使用持有的ExceptionResolver處理，當沒有配置本身的處理器時，程序會將異常繼續往上拋出，最終交給咱們的容器處理   
  69.             catch (Exception ex) {   
  70.                 Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);   
  71.                 mv = processHandlerException(processedRequest, response, handler, ex);   
  72.                 errorView = (mv != null);   
  73.             }   
  74.   
  75.             // Did the handler return a view to render?   
  76.             if (mv != null && !mv.wasCleared()) {   
  77.                 render(mv, processedRequest, response);   
  78.                 if (errorView) {   
  79.                     WebUtils.clearErrorRequestAttributes(request);   
  80.                 }   
  81.             }   
  82.             else {   
  83.                 if (logger.isDebugEnabled()) {   
  84.                     logger.debug("Null ModelAndView returned to DispatcherServlet with name '" +   
  85.                             getServletName() + "': assuming HandlerAdapter completed request handling");   
  86.                 }   
  87.             }   
  88.   
  89.             // Trigger after-completion for successful outcome.   
  90.             triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);   
  91.         }   
  92. // 當沒有配置ExceptionResolver時，異常將到達這裏，最終拋出   
  93.         catch (Exception ex) {   
  94.             // Trigger after-completion for thrown exception.   
  95.             triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);   
  96.             throw ex;   
  97.         }   
  98.         catch (Error err) {   
  99.             ServletException ex = new NestedServletException("Handler processing failed", err);   
  100.             // Trigger after-completion for thrown exception.   
  101.             triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);   
  102.             throw ex;   
  103.         }   
  104.   
  105.         finally {   
  106.             // Clean up any resources used by a multipart request.   
  107.             if (processedRequest != request) {   
  108.                 cleanupMultipart(processedRequest);   
  109.             }   
  110.   
  111.             // Reset thread-bound context.   
  112.             RequestContextHolder.setRequestAttributes(previousRequestAttributes, this.threadContextInheritable);   
  113.             LocaleContextHolder.setLocaleContext(previousLocaleContext, this.threadContextInheritable);   
  114.   
  115.             // Clear request attributes.   
  116.             requestAttributes.requestCompleted();   
  117.             if (logger.isTraceEnabled()) {   
  118.                 logger.trace("Cleared thread-bound request context: " + request);   
  119.             }   
  120.         }   
  121.     }  



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

spring mvc異常設置，
  1.       
  2. 此段代碼ZZ from http://tdcq.iteye.com/blog/890957   
  3. <!-- 全局異常配置 start -->     
  4.      <bean id="exceptionResolver" class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">     
  5.          <property name="exceptionMappings">     
  6.              <props>     
  7.                  <prop key="java.lang.Exception">errors/error</prop>     
  8.                  <prop key="java.lang.Throwable">errors/err</prop>     
  9.              </props>     
  10.          </property>     
  11.          <property name="statusCodes">     
  12.              <props>     
  13.                  <prop key="errors/error">500</prop>     
  14.                  <prop key="errors/404">404</prop>     
  15.              </props>     
  16.          </property>     
  17.          <!-- 設置日誌輸出級別，不定義則默認不輸出警告等錯誤日誌信息 -->     
  18.          <property name="warnLogCategory" value="WARN"></property>     
  19.          <!-- 默認錯誤頁面，當找不到上面mappings中指定的異常對應視圖時，使用本默認配置 -->     
  20.          <property name="defaultErrorView" value="errors/error"></property>     
  21.          <!-- 默認HTTP狀態碼 -->     
  22.          <property name="defaultStatusCode" value="500"></property>     
  23.      </bean>     
  24.      <!-- 全局異常配置 end -->    
   
用spring mvc作了個項目，可是出現異常的狀況下竟然沒有日誌輸出，而後各類嘗試。。。正如上面介紹的：設置日誌輸出級別，不定義則默認不輸出警告等錯誤日誌信息！！【固然，try catch的異常沒問題】 敬請留意。
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程