碼上快樂

相關內容    簡體    繁體

spring mvc 異常統一處理方式

本文轉載自   查看原文   2012-09-24 18:32   117278    spring

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

 

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

 

Java代碼 復制代碼  收藏代碼
  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個參數表示對哪種類型的異常進行處理，如果想同時對多種異常進行處理，可以把它換成一個異常數組。

定義了這樣一個異常處理器之后就要在applicationContext中定義這樣一個bean對象，如：

Xml代碼 復制代碼  收藏代碼
  1. <bean id="exceptionResolver" class="com.tiantian.xxx.web.handler.ExceptionHandler"/>  

 

2、使用@ExceptionHandler進行處理

使用@ExceptionHandler進行處理有一個不好的地方是進行異常處理的方法必須與出錯的方法在同一個Controller里面

如：

Java代碼 復制代碼  收藏代碼
  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又擁有一個處理該異常的方法，這個時候處理異常的方法就會被調用

  

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

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

 

 

最近使用spring mvc開發一個web系統，發現在controller里發生未捕獲異常時不出日志。

分析DispatcherServlet，初始化handlerExceptionResolvers

Java代碼 復制代碼  收藏代碼
  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，分發處理請求
Java代碼 復制代碼  收藏代碼
  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異常設置，
Java代碼 復制代碼  收藏代碼
  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的異常沒問題】 
敬請留意。
http://fancyboy2050.iteye.com/blog/965663


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 C# 異常統一處理方式 Spring異常統一處理 Spring MVC異常統一處理的三種方式 Spring 捕捉校驗參數異常並統一處理 Spring 捕捉校驗參數異常並統一處理 spring boot 攔截異常 統一處理 Spring Cloud微服務統一處理異常 spring @ExceptionHandler注解方式實現異常統一處理 java異常統一處理 Java異常統一處理
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM