posts - 495,comments - 227,trackbacks - 0


          
	

          


          
	
					


          
	
	
          http://blog.csdn.net/sunitjy/article/details/6782431

           
           
           一、前言：
           
           大家好，Spring3 MVC是非常優秀的MVC框架，由其是在3.0版本發布后，現在有越來越多的團隊選擇了Spring3 MVC了。Spring3 MVC結構簡單，應了那句話簡單就是美，而且他強大不失靈活，性能也很優秀。
           
           官方的下載網址是：http://www.springsource.org/download   （本文使用是的Spring 3.0.5版本）
           
            
           
           Struts2也是比較優秀的MVC構架，優點非常多比如良好的結構。但這里想說的是缺點，Struts2由于采用了值棧、OGNL表達式、 struts2標簽庫等，會導致應用的性能下降。Struts2的多層攔截器、多實例action性能都很好。可以參考我寫的一篇關于Spring  MVC與Struts2與Servlet比較的文章 http://elf8848.iteye.com/admin/blogs/698217
           
            
           
           Spring3 MVC的優點：
           
           1、Spring3 MVC的學習難度小于Struts2，Struts2用不上的多余功能太多。呵呵，當然這不是決定因素。
           
           2、Spring3 MVC很容易就可以寫出性能優秀的程序，Struts2要處處小心才可以寫出性能優秀的程序（指MVC部分）
           
           3、Spring3 MVC的靈活是你無法想像的，Spring的擴展性有口皆碑，Spring3 MVC當然也不會落后，不會因使用了MVC框架而感到有任何的限制。
           
            
           
           Struts2的眾多優點：略...   (呵呵，是不是不公平？)
           
            
           
           眾多文章開篇時總要吹些牛，吸引一下讀者的眼球，把讀者的胃口調起來，這樣大家才有興趣接著往后看。本文也沒能例外。不過保證你看了之后不會后悔定有收獲。
           
            
           
            
           
           二、核心類與接口：
           
            
           
           先來了解一下，幾個重要的接口與類。現在不知道他們是干什么的沒關系，先混個臉熟，為以后認識他們打個基礎。
           
            
           
           DispatcherServlet   -- 前置控制器
           
           
           
            
           
           HandlerMapping接口 -- 處理請求的映射
           
           HandlerMapping接口的實現類：
           
           SimpleUrlHandlerMapping  通過配置文件，把一個URL映射到Controller
           
           DefaultAnnotationHandlerMapping  通過注解，把一個URL映射到Controller類上
           
           
           
            
           
           HandlerAdapter接口 -- 處理請求的映射
           
           AnnotationMethodHandlerAdapter類，通過注解，把一個URL映射到Controller類的方法上
           
           
           
            
           
           Controller接口 -- 控制器
           
           由于我們使用了@Controller注解，添加了@Controller注解注解的類就可以擔任控制器（Action）的職責,
           
           所以我們并沒有用到這個接口。
           
           
           
            
           
            
           
            
           
           HandlerInterceptor 接口--攔截器
           
           無圖，我們自己實現這個接口，來完成攔截的器的工作。
           
            
           
            
           
           ViewResolver接口的實現類
           
           UrlBasedViewResolver類 通過配置文件，把一個視圖名交給到一個View來處理
           
           InternalResourceViewResolver類，比上面的類，加入了JSTL的支持
           
           
           
            
           
           View接口
           
           JstlView類
           
           
           
            
           
           LocalResolver接口
           
           
           
            
           
           HandlerExceptionResolver接口 --異常處理
           
           SimpleMappingExceptionResolver實現類
           
           
           
            
           
            
           
           ModelAndView類
           
           無圖。
           
            
           
            
           
            
           
            
           
            
           
           三、核心流程圖
           
            
           
           本圖是我個人畫的，有不嚴謹的地方，大家對付看吧。總比沒的看強。
           
           
           
            
           
            
           
            
           
           
           四、DispatcherServlet說明
           
            
           
           使用Spring MVC,配置DispatcherServlet是第一步。
           
           DispatcherServlet是一個Servlet,所以可以配置多個DispatcherServlet。
           
           DispatcherServlet是前置控制器，配置在web.xml文件中的。攔截匹配的請求，Servlet攔截匹配規則要自已定義，把攔截下來的請求，依據某某規則分發到目標Controller(我們寫的Action)來處理。
           
            
           
           “某某規則”：是根據你使用了哪個HandlerMapping接口的實現類的不同而不同。
           
            
           
           先來看第一個例子：
           
           
           
           Xml代碼  
           
           
          1.  <web-app>  
          2.      <servlet>  
          3.          <servlet-name>example</servlet-name>  
          4.          <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
          5.          <load-on-startup>1</load-on-startup>  
          6.      </servlet>  
          7.      <servlet-mapping>  
          8.          <servlet-name>example</servlet-name>  
          9.          <url-pattern>*.form</url-pattern>  
          10.      </servlet-mapping>  
          11.  </web-app>  
           
           
            <load-on-startup>1</load-on-startup>是啟動順序，讓這個Servlet隨Servletp容器一起啟動。
           
            <url-pattern>*.form</url-pattern> 會攔截*.form結尾的請求。
           
            
           
            <servlet-name>example</servlet-name>這個Servlet的名字是example，可以 有多個DispatcherServlet，是通過名字來區分的。每一個DispatcherServlet有自己的 WebApplicationContext上下文對象。同時保存的ServletContext中和Request對象中，關于key，以后說明。
           
            
           
           在DispatcherServlet的初始化過程中，框架會在web應用的 WEB-INF文件夾下尋找名為[servlet-name]-servlet.xml 的配置文件，生成文件中定義的bean。
           
            
           
            
           
           第二個例子：
           
           
           
           Xml代碼  
           
           
          1.  <servlet>  
          2.      <servlet-name>springMVC</servlet-name>  
          3.      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
          4.      <init-param>  
          5.          <param-name>contextConfigLocation</param-name>  
          6.          <param-value>classpath*:/springMVC.xml</param-value>  
          7.      </init-param>  
          8.      <load-on-startup>1</load-on-startup>  
          9.  </servlet>  
          10.  <servlet-mapping>  
          11.      <servlet-name>springMVC</servlet-name>  
          12.      <url-pattern>/</url-pattern>  
          13.  </servlet-mapping>  
           
           
           指明了配置文件的文件名，不使用默認配置文件名，而使用springMVC.xml配置文件。
           
           其中<param-value>**.xml</param-value> 這里可以使用多種寫法
           1、不寫,使用默認值:/WEB-INF/<servlet-name>-servlet.xml
           2、<param-value>/WEB-INF/classes/springMVC.xml</param-value>
           3、<param-value>classpath*:springMVC-mvc.xml</param-value>
           4、多個值用逗號分隔
           
            
           
           
           Servlet攔截匹配規則可以自已定義，Servlet攔截哪種URL合適？ 
           
           當映射為@RequestMapping("/user/add")時：
           1、攔截*.do，例如：/user/add.do，弊端：所有的url都要以.do結尾。不會影響訪問靜態文件。
           2、攔截/app/*，例如：/app/user/add，弊端：請求的url都要包含/app，@RequestMapping("/user/add")中不須要包含/app。
           3、攔截/，例如：/user/add，弊端：對jpg,js,css靜態文件的訪問也被攔截不能正常顯示。后面有解決辦法。
           4、攔截/*，可以走到Action中，但轉發到jsp時再次被攔截，不能訪問到jsp。
           
            
           
            
           
           五、雙親上下文的說明
           
            
           
           如果你使用了listener監聽器來加載配置，一般在Struts+Spring+Hibernate的項目中都是使用listener監聽器的。如下
           
           
           
           Java代碼  
           
           
          1.  <listener>    
          2.    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>   
          3.  </listener>    
           
           
           Spring會創建一個全局的WebApplicationContext上下文，稱為根上下文 ，保存在 ServletContext 中，key是WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE屬性的值。可 以使用工具類取出上下 文：WebApplicationContextUtils.getWebApplicationContext(ServletContext);
           
            
           
           DispatcherServlet是一個Servlet,可以同時配置多個，每個 DispatcherServlet有一個自己的 WebApplicationContext上下文，這個上下文繼承了 根上下文 中所有東西。 保存在 ServletContext中，key是"org.springframework.web.servlet.FrameworkServlet.CONTEXT"+Servlet名稱。當一個Request對象產生時，會把這個WebApplicationContext上下文保存在Request對象中，key是DispatcherServlet.class.getName()  + ".CONTEXT"。可以使用工具類取出上下文：RequestContextUtils.getWebApplicationContext(request);
           
            
           
           Spring中的 ApplicationContext實例可以被限制在不同的作用域（scope）中。
           在web MVC框架中，每個 DispatcherServlet有它自己的WebApplicationContext ，這個context繼承了根 WebApplicationContext 的所有bean定義。
           這些繼承的bean也可以在每個serlvet自己的所屬的域中被覆蓋（override），覆蓋后的bean 可以被設置上只有這個servlet實例自己使用的屬性。
           
            
           
           總結：不使用listener監聽器來加載spring的配置，改用DispatcherServlet來加載spring的配置，不要雙親上下文，只使用一個DispatcherServlet，事情就簡單了，什么麻煩事兒也沒有了。
           
            
           
            
           
           六、springMVC-mvc.xml 配置文件片段講解 （未使用默認配置文件名）
           
            
           
           
           
           Xml代碼  
           
           
          1.     <!-- 自動掃描的包名 -->  
          2.     <context:component-scan base-package="com.app,com.core,JUnit4" ></context:component-scan>  
          3.        
          4.     <!-- 默認的注解映射的支持 -->  
          5.     <mvc:annotation-driven />  
          6.        
          7.     <!-- 視圖解釋類 -->  
          8.     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
          9.      <property name="prefix" value="/WEB-INF/jsp/"/>  
          10.      <property name="suffix" value=".jsp"/><!--可為空,方便實現自已的依據擴展名來選擇視圖解釋類的邏輯  -->  
          11.      <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />  
          12.     </bean>  
          13.        
          14.  <!-- 攔截器 -->  
          15.     <mvc:interceptors>  
          16.      <bean class="com.core.mvc.MyInteceptor" />  
          17.  </mvc:interceptors>       
          18.     
          19.      <!-- 對靜態資源文件的訪問  方案一 （二選一） -->  
          20.      <mvc:default-servlet-handler/>  
          21.         
          22.      <!-- 對靜態資源文件的訪問  方案二 （二選一）-->  
          23.  <mvc:resources mapping="/images/**" location="/images/" cache-period="31556926"/>  
          24.  <mvc:resources mapping="/js/**" location="/js/" cache-period="31556926"/>  
          25.  <mvc:resources mapping="/css/**" location="/css/" cache-period="31556926"/>  
           
           
            
           
           <context:component-scan/> 掃描指定的包中的類上的注解，常用的注解有：
           
           @Controller 聲明Action組件
           @Service    聲明Service組件    @Service("myMovieLister") 
           @Repository 聲明Dao組件
           @Component   泛指組件, 當不好歸類時. 
           @RequestMapping("/menu")  請求映射
           @Resource  用于注入，( j2ee提供的 ) 默認按名稱裝配，@Resource(name="beanName") 
           @Autowired 用于注入，(srping提供的) 默認按類型裝配 
           @Transactional( rollbackFor={Exception.class}) 事務管理
           @ResponseBody
           @Scope("prototype")   設定bean的作用域
           
            
           
           <mvc:annotation-driven />  是一種簡寫形式，完全可以手動配置替代這種簡寫形式，簡寫形式可以讓初學都快速應用默認配置方案。<mvc:annotation-driven  />  會自動注冊DefaultAnnotationHandlerMapping與AnnotationMethodHandlerAdapter  兩個bean,是spring MVC為@Controllers分發請求所必須的。
           并提供了：數據綁定支持，@NumberFormatannotation支持，@DateTimeFormat支持，@Valid支持，讀寫XML的支持（JAXB），讀寫JSON的支持（Jackson）。
           后面，我們處理響應ajax請求時，就使用到了對json的支持。
           后面，對action寫JUnit單元測試時，要從spring  IOC容器中取DefaultAnnotationHandlerMapping與AnnotationMethodHandlerAdapter  兩個bean，來完成測試，取的時候要知道是<mvc:annotation-driven />這一句注冊的這兩個bean。
           
            
           
           <mvc:interceptors/>  是一種簡寫形式。通過看前面的大圖，知道，我們可以配置多個HandlerMapping。<mvc:interceptors/>會為每一 個HandlerMapping，注入一個攔截器。其實我們也可以手動配置為每個HandlerMapping注入一個攔截器。
           
            
           
           <mvc:default-servlet-handler/> 使用默認的Servlet來響應靜態文件。
           
            
           
           <mvc:resources mapping="/images/**" location="/images/"  cache-period="31556926"/> 匹配URL  /images/**   的URL被當做靜態資源，由Spring讀出到內存中再響應http。
           
            
           
            
           七、如何訪問到靜態的文件，如jpg,js,css？
           
           
           
           
           
           如何你的DispatcherServlet攔截 *.do這樣的URL，就不存在訪問不到靜態資源的問題。如果你的DispatcherServlet攔截“/”，攔截了所有的請求，同時對*.js,*.jpg的訪問也就被攔截了。
           
            
           
           目的：可以正常訪問靜態文件，不要找不到靜態文件報404。
            
           方案一：激活Tomcat的defaultServlet來處理靜態文件
           
           
           
           
           Xml代碼  
           
           
          1.  <servlet-mapping>   
          2.      <servlet-name>default</servlet-name>  
          3.      <url-pattern>*.jpg</url-pattern>     
          4.  </servlet-mapping>    
          5.  <servlet-mapping>       
          6.      <servlet-name>default</servlet-name>    
          7.      <url-pattern>*.js</url-pattern>    
          8.  </servlet-mapping>    
          9.  <servlet-mapping>        
          10.      <servlet-name>default</servlet-name>       
          11.      <url-pattern>*.css</url-pattern>      
          12.  </servlet-mapping>    
          13.  要配置多個，每種文件配置一個    
           
           
           要寫在DispatcherServlet的前面， 讓 defaultServlet先攔截，這個就不會進入Spring了，我想性能是最好的吧。
           
           
           
           
           Tomcat, Jetty, JBoss, and GlassFish  默認 Servlet的名字 -- "default"
           Google App Engine 默認 Servlet的名字 -- "_ah_default"
           Resin 默認 Servlet的名字 -- "resin-file"
           WebLogic 默認 Servlet的名字  -- "FileServlet"
           WebSphere  默認 Servlet的名字 -- "SimpleFileServlet" 
           
            
           
            
           
           
           方案二： 在spring3.0.4以后版本提供了mvc:resources 
           mvc:resources 的使用方法：
           
           
           
           
           Xml代碼  
           
           
          1.  <!-- 對靜態資源文件的訪問 -->    
          2.  <mvc:resources mapping="/images/**" location="/images/" />  
           
           
             
           /images/**映射到ResourceHttpRequestHandler進行處 理，location指定靜態資源的位置.可以是web  application根目錄下、jar包里面，這樣可以把靜態資源壓縮到jar包中。cache-period 可以使得靜態資源進行web  cache 
            
           如果出現下面的錯誤，可能是沒有配置<mvc:annotation-driven />的原因。 
           報錯WARNING: No mapping found for HTTP request with URI [/mvc/user/findUser/lisi/770] in DispatcherServlet with name 'springMVC'
           
           
            
           
           使用<mvc:resources/>元素,把mapping的URI注冊到SimpleUrlHandlerMapping的urlMap中,
           key為mapping的URI pattern值,而value為ResourceHttpRequestHandler,
           這樣就巧妙的把對靜態資源的訪問由HandlerMapping轉到ResourceHttpRequestHandler處理并返回,所以就支持classpath目錄,jar包內靜態資源的訪問.
           另外需要注意的一點是,不要對SimpleUrlHandlerMapping設置defaultHandler.因為對static uri的defaultHandler就是ResourceHttpRequestHandler,
           否則無法處理static resources request.
           
            
           
            
           
           方案三 ，使用<mvc:default-servlet-handler/>
           
            
           
           
           
           Xml代碼  
           
           
          1.  <mvc:default-servlet-handler/>  
           
           
            
           
           會把"/**"  url,注冊到SimpleUrlHandlerMapping的urlMap中,把對靜態資源的訪問由HandlerMapping轉到 org.springframework.web.servlet.resource.DefaultServletHttpRequestHandler 處理并返回.
           DefaultServletHttpRequestHandler使用就是各個Servlet容器自己的默認Servlet.
           
            
           
            
           
           補充說明：多個HandlerMapping的執行順序問題：
           
           DefaultAnnotationHandlerMapping的order屬性值是：0
           
           <mvc:resources/ >自動注冊的 SimpleUrlHandlerMapping的order屬性值是： 2147483646
           
            
           
           <mvc:default-servlet-handler/>自動注冊 的SimpleUrlHandlerMapping 的order屬性值是： 2147483647
           
            
           
           spring會先執行order值比較小的。當訪問一個a.jpg圖片文件時，先通過 DefaultAnnotationHandlerMapping 來找處理器，一定是找不到的，我們沒有叫a.jpg的Action。再 按order值升序找，由于最后一個 SimpleUrlHandlerMapping 是匹配 "/**"的，所以一定會匹配上，再響應圖片。
           
            
           
           訪問一個圖片，還要走層層匹配。真不知性能如何？改天做一下壓力測試，與Apache比一比。
           
            
           
           最后再說明一下，如何你的DispatcherServlet攔截 *.do這樣的URL，就不存上述問題了。
           
            
           
            
           
           
           八、請求如何映射到具體的Action中的方法？
                     方案一：基于xml配置映射，可以利用SimpleUrlHandlerMapping、BeanNameUrlHandlerMapping進行Url映射和攔截請求。
           配置方法略。
            
           方案二：基于注解映射，可以使用DefaultAnnotationHandlerMapping。
           
           
           
           Xml代碼  
           
           
          1.  <bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">  </bean>   
           
           
            
           
           但前面我們配置了<mvc:annotation-driven />，他會自動注冊這個bean,就不須要我們顯示的注冊這個bean了。  
           
            
           
            
           以上都可以注入interceptors，實現權限控制等前置工作。
           我們使用第2種，基于注解來使用spring MVC
           
            
           
            
           
            并在action類上使用：
           @Controller
           @RequestMapping("/user")
            
            
            
           九、Spring中的攔截器：
                     Spring為我們提供了：
           org.springframework.web.servlet.HandlerInterceptor接口，
           
           org.springframework.web.servlet.handler.HandlerInterceptorAdapter適配器，
           實現這個接口或繼承此類，可以非常方便的實現自己的攔截器。
            
           有以下三個方法：
            
           Action之前執行:
            public boolean preHandle(HttpServletRequest request,
              HttpServletResponse response, Object handler);
            
           生成視圖之前執行
            public void postHandle(HttpServletRequest request,
              HttpServletResponse response, Object handler,
              ModelAndView modelAndView);
            
           最后執行，可用于釋放資源
            public void afterCompletion(HttpServletRequest request,
              HttpServletResponse response, Object handler, Exception ex)
            
            
           分別實現預處理、后處理（調用了Service并返回ModelAndView，但未進行頁面渲染）、返回處理（已經渲染了頁面） 
           在preHandle中，可以進行編碼、安全控制等處理； 
           在postHandle中，有機會修改ModelAndView； 
           在afterCompletion中，可以根據ex是否為null判斷是否發生了異常，進行日志記錄。 
           參數中的Object handler是下一個攔截器。
            
           
           
           十、如何使用攔截器？
                     自定義一個攔截器，要實現HandlerInterceptor接口：
           
           
           
           
           Java代碼  
           
           
          1.  public class MyInteceptor implements HandlerInterceptor {     
          2.      略。。。   
          3.  }     
           
           
            
           
           Spring MVC并沒有總的攔截器，不能對所有的請求進行前后攔截。
           Spring MVC的攔截器，是屬于HandlerMapping級別的，可以有多個HandlerMapping ，每個HandlerMapping可以有自己的攔截器。
           當一個請求按Order值從小到大，順序執行HandlerMapping接口的實現類時，哪一個先有返回，那就可以結束了，后面的HandlerMapping就不走了，本道工序就完成了。就轉到下一道工序了。
           攔截器會在什么時候執行呢？ 一個請求交給一個HandlerMapping時，這個HandlerMapping先找有沒有處理器來處理這個請求，如何找到了，就執行攔截器，執行完攔截后，交給目標處理器。
           如果沒有找到處理器，那么這個攔截器就不會被執行。
           
            
           
           
           在spring MVC的配置文件中配置有三種方法：
           
           
           方案一，（近似）總攔截器，攔截所有url
           
           
           
           Java代碼  
           
           
          1.     <mvc:interceptors>  
          2.      <bean class="com.app.mvc.MyInteceptor" />  
          3.  </mvc:interceptors>   
           
           
           為什么叫“近似”，前面說了，Spring沒有總的攔截器。
           
           <mvc:interceptors/>會為每一 個HandlerMapping，注入一個攔截器。總有一個HandlerMapping是可以找到處理器的，最多也只找到一個處理器，所以這個攔截器總會被執行的。起到了總攔截器的作用。
           
            
           
            
           方案二， （近似） 總攔截器， 攔截匹配的URL。
           
           
           
           Xml代碼  
           
           
          1.  <mvc:interceptors >    
          2.    <mvc:interceptor>    
          3.          <mvc:mapping path="/user/*" /> <!-- /user/*  -->    
          4.          <bean class="com.mvc.MyInteceptor"></bean>    
          5.      </mvc:interceptor>    
          6.  </mvc:interceptors>    
           
           
           就是比 方案一多了一個URL匹配。
           
            
           
            
           
            
           
           方案三,HandlerMappint上的攔截器
           
           
           
           Xml代碼  
           
           
          1.  <bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">       
          2.   <property name="interceptors">       
          3.       <list>       
          4.           <bean class="com.mvc.MyInteceptor"></bean>      
          5.       </list>       
          6.   </property>       
          7.  </bean>   
           
           
             如果使用 了<mvc:annotation-driven />， 它會自動注冊DefaultAnnotationHandlerMapping  與AnnotationMethodHandlerAdapter  這兩個bean,所以就沒有機會再給它注入interceptors屬性，就無法指定攔截器。
           
           當然我們可以通過人工配置上面的兩個Bean，不使用 <mvc:annotation-driven />，就可以 給interceptors屬性 注入攔截器了。
           
            
           
           其實我也不建議使用<mvc:annotation-driven />，而建議手動寫配置文件，來替代 <mvc:annotation-driven />，這就控制力就強了。
           
           
            
           
            
           
            
           
            
           
           十一、如何實現全局的異常處理？
           
           在spring MVC的配置文件中：
           
           
           
           Xml代碼  
           
           
          1.  <!-- 總錯誤處理-->  
          2.  <bean id="exceptionResolver" class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">  
          3.      <property name="defaultErrorView">    
          4.          <value>/error/error</value>  
          5.      </property>  
          6.      <property name="defaultStatusCode">    
          7.          <value>500</value>  
          8.      </property>     
          9.  <property name="warnLogCategory">    
          10.          <value>org.springframework.web.servlet.handler.SimpleMappingExceptionResolver</value>  
          11.      </property>     
          12.  </bean>   
           
           
            
           
           這里主要的類是SimpleMappingExceptionResolver類，和他的父類AbstractHandlerExceptionResolver類。
           
           具體可以配置哪些屬性，我是通過查看源碼知道的。
           
           你也可以實現HandlerExceptionResolver接口，寫一個自己的異常處理程序。spring的擴展性是很好的。
           
            
           
            
           
           通過SimpleMappingExceptionResolver我們可以將不同的異常映射到不同的jsp頁面（通過exceptionMappings屬性的配置）。
           
            
           
           同時我們也可以為所有的異常指定一個默認的異常提示頁面（通過defaultErrorView屬性的配置），如果所拋出的異常在exceptionMappings中沒有對應的映射，則Spring將用此默認配置顯示異常信息。
           
           注意這里配置的異常顯示界面均僅包括主文件名，至于文件路徑和后綴已經在viewResolver中指定。如/error/error表示/error/error.jsp
           
            
           
            
           
           顯示錯誤的jsp頁面：
           
           
           
           Html代碼  
           
           
          1.  <%@ page language="java" contentType="text/html; charset=GBK"  
          2.      pageEncoding="GBK"%>  
          3.  <%@ page import="java.lang.Exception"%>  
          4.  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
          5.  <html>  
          6.  <head>  
          7.  <meta http-equiv="Content-Type" content="text/html; charset=GBK">  
          8.  <title>錯誤頁面</title>  
          9.  </head>  
          10.  <body>  
          11.  <h1>出錯了</h1>  
          12.  <%  
          13.  Exception e = (Exception)request.getAttribute("exception");  
          14.  out.print(e.getMessage());   
          15.  %>  
          16.  </body>  
          17.  </html>  
           
           
           其中一句：request.getAttribute("exception")，key是exception，也是在SimpleMappingExceptionResolver類默認指定的，是可能通過配置文件修改這個值的，大家可以去看源碼。
           
            
           
            參考文章：
           
           http://www.aygfsteel.com/wuxufeng8080/articles/191150.html
           
           http://fangjunai.blog.163.com/blog/static/1124970520108102013839/
           
            
           
            
           
            
           
           十二、如何把全局異常記錄到日志中？
           
           在前的配置中，其中有一個屬性warnLogCategory，值是 “SimpleMappingExceptionResolver類的全限定名”。我是在SimpleMappingExceptionResolver 類父類AbstractHandlerExceptionResolver類中找到這個屬性的。查看源碼后得知：如果warnLogCategory不為 空，spring就會使用apache的org.apache.commons.logging.Log日志工具，記錄這個異常，級別是warn。
           
           值：“org.springframework.web.servlet.handler.SimpleMappingExceptionResolver”，是“SimpleMappingExceptionResolver類的全限定名”。這個值不是隨便寫的。  因 為我在log4j的配置文件中還要加入 log4j.logger.org.springframework.web.servlet.handler.SimpleMappingExceptionResolver=WARN， 保證這個級別是warn的日志一定會被記錄，即使log4j的根日志級別是ERROR。
           
            
           
            
           
            
           
            
           
            十三、如何給spring3 MVC中的Action做JUnit單元測試？
           
            使用了spring3 MVC后，給action做單元測試也很方便，我以前從來不給action寫單元測試的，再在不同了，方便了，所以一定要寫。
           
            
           
            JUnitActionBase類是所有JUnit的測試類的父類
           
            
           
           
           
           Java代碼  
           
           
          1.  package test;  
          2.  import javax.servlet.http.HttpServletRequest;  
          3.  import javax.servlet.http.HttpServletResponse;  
          4.  import org.junit.BeforeClass;  
          5.  import org.springframework.mock.web.MockServletContext;  
          6.  import org.springframework.web.context.WebApplicationContext;  
          7.  import org.springframework.web.context.support.XmlWebApplicationContext;  
          8.  import org.springframework.web.servlet.HandlerAdapter;  
          9.  import org.springframework.web.servlet.HandlerExecutionChain;  
          10.  import org.springframework.web.servlet.HandlerMapping;  
          11.  import org.springframework.web.servlet.ModelAndView;  
          12.  import org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter;  
          13.  import org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping;  
          14.  /**   
          15.  * 說明： JUnit測試action時使用的基類 
          16.  *   
          17.  * @author  趙磊 
          18.  * @version 創建時間：2011-2-2 下午10:27:03   
          19.  */   
          20.  public class JUnitActionBase {  
          21.      private static HandlerMapping handlerMapping;  
          22.      private static HandlerAdapter handlerAdapter;  
          23.      /**  
          24.       * 讀取spring3 MVC配置文件 
          25.       */  
          26.      @BeforeClass  
          27.   public static void setUp() {  
          28.          if (handlerMapping == null) {  
          29.              String[] configs = { "file:src/springConfig/springMVC.xml" };  
          30.              XmlWebApplicationContext context = new XmlWebApplicationContext();  
          31.              context.setConfigLocations(configs);  
          32.              MockServletContext msc = new MockServletContext();  
          33.              context.setServletContext(msc);         context.refresh();  
          34.              msc.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, context);  
          35.              handlerMapping = (HandlerMapping) context  
          36.                      .getBean(DefaultAnnotationHandlerMapping.class);  
          37.              handlerAdapter = (HandlerAdapter) context.getBean(context.getBeanNamesForType(AnnotationMethodHandlerAdapter.class)[0]);     
          38.          }   
          39.      }   
          40.     
          41.      /**  
          42.       * 執行request對象請求的action 
          43.       *   
          44.       * @param request 
          45.       * @param response 
          46.       * @return 
          47.       * @throws Exception 
          48.       */  
          49.      public ModelAndView excuteAction(HttpServletRequest request, HttpServletResponse response)  
          50.   throws Exception {  
          51.          HandlerExecutionChain chain = handlerMapping.getHandler(request);  
          52.          final ModelAndView model = handlerAdapter.handle(request, response,  
          53.                  chain.getHandler());   
          54.          return model;  
          55.      }   
          56.  }   
           
            
            
           
            
           
            
           
            
           
            
           
            
           
           這是個JUnit測試類，我們可以new Request對象，來參與測試，太方便了。給request指定訪問的URL，就可以請求目標Action了。
           
            
           
           
           
           Java代碼  
           
           
          1.  package test.com.app.user;  
          2.  import org.junit.Assert;  
          3.  import org.junit.Test;  
          4.  import org.springframework.mock.web.MockHttpServletRequest;  
          5.  import org.springframework.mock.web.MockHttpServletResponse;  
          6.  import org.springframework.web.servlet.ModelAndView;  
          7.     
          8.  import test.JUnitActionBase;  
          9.     
          10.  /**   
          11.  * 說明： 測試OrderAction的例子 
          12.  *   
          13.  * @author  趙磊  
          14.  * @version 創建時間：2011-2-2 下午10:26:55   
          15.  */   
          16.     
          17.  public class TestOrderAction extends JUnitActionBase {  
          18.      @Test  
          19.      public void testAdd() throws Exception {  
          20.      MockHttpServletRequest request = new MockHttpServletRequest();  
          21.          MockHttpServletResponse response = new MockHttpServletResponse();  
          22.          request.setRequestURI("/order/add");  
          23.          request.addParameter("id", "1002");  
          24.          request.addParameter("date", "2010-12-30");  
          25.          request.setMethod("POST");  
          26.          // 執行URI對應的action  
          27.          final ModelAndView mav = this.excuteAction(request, response);  
          28.          // Assert logic  
          29.          Assert.assertEquals("order/add", mav.getViewName());  
          30.          String msg=(String)request.getAttribute("msg");  
          31.          System.out.println(msg);   
          32.      }   
          33.  }   
           
           
            需要說明一下 ： 由于當前最想版本的Spring(Test) 3.0.5還不支持@ContextConfiguration的注解式context  file注入，所以還需要寫個setUp處理下，否則類似于Tiles的加載過程會有錯誤，因為沒有ServletContext。3.1的版本應該有更 好的解決方案，參見： https://jira.springsource.org/browse/SPR-5243 。
           
           參考 ：http://www.iteye.com/topic/828513
           
            
           
            
           
            
           
            
           
            十四、轉發與重定向
           
           可以通過redirect/forward:url方式轉到另一個Action進行連續的處理。
           
           可以通過redirect:url 防止表單重復提交 。
           
           寫法如下：
           
           return "forward:/order/add";
           
           return "redirect:/index.jsp";
           
            
           
            
           
            
           
            
           
            十五、處理ajax請求
           
            
           
           1、引入下面兩個jar包，我用的是1.7.2，好像1.4.2版本以上都可以，下載地址： http://wiki.fasterxml.com/JacksonDownload
           
           jackson-core-asl-1.7.2.jar 
           
           jackson-mapper-asl-1.7.2.jar
           
            
           
           2、spring的配置文件中要有這一行，才能使用到spring內置支持的json轉換。如果你手工把POJO轉成json就可以不須要使用spring內置支持的json轉換。
           
           <mvc:annotation-driven />
           
            
           
           3、使用@ResponseBody注解
           
           
           
           Java代碼  
           
           
          1.  /**  
          2.   * ajax測試  
          3.  * http://127.0.0.1/mvc/order/ajax 
          4.   */  
          5.     
          6.  @RequestMapping("/ajax")  
          7.  @ResponseBody  
          8.  public Object ajax(HttpServletRequest request){  
          9.      List<String> list=new ArrayList<String>();  
          10.      list.add("電視");  
          11.  nbsp;       list.add("洗衣機");  
          12.      list.add("冰箱");  
          13.      list.add("電腦");  
          14.      list.add("汽車");  
          15.      list.add("空調");  
          16.      list.add("自行車");  
          17.      list.add("飲水機");  
          18.      list.add("熱水器");  
          19.      return list;  
          20.  }   
           
           
            
           
           
          
	
          posted on 2012-11-22 09:23 SIMONE 閱讀(1868) 評論(0)  編輯  收藏  
          

          







          
	    
    




          





          


          

	
          
		
          
				
		
	
		
          
		
		
          只有注冊用戶登錄后才能發表評論。
          
		
          
			
		
          
			
		
          
		
		
          
		


          

		          		
		
          
		
          			
		
		
		
		
          
		
          
		
		
          
		
          
			網站導航:
		
		
          
		
          
			
		
          	
		
          
			 
		
          
		
          
			
		
          
		
          
			
				
		
          		
	
          	

          



          

				

          



    







          
        
	




主站蜘蛛池模板：
安宁市|
平原县|
武功县|
墨脱县|
昌乐县|
五峰|
仙桃市|
陇西县|
阿图什市|
涿鹿县|
招远市|
丰城市|
宝丰县|
成武县|
远安县|
于都县|
保康县|
静安区|
利辛县|
阳城县|
海兴县|
萨嘎县|
罗定市|
临沭县|
馆陶县|
通渭县|
阜南县|
台中县|
治县。|
巴楚县|
昆山市|
台江县|
长子县|
巨野县|
金昌市|
任丘市|
巴林左旗|
宁都县|
祁阳县|
独山县|
沐川县|