Spring原始碼深度解析之Spring MVC
Spring原始碼深度解析之Spring MVC
Spring框架提供了構建Web應用程式的全功能MVC模組。通過策略介面,Spring框架是高度可配置的,而且支援多種檢視技術,例如JavaServer pages(JSP)技術、Velocity、Tiles、iText和POI。Spring MVC框架並不知道使用的檢視,所以不會強迫您只使用JSP技術。Spring MVC分離了控制器、模型物件、分派器以及處理程式物件的角色,這種分離讓它們更容易進行定製。
Spring的MVC是基於Servlet功能實現的。通過實現Servlet介面的DispatcherServlet來封裝其核心功能實現,通過將請求分派給處理程式,同時帶有可配置的處理程式對映、檢視解析、本地語言、主題解析以及上載檔案的支援。預設的處理程式是非常簡單的Controller介面,只有一個方法ModelAndView handleRequest(request, response)。Spring提供了一個控制器層次結構,可以派生子類。如果應用程式需要處理使用者輸入表單,那麼可以繼承AbstractFormController。如果需要把多頁輸入處理到一個表單,那麼可以繼承AbstractWizardFormController。
Spring MVC或者其他比較成熟的MVC框架而言,解決的問題無外乎以下幾點:
(1)將Web頁面的請求傳給伺服器。
(2)根據不同的請求處理不同的邏輯單元。
(3)返回處理結果資料並跳轉到響應的頁面。
我們先通過一個簡單示例來快速回顧Spring MVC的使用。
一、 Spring MVC快速體驗
(一)配置web.xml
一個Web中可以沒有web.xml檔案,也就是說,web.xml檔案並不是Web工廠必須的。web.xml檔案用來初始化配置資訊:比如Welcome頁面、servlet、servlet-mapping、filter、listener、啟動載入級別等。但是,Spring MVC的實現原理就是通過Servlet攔截所有URL來達到控制的目的,所以web.xml的配置是必須的。
1 <?xml version="1.0" encoding="UTF-8"?> 2 <web-app id="WebApp_ID" version="2.5" xmlns="http://java.sun.com/xml/ns/j2ee" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> 5 <display-name>Springmvc</display-name> 6 7 <!--使用ContextLoaderListener配置時,需要告訴他Spring配置檔案的位置--> 8 <context-param> 9 <param-name>contextConfigLocation</param-name> 10 <param-value>classpath:applicationContext.xml</param-value> 11 </context-param> 12 13 <!--Spring MVC的前端控制器--> 14 <!--當DispatcherServlet載入後,它將從一個XML檔案中載入Spring的應用上下文,該XMl檔案的名字取決於<servlet-name>--> 15 <!--這裡DispatcherServlet將試圖從一個叫做Springmvc-servlet.xml的檔案中載入應用上下文,其預設位於WEB-INF目錄下--> 16 <servlet> 17 <servlet-name>Springmvc</servlet-name> 18 <servlet-class>org.Springframework.web.servlet.DispatcherServlet</servlet-class> 19 <load-on-startup>1</load-on-startup> 20 </servlet> 21 <servlet-mapping> 22 <servlet-name>Springmvc</servlet-name> 23 <url-pattern>*.htm</url-pattern> 24 </servlet-mapping> 25 26 <!--配置上下文載入器--> 27 <!--上下文載入器載入除DispatcherServlet載入的配置檔案之外的其它上下文配置檔案--> 28 <!--最常用的上下文載入器是一個Servlet監聽器,其名稱為ContextLoaderListener--> 29 <listener> 30 <listener-class>org.Springframework.web.context.ContextLoaderListener</listener-class> 31 </listener> 32 33 </web-app>
Spring的MVC之所以必須要配置web.xml,其實最關鍵的是要配置兩個地方。
(1)contextConfigLocation:Spring的核心就是配置檔案,可以說配置檔案是Spring中必不可少的東西,而這個引數就是使Web與Spring的配置檔案相結合的一個關鍵配置。
(2)DispatcherServlet:包含了SpringMVC的請求邏輯,Spring使用此類攔截Web請求並進行相應的邏輯處理。
(二)建立Spring配置檔案applicationContext.xml
1 <?xml version="1.0" encoding="UTF-8" ?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmls:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xmlns:tx="http://www.springframework.org/schema/tx" 5 xsi:schemaLocation="http://www.springframework.org/schema/beans 6 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd 7 http://www.springframework.org/schema/tx 8 http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> 9 10 <bean id="viewResolver" class="org.springframework.web.servlet.view.Internal Resource ViewResolver"> 11 <property name="prefix" value="/WEB-INF/jsp/"/> 12 <property name="suffix" value=".jsp"/> 13 </bean> 14 15 </beans>
InternalResourceViewResolver是一個輔助Bean,會在ModelAndView返回的檢視名前加上prefix指定的字首,再在最後加上suffix指定的字尾,例如:由於XXController返回的ModelAndView中的檢視名師testview。故該檢視解析器將在/WEB-INF/jsp/testview.jsp處查詢檢視。
(三)建立model
模型對於Spring MVC來說是必不可少,如果處理程式非常簡單,完全可以忽略。模型建立的主要目的就是承載資料,使資料傳輸更加方便。
1 public class User{ 2 private String username; 3 private Integer age; 4 5 public String getUsername(){ 6 return username; 7 } 8 public void setUsername(String username){ 9 this.username = username; 10 } 11 12 public Integer getAge() { 13 return age; 14 } 15 public void setAge(Integer age){ 16 this.age = age; 17 } 18 }
(四)建立Controller
控制器用於處理Web請求,每個控制器都對應著一個邏輯處理。
1 public class UserController extends AbstractController{ 2 @Override 3 protected ModelAndView handleRequestInternal(HttpServletRequest arg0, HttpServletResponse arg1) throws Exception{ 4 List<User> userList = new ArrayList<User>(); 5 User userA = new User(); 6 User userB = new User(); 7 userA.setUsername("張三"); 8 userA.setAge(27); 9 userB.setUsername("李四"); 10 userB.setAge(37); 11 userList.add(userA); 12 userList.add(userB); 13 14 return new ModelAndView("userlist", "users", userList); 15 } 16 }
在請求的最後返回了ModelAndView型別的例項。ModelAndView類在Spring MVC中佔有很重要的地位。控制器執行方法都必須返回一個ModelAndView,ModelAndView物件儲存了檢視以及檢視顯示的模型資料,例如其中的引數如下:
第一個引數userlist:檢視元件的邏輯名稱。這裡檢視的邏輯名稱就是userlist,檢視解析器會使用該名稱查詢實際的View物件。
第二個引數users:傳遞給檢視的,模型物件的名稱。
第三個引數userList:傳遞給檢視的,模型物件的值。
(五)建立檢視檔案userlist.jsp
1 <%@ page language="java" pageEncoding="UTF-8" %> 2 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 3 <h2>This is SpringMVC demo page</h2> 4 <c:forEach item="${users}" var="user"> 5 <c:out value="${user.username}"/><br/> 6 <c:out value="${usr.age}"/><br/> 7 </c:forEach>
檢視檔案用於展現請求處理結果,通過對JSTL的支援,可以很方便地展現在控制器中放入ModelAndView中處理結果資料。
(六)建立Servlet配置檔案Spring-servlet.xml
1 <?xml version="1.0" encoding="UTF-8" ?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:xsi="http//www.w3.org/2001/XMLSchema-instance" 4 xmlns:tx="http://www.springframework.org/schema/tx" 5 xsi:schemaLocation="http://www.springframework.org/schema/beans 6 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd 7 http://www.springframework.org/schema/tx 8 http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> 9 10 <bean id="simpleUrlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping"> 11 <property name="mapping"> 12 <props> 13 <prop key="/usrerlist.htm">userController</prop> 14 </props> 15 </property> 16 </bean> 17 18 <!--這裡的 id="userController對應的是<bean id="simpleUrlMapping">中的<prop>裡面的value"--> 19 <bean id="userController" class="test.controller.UserController"/> 20 21 </beans>
因為Spring MVC是基於Servlet的實現,所以在Web啟動的時候,伺服器會首先嚐試載入對應於Servlet的配置檔案,而為了讓專案更加模組化,通常我們講Web部分的配置都存放於此配置檔案中。
至此,已經完成了Spring MVC的搭建,啟動伺服器,輸入網址http://localhost:8080/Springmvc/userlist.htm。會看到伺服器器的返回介面。
二 、ContextLoaderListener
對於Spring MVC功能實現的分析,我們首先從web.xml開始,在web.xml檔案中我們首先配置的就是contextLoaderListener,那麼它所提供的功能有哪些又是如何實現的呢?
當使用程式設計方式的時候我們可以直接將Spring配置資訊作為引數傳入Spring容器中,如:
ApplicationContext ac = new ClassPathXmlApplicationContext(“applicationContext.xml”);
但是在Web下,我們需要更多的是與Web環境相互結合,通常的辦法是將路徑以context-param的方式註冊並使用ContextLoaderListener進行監聽讀取。
ContextLoaderListener的作用就是啟動Web容器時,自動裝配ApplicationContext的配置資訊。因為它實現了ServletContextListener這個介面,在web.xml配置這個監聽器,啟動容器時,就會預設執行它實現的方法,使用ServletContextListener介面,開發者能夠在為客戶端請求提供服務之前向ServletContext中新增任意的物件。這個物件在ServletContext啟動的時候被初始化,然後在ServletContext整個執行期間都是可見的。
每一個Web應用都有一個ServletContext與之相關聯。ServletContext物件在應用啟動時被建立,在應用關閉的時候被銷燬。ServletContext在全域性範圍內有效,類似於應用中一個全域性變數。
在ServletContextListener中的核心邏輯便是初始化WebApplicationContext例項並存放至ServletContext中。
(一)ServletContextListener的使用
正式分析程式碼前我們同樣還是先了解ServletContextListener的使用。
(1)建立自定義ServletContextListener。
首先我們建立ServletContextListener,目標是在系統啟動時新增自定義的屬性,以便於在全域性範圍內可以隨時呼叫。系統啟動的時候會呼叫ServletContextListener實現類的contextInitialized方法,所以需要在這個方法中實現我們的初始化邏輯。
1 public class MyDataContextListener implements ServletContextListener{ 2 3 private ServletContext context = null; 4 5 public MyDataContextListener(){ 6 7 } 8 9 //該方法在ServletContext啟動之後被呼叫,並準備好處理客戶端的請求 10 public void contextInitialized(ServletContextEvent event){ 11 this.context = event.getServletContext(); 12 //通過你可以實現自己的邏輯並將結果記錄在屬性中 13 context = setAttribut("myData", "this is myData"); 14 } 15 16 //這個方法在ServletContext將要關閉的時候呼叫 17 public void contextDestroyed(ServletContextEvent event){ 18 this.context = null; 19 } 20 }
(2)註冊監聽器。
在web.xml檔案中需要註冊自定義的監聽器。
1 <listener> 2 com.test.MyDataContextListener 3 </listener>
(3)測試。
一旦Web應用啟動的時候,我們就能在任意的Servlet或者JSP中通過下面的方式獲取我們初始化引數,如下:String myData = (String) getServletContext().getAttribut(“myData”);
(二)Spring中的ContextLoaderListener
分析了ServletContextListener的使用方式後再來分析Spring中的ContextLoaderListener的實現方式就容易理解得多,雖然ContextLoaderListener實現的邏輯要複雜得多,但是大致的套路還是萬變不離其宗。
ServletContext啟動後會呼叫ServletContextListener的contextInitialized方法,那麼,我們就從這個函式開始進行分析。
1 @Override 2 public void contextInitialized(ServletContextEvent event) { 3 //該方法在其父類ContextLoader中定義 4 initWebApplicationContext(event.getServletContext()); 5 }
這裡涉及了一個常用類WebApplicationContext:在Web應用中,我們會用到WebApplicationContext,WebApplicationContext繼承自ApplicationContext,在ApplicationContext的基礎上又追加了一些特定於Web的操作及屬性。非常類似於我們通過程式設計方式使用Spring時使用的ClassPathXmlApplicationContext類提供的功能。繼續跟蹤程式碼:
1 public WebApplicationContext initWebApplicationContext(ServletContext servletContext) { 2 if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) { 3 //web.xml中存在多次ContextLoader的定義 4 throw new IllegalStateException( 5 "Cannot initialize context because there is already a root application context present - " + 6 "check whether you have multiple ContextLoader* definitions in your web.xml!"); 7 } 8 9 servletContext.log("Initializing Spring root WebApplicationContext"); 10 Log logger = LogFactory.getLog(ContextLoader.class); 11 if (logger.isInfoEnabled()) { 12 logger.info("Root WebApplicationContext: initialization started"); 13 } 14 long startTime = System.currentTimeMillis(); 15 16 try { 17 // Store context in local instance variable, to guarantee that 18 // it is available on ServletContext shutdown. 19 if (this.context == null) { 20 //初始化context 21 this.context = createWebApplicationContext(servletContext); 22 } 23 if (this.context instanceof ConfigurableWebApplicationContext) { 24 ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context; 25 if (!cwac.isActive()) { 26 // The context has not yet been refreshed -> provide services such as 27 // setting the parent context, setting the application context id, etc 28 if (cwac.getParent() == null) { 29 // The context instance was injected without an explicit parent -> 30 // determine parent for root web application context, if any. 31 ApplicationContext parent = loadParentContext(servletContext); 32 cwac.setParent(parent); 33 } 34 configureAndRefreshWebApplicationContext(cwac, servletContext); 35 } 36 } 37 //記錄在servletContext中 38 servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context); 39 40 ClassLoader ccl = Thread.currentThread().getContextClassLoader(); 41 if (ccl == ContextLoader.class.getClassLoader()) { 42 currentContext = this.context; 43 } 44 else if (ccl != null) { 45 currentContextPerThread.put(ccl, this.context); 46 } 47 48 if (logger.isInfoEnabled()) { 49 long elapsedTime = System.currentTimeMillis() - startTime; 50 logger.info("Root WebApplicationContext initialized in " + elapsedTime + " ms"); 51 } 52 53 return this.context; 54 } 55 catch (RuntimeException | Error ex) { 56 logger.error("Context initialization failed", ex); 57 servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex); 58 throw ex; 59 } 60 }
initWebApplicationContext函式主要是體現了建立WebApplicationContext例項的一個功能架構,從函式中我們看到了初始化的大致步驟。
(1)WebApplicationContext存在性的驗證。
在配置中只允許申明一次ServletContextListener,多次申明會擾亂Spring的執行邏輯,所以這裡首先要做的就是對比驗證,在Spring中如果建立WebApplicationContext;例項會記錄在ServletContext中以方便全域性呼叫,而使用的key就是WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE,所以驗證的方式就是檢視ServletContext例項中是否有對應key的屬性。
(2)建立WebApplicationContext例項。
如果通過驗證,則Spring將建立WebApplicationContext例項的工作委託給了createWebApplicationContext函式。
1 protected WebApplicationContext createWebApplicationContext(ServletContext sc) { 2 Class<?> contextClass = determineContextClass(sc); 3 if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) { 4 throw new ApplicationContextException("Custom context class [" + contextClass.getName() + 5 "] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]"); 6 } 7 return (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass); 8 }
createWebApplicationContext函式又呼叫了determineContextClass方法,繼續:
1 protected Class<?> determineContextClass(ServletContext servletContext) { 2 String contextClassName = servletContext.getInitParameter(CONTEXT_CLASS_PARAM); 3 if (contextClassName != null) { 4 try { 5 return ClassUtils.forName(contextClassName, ClassUtils.getDefaultClassLoader()); 6 } 7 catch (ClassNotFoundException ex) { 8 throw new ApplicationContextException( 9 "Failed to load custom context class [" + contextClassName + "]", ex); 10 } 11 } 12 else { 13 contextClassName = defaultStrategies.getProperty(WebApplicationContext.class.getName()); 14 try { 15 return ClassUtils.forName(contextClassName, ContextLoader.class.getClassLoader()); 16 } 17 catch (ClassNotFoundException ex) { 18 throw new ApplicationContextException( 19 "Failed to load default context class [" + contextClassName + "]", ex); 20 } 21 } 22 }
其中,在ContextLoader類中有這樣的靜態程式碼塊:
1 static { 2 // Load default strategy implementations from properties file. 3 // This is currently strictly internal and not meant to be customized 4 // by application developers. 5 try { 6 ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, ContextLoader.class); 7 defaultStrategies = PropertiesLoaderUtils.loadProperties(resource); 8 } 9 catch (IOException ex) { 10 throw new IllegalStateException("Could not load 'ContextLoader.properties': " + ex.getMessage()); 11 } 12 }
根據以上靜態的程式碼塊內容,我們推斷在當前類ContextLoader同樣目錄下必定會存在屬性檔案ContextLoader.properties(在..\spring-web\src\main\resources\org\springframework\web\context目錄下),檢視後果然存在,內容如下:
org.springframework.web.context.WebApplicationContext=org.springframework.web.context.support.XmlWebApplicationContext
綜合以上程式碼分析,在初始化過程中,程式首先會讀取ContextLoader類的同目錄下的屬性檔案ContextLoader.properties。並根據其中的配置提取將要實現WebApplicationContext介面的實現類,並根據這個實現類通過反射的方式進行例項的建立。
(3)將例項記錄在servletContext中。
(4)對映當前的類載入器與建立的例項到全域性變數currentContextPerThread中。
三、 DispatcherServlet
在Spring中,ContextLoaderListener只是輔助功能,用於建立WebApplicationContext型別例項,而真正的邏輯其實是在DispatcherServlet(package org.springframework.web.servlet)中進行的,DispatcherServlet是實現servlet的介面的實現類。
servlet是一個Java編寫的程式,此程式是基於HTTP協議的,在伺服器端執行的(如Tomcat),是按照servlet規範編寫的一個Java類。主要是處理客戶端的請求並將其結果傳送到客戶端。servlet的生命週期是由servlet的容器來控制的,它可以分為3個階段:初始化、執行和銷燬。
(1)初始化階段
servlet容器載入servlet類,把servlet類的.class檔案中的資料讀到記憶體中。
servlet容器建立一個ServletConfig物件,ServletConfig物件包含了servlet的初始化配置資訊。
servlet容器建立一個servlet物件。
servlet容器呼叫servlet物件的init方法機芯初始化化。
(2)執行階段
當servelt容器接收到一個請求是,servelt容器會針對這個請求建立serveltRequest和ServletResponse物件,然後呼叫service方法。並把這兩個引數傳遞給service方法。service方法通過servletRequest物件獲得請求的資訊。並處理請求。再通過servletResponse物件生成這個請求的響應結果。然後銷燬servletRequest和ServletResponse物件。我們不管這個請求是post提交的還是get提交的,最終這個請求都會由service方法來處理。
(3)銷燬階段。
當Web應用被終止時,servlet容器會先呼叫servlet物件的destroy方法,然後在銷燬servlet物件,同時也會銷燬與servlet物件相關聯的servletConfig物件。我們可以在destroy方法的實現中,釋放servlet所佔用的資源,如關閉資料庫連線,關閉檔案輸入輸出流等。
servlet的框架是由兩個Java包組成:javax.servlet和javax.servlet.http。在javax.servlet包中定義了所有的servlet類都必須實現或拓展的通用介面和類。在javax.servlet.http包中定義了採用HTTP通訊協議的HttpServlet類。
servlet類被設計成請求驅動,servlet的請求可能包含多個數據項,當Web容器接收到某個servlet請求是,servelt把請求封裝成一個HTTPServletRequest物件,然後把物件傳給servlet的物件的服務方法。
HTTP的請求方式包括delete、get、options、post、put和trace。在HttpServlet類中分別提供了相應的服務方法,它們是doDelete()、doGet()、doOptions()、doPost()、doPut()和doTrace()。
(一)servlet的使用
我們同樣還是以最簡單的servlet來快速體驗其用法。
(1)建立servlet
1 public class Myservlet extends HttpServlet{ 2 public void init(){ 3 System.out.println("this is a method"); 4 } 5 6 public void doGet(HttpServletRequest request, HttpServletResponse response){ 7 handleLogic(request, response); 8 } 9 10 public void doPost(HttpServletRequest request, HttpServletResponse response){ 11 handleLogic(request, response); 12 } 13 14 public void handleLogic(HttpServletRequest request, HttpServletResponse response){ 15 System.out.println("handle myLogic"); 16 ServletContext sc = getServletContext(); 17 18 RequestDispatcher rd = null; 19 20 rd = sc.getRequestDispatcher("/index.jsp"); 21 try { 22 rd.forward(request, response); 23 } catch (ServletException | IOException e) { 24 e.printStackTrace(); 25 } 26 } 27 }
麻雀雖小,五臟俱全。例項中包含了對init方法和get/post方法的處理,init方法包裝在servlet載入的時候能做一些邏輯操作,而HttpServlet類則會幫助我們根據方法型別的不同而將邏輯引入不同的函式。在子類中我們只需要重寫對應的函式邏輯便可,如以上程式碼重寫了doGet和doPost方法並將邏輯處理部分引導至handleLogic函式中,最後,又將頁面跳轉至index.jsp。
(2)新增配置
為了是servlet能夠正常使用,需要在web.xml檔案中新增以下配置:
1 <servlet> 2 <servlet-name>myservlet</servlet-name> 3 <servlet-name>test.servlet.MyServlet</servlet-name> 4 <load-on-startup>1</load-on-startup> 5 </servlet> 6 7 <servlet-mapping> 8 <servlet-name>myservlet</servlet-name> 9 <url-pattern>*.htm</url-pattern> 10 </servlet-mapping>
配置後便可以根據對應的配置訪問響應的路徑了。
(二)DispatcherServlet的初始化
通過上面的例項我們瞭解到,在servlet初始化階段會呼叫器init方法,所以我們首先要檢視在DispatcherServlet中是否重寫了init方法。我們再其父類HttpServletBean(package org.springframework.web.servlet)中找到了該方法。
1 @Override 2 public final void init() throws ServletException { 3 4 // Set bean properties from init parameters. 5 //解析init-param並封裝在pvs中 6 PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties); 7 if (!pvs.isEmpty()) { 8 try { 9 //將當前的這個Servlet類轉化成一個BeanWrapper,從而能夠以Spring的方式來對init-param的值進行注 10 BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this); 11 ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext()); 12 //註冊自定義屬性編輯器,一旦遇到Resource型別的屬性將會使用ResourceEditor進行解析 13 bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment())); 14 //空實現,留給子類覆蓋 15 initBeanWrapper(bw); 16 //屬性注入 17 bw.setPropertyValues(pvs, true); 18 } 19 catch (BeansException ex) { 20 if (logger.isErrorEnabled()) { 21 logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex); 22 } 23 throw ex; 24 } 25 } 26 27 // Let subclasses do whatever initialization they like. 28 //留給子類擴充套件 29 initServletBean(); 30 }
DispatchServlet的初始化過程主要是通過將當前的servlet型別例項轉換成BeanWrapper型別例項,以便使用Spring中提供的注入功能進行對應屬性的注入。這些屬性如contextAttribut、contextClass、nameSpace、contextConfigLocation等,都可以在web.xml檔案中以初始化引數的方式配置在servelt的宣告中。DispatcherServlet繼承自FrameworkServlet,FrameServlet類上包含對應的同名屬性,Spring會保證這些引數被注入到對應的值中。屬性注入主要包含以下幾個步驟:
(1)封裝及驗證初始化引數
ServletConfigPropertyValues除了封裝屬性外還有對屬性驗證的功能。
1 public ServletConfigPropertyValues(ServletConfig config, Set<String> requiredProperties) 2 throws ServletException { 3 4 Set<String> missingProps = (!CollectionUtils.isEmpty(requiredProperties) ? 5 new HashSet<>(requiredProperties) : null); 6 7 Enumeration<String> paramNames = config.getInitParameterNames(); 8 while (paramNames.hasMoreElements()) { 9 String property = paramNames.nextElement(); 10 Object value = config.getInitParameter(property); 11 addPropertyValue(new PropertyValue(property, value)); 12 if (missingProps != null) { 13 missingProps.remove(property); 14 } 15 } 16 17 // Fail if we are still missing properties. 18 if (!CollectionUtils.isEmpty(missingProps)) { 19 throw new ServletException( 20 "Initialization from ServletConfig for servlet '" + config.getServletName() + 21 "' failed; the following required properties were missing: " + 22 StringUtils.collectionToDelimitedString(missingProps, ", ")); 23 } 24 }
從程式碼中得知,封裝屬性主要是對初始化的引數進行封裝,也就是servlet中配置的<init-param>中配置的封裝。當然,使用者可以同對requiredProperties引數的初始化來強制驗證某些屬性的必要性。這樣,在屬性封裝的過程中,一旦檢測到requiredProperties中的屬性沒有指定初始值,就會丟擲異常。
(2)將當前servlet例項轉化成BeanWrapper例項
PropertyAccessorFactory.forBeanPropertyAccess是Spring中提供的工具方法,主要用於將指定例項轉化成Spring中可以處理的BeanWrapper型別的例項。
(3)註冊相對於Resource的屬性編輯器
屬性編輯器,我們再上文中已經介紹並分析過其原理。這裡使用屬性編輯器的目的是在對當前例項(DispatcherServlet)屬性注入過程中一旦遇到Resource型別的屬性就會使用ResourceEditor去解析。
(4)屬性注入
BeanWrapper為Spring中的方法,支援Spring的自動注入。其實我們最常用的屬性注入無非是contextAttribut、contextClass、nameSpace、contextConfigLocation等屬性。
(5)servletBean的初始化
在ContextLoaderListener載入的時候已經建立了WebApplicationContext例項,而在這個函式中最重要的就是對這個例項進行進一步的補充初始化。
繼續檢視initServletBean()。父類FrameworkServlet覆蓋了HttpServletBean中的initServletBean函式,如下:
1 protected final void initServletBean() throws ServletException { 2 getServletContext().log("Initializing Spring " + getClass().getSimpleName() + " '" + getServletName() + "'"); 3 if (logger.isInfoEnabled()) { 4 logger.info("Initializing Servlet '" + getServletName() + "'"); 5 } 6 long startTime = System.currentTimeMillis(); 7 8 try { 9 this.webApplicationContext = initWebApplicationContext(); 10 //設為子類覆蓋 11 initFrameworkServlet(); 12 } 13 catch (ServletException | RuntimeException ex) { 14 logger.error("Context initialization failed", ex); 15 throw ex; 16 } 17 18 if (logger.isDebugEnabled()) { 19 String value = this.enableLoggingRequestDetails ? 20 "shown which may lead to unsafe logging of potentially sensitive data" : 21 "masked to prevent unsafe logging of potentially sensitive data"; 22 logger.debug("enableLoggingRequestDetails='" + this.enableLoggingRequestDetails + 23 "': request parameters and headers will be " + value); 24 } 25 26 if (logger.isInfoEnabled()) { 27 logger.info("Completed initialization in " + (System.currentTimeMillis() - startTime) + " ms"); 28 } 29 }
上面的函式設計了計時器來統計初始化的執行時間,而且提供了一個擴充套件方法initFrameworkServlet()用於子類的覆蓋操作。而作為關鍵的初始化邏輯實現委託給了initWebApplicationContext()。
(三)WebApplicationContext的初始化
initWebApplicationContext函式的主要工作就是建立或者重新整理WebApplicationContext例項並對servlet功能所使用額變數進行初始化。
1 protected WebApplicationContext initWebApplicationContext() { 2 WebApplicationContext rootContext = 3 WebApplicationContextUtils.getWebApplicationContext(getServletContext()); 4 WebApplicationContext wac = null; 5 6 if (this.webApplicationContext != null) { 7 // A context instance was injected at construction time -> use it 8 //context例項在建構函式中被注入 9 wac = this.webApplicationContext; 10 if (wac instanceof ConfigurableWebApplicationContext) { 11 ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac; 12 if (!cwac.isActive()) { 13 // The context has not yet been refreshed -> provide services such as 14 // setting the parent context, setting the application context id, etc 15 if (cwac.getParent() == null) { 16 // The context instance was injected without an explicit parent -> set 17 // the root application context (if any; may be null) as the parent 18 cwac.setParent(rootContext); 19 } 20 //重新整理上下文環境 21 configureAndRefreshWebApplicationContext(cwac); 22 } 23 } 24 } 25 if (wac == null) { 26 // No context instance was injected at construction time -> see if one 27 // has been registered in the servlet context. If one exists, it is assumed 28 // that the parent context (if any) has already been set and that the 29 // user has performed any initialization such as setting the context id 30 //根據contextAttribute屬性載入WebApplicationContext 31 wac = findWebApplicationContext(); 32 } 33 if (wac == null) { 34 // No context instance is defined for this servlet -> create a local one 35 wac = createWebApplicationContext(rootContext); 36 } 37 38 if (!this.refreshEventReceived) { 39 // Either the context is not a ConfigurableApplicationContext with refresh 40 // support or the context injected at construction time had already been 41 // refreshed -> trigger initial onRefresh manually here. 42 synchronized (this.onRefreshMonitor) { 43 onRefresh(wac); 44 } 45 } 46 47 if (this.publishContext) { 48 // Publish the context as a servlet context attribute. 49 String attrName = getServletContextAttributeName(); 50 getServletContext().setAttribute(attrName, wac); 51 } 52 53 return wac; 54 }
對應本函式中的初始化主要包含幾個部分。
(1)尋找或建立對應的WebApplicationContext例項
WebApplicationContext的尋找和建立包括以下幾個步驟。
(1.1)通過建構函式的注入進行初始化。
當進入initWebApplicationContext函式後通過判斷this.webApplicationContext != null後,便可以確定this.webApplicationContext是否是通過建構函式來初始化的。可是有讀者可能會有疑問,在initServletBean函式中明明是把建立好的例項記錄在了this.webApplicationContext中:
this.webApplicationContext = initWebApplicationContext();
何以判斷這個引數就是通過建構函式初始化,而不是通過上一次的函式返回值初始化的呢?如果存在這個問題,那麼就是讀者忽略了一個問題:在Web中包含SpringWeb的核心邏輯DispatcherServlet只可以被宣告一次,在Spring中已經存在驗證,所以這就確保瞭如果this.webApplicationContext != null,則可以直接判定this.webApplicationContext已經通過建構函式初始化了。
(1.2)通過contextAttribute進行初始化。
通過在web.xml檔案中配置的servlet引數contextAttribut來 查詢ServletContext中對應的屬性,預設為WebApplicationContext.class.getName()+”.ROOT”,也就是在ContextLoaderListener載入時會建立WebApplicationContext例項,並將例項以WebApplicationContext.class.getName()+”.ROOT”為key放入ServletContext中,當然讀者可以重寫初始化邏輯使用自己建立的WebApplicationContext,並在servlet的配置中通過初始化引數contextAttribut指定可以key。
1 protected WebApplicationContext findWebApplicationContext() { 2 String attrName = getContextAttribute(); 3 if (attrName == null) { 4 return null; 5 } 6 WebApplicationContext wac = 7 WebApplicationContextUtils.getWebApplicationContext(getServletContext(), attrName); 8 if (wac == null) { 9 throw new IllegalStateException("No WebApplicationContext found: initializer not registered?"); 10 } 11 return wac; 12 }
(1.3)重新建立WebApplicationContext例項。
如果通過以上兩種方式並沒有找到任何突破,那就沒有辦法了,只能在這裡重新建立新的例項了。
1 protected WebApplicationContext createWebApplicationContext(@Nullable WebApplicationContext parent) { 2 return createWebApplicationContext((ApplicationContext) parent); 3 }
1 protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) { 2 //獲取servlet的初始化引數contextClass,如果沒有配置預設為XMLWebApplication.class 3 Class<?> contextClass = getContextClass(); 4 if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) { 5 throw new ApplicationContextException( 6 "Fatal initialization error in servlet with name '" + getServletName() + 7 "': custom WebApplicationContext class [" + contextClass.getName() + 8 "] is not of type ConfigurableWebApplicationContext"); 9 } 10 //通過反射方式例項化contextClass 11 ConfigurableWebApplicationContext wac = 12 (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass); 13 14 wac.setEnvironment(getEnvironment()); 15 //parent為在ContextloaderListener中建立的例項,在ContextLoaderListener載入的時候初始化的WebApplicationContext型別例項 16 wac.setParent(parent); 17 String configLocation = getContextConfigLocation(); 18 if (configLocation != null) { 19 //獲取contextConfigLocation屬性,配置在servlet初始化引數中 20 wac.setConfigLocation(configLocation); 21 } 22 //初始化Spring環境包括載入配置檔案等 23 configureAndRefreshWebApplicationContext(wac); 24 25 return wac; 26 }
(2)configureAndRefreshWebApplicationContext
無論是通過建構函式注入還是單獨建立,都免不了會呼叫configureAndRefreshWebApplicationContext方法來對已經建立的WebApplicationContext例項進行配置及重新整理,那麼這個步驟又做了哪些工作呢?
1 protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) { 2 if (ObjectUtils.identityToString(wac).equals(wac.getId())) { 3 // The application context id is still set to its original default value 4 // -> assign a more useful id based on available information 5 if (this.contextId != null) { 6 wac.setId(this.contextId); 7 } 8 else { 9 // Generate default id... 10 wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX + 11 ObjectUtils.getDisplayString(getServletContext().getContextPath()) + '/' + getServletName()); 12 } 13 } 14 15 wac.setServletContext(getServletContext()); 16 wac.setServletConfig(getServletConfig()); 17 wac.setNamespace(getNamespace()); 18 wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener())); 19 20 // The wac environment's #initPropertySources will be called in any case when the context 21 // is refreshed; do it eagerly here to ensure servlet property sources are in place for 22 // use in any post-processing or initialization that occurs below prior to #refresh 23 ConfigurableEnvironment env = wac.getEnvironment(); 24 if (env instanceof ConfigurableWebEnvironment) { 25 ((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig()); 26 } 27 28 postProcessWebApplicationContext(wac); 29 applyInitializers(wac); 30 //載入配置檔案及整合parent到wac 31 wac.refresh(); 32 }
(3)重新整理
onRefresh是FrameworkServlet類中提供的模板方法,在其子類DispatcherServlet中進行了重寫,主要用於重新整理Spring在Web功能實現中所必須使用的全域性變數。下面我們會介紹它們的初始化過程以及使用場景,而至於具體的使用細節會在稍後的章節中再做詳細的介紹。
1 /** 2 * This implementation calls {@link #initStrategies}. 3 */ 4 @Override 5 protected void onRefresh(ApplicationContext context) { 6 initStrategies(context); 7 } 8 9 /** 10 * Initialize the strategy objects that this servlet uses. 11 * <p>May be overridden in subclasses in order to initialize further strategy objects. 12 */ 13 protected void initStrategies(ApplicationContext context) { 14 //(1)初始化MultipartResolver 15 initMultipartResolver(context); 16 //(2)初始化LocaleResolver 17 initLocaleResolver(context); 18 //(3)初始化ThemeResolver 19 initThemeResolver(context); 20 //(4)初始化HandlerMappings 21 initHandlerMappings(context); 22 //(5)初始化HandlerAdapters 23 initHandlerAdapters(context); 24 //(6)初始化HandlerExceptionResolvers 25 initHandlerExceptionResolvers(context); 26 //(7)初始化RequestToViewNameTranslator 27 initRequestToViewNameTranslator(context); 28 //(8)初始化ViewResolvers 29 initViewResolvers(context); 30 //(9)初始化FlashMapManager 31 initFlashMapManager(context); 32 }
(3.1)初始化MultipartResolver
在Spring中,MultipartResolver主要用來處理檔案上傳。預設情況下,Spring是沒有Multipart處理的,因為一些開發者想要自己處理它們。如果想使用Spring的multipart,則需要在Web應用的上下文中新增multipart解析器。這樣,每個請求就會被檢查是否包含multipart。然而,如果請求中包含multipart,那麼上下文中定義的MultipartResolver就會解析它,這樣請求的multipart屬性就會像其他屬性一樣被處理。常用配置如下:
1 <bean id="multipartResolver" class="org.Springframework.web.multipart.commons.CommonsMultipartResolver"> 2 <!--該屬性用來配置可上傳檔案的最大byte數--> 3 <proterty name="maximumFileSize"><value>100000</value></proterty> 4 </bean>
當然,CommonsMultipartResolver還提供了其他功能用於幫助使用者完成上傳功能,有興趣的讀者可以進一步檢視。
那麼MultipartResolver就是在initMultipartResolver中被加入到DispatcherServlet中的。
1 private void initMultipartResolver(ApplicationContext context) { 2 try { 3 this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class); 4 if (logger.isTraceEnabled()) { 5 logger.trace("Detected " + this.multipartResolver); 6 } 7 else if (logger.isDebugEnabled()) { 8 logger.debug("Detected " + this.multipartResolver.getClass().getSimpleName()); 9 } 10 } 11 catch (NoSuchBeanDefinitionException ex) { 12 // Default is no multipart resolver. 13 this.multipartResolver = null; 14 if (logger.isTraceEnabled()) { 15 logger.trace("No MultipartResolver '" + MULTIPART_RESOLVER_BEAN_NAME + "' declared"); 16 } 17 } 18 }
因為之前的步驟已經完成了Spring中配置檔案的解析,所以在這裡只要在配置檔案註冊過都可以通過ApplicationContext提供的getBean方法來直接獲取對應的bean,進而初始化MultipartResolver中的MultipartResolver變數。
(3.2)初始化LocalResolver
在Spring國際化配置中一共有3種使用方式。
1. 基於URL引數的配置
通過URL引數來控制國際化,比如你在頁面上加一句<a href=”?locale=zh_CN”>簡體中文</a>來控制專案中使用的國際化引數。而提供這個功能的就是AcceptHeaderLocalResolver,預設的引數名為local,注意大小寫。裡面放的就是你的提交引數,比如en_US、zh_CN之類的,具體配置如下:
<bean id=”localResolver” class=”org.Springframework.web.servlet.i18n.AcceptHeaderLocalResolver”/>
2. 基於session的配置
它通過檢驗使用者會話中國預置的屬性來解析區域。最常用的是根據使用者本次會話過程中的語言設定決定語言種類(例如,使用者登入時選擇語言種類,則此次登入週期內統一使用此語言設定),如果會話屬性不存在,它會根據accept-language HTTP頭部確定預設區域。
<bean id=”localResolver” class=”org.Springframework.web.servlet.i18n.SessionLocaleResolver”>
3. 基於Cookie的國際化配置。
CookieLocalResolver用於通過瀏覽器的cookie設定取得Locale物件。這種策略再應用程式不支援會話或者狀態必須儲存在客戶端時有用,配置如下:
<bean id=”localResolver” class=”org.Springframework.web.servlet.i18n.CookieLocalResolver”>
這3種方式都可以解決國際化的問題,但是,對於LocalResolver的使用基礎是在DispatcherServlet中初始化的。
1 private void initLocaleResolver(ApplicationContext context) { 2 try { 3 this.localeResolver = context.getBean(LOCALE_RESOLVER_BEAN_NAME, LocaleResolver.class); 4 if (logger.isTraceEnabled()) { 5 logger.trace("Detected " + this.localeResolver); 6 } 7 else if (logger.isDebugEnabled()) { 8 logger.debug("Detected " + this.localeResolver.getClass().getSimpleName()); 9 } 10 } 11 catch (NoSuchBeanDefinitionException ex) { 12 // We need to use the default. 13 this.localeResolver = getDefaultStrategy(context, LocaleResolver.class); 14 if (logger.isTraceEnabled()) { 15 logger.trace("No LocaleResolver '" + LOCALE_RESOLVER_BEAN_NAME + 16 "': using default [" + this.localeResolver.getClass().getSimpleName() + "]"); 17 } 18 } 19 }
提取配置檔案中設定的LocalResolver來初始化DispatcherServlet中的localeResolver屬性。
(3.3)初始化ThemeResolver。
在Web開發中經常會遇到通過主題Theme來控制網頁風格。這將進一步改善使用者體驗。簡單的說,一個主題就是一組靜態資源(比如樣式表和圖片)。它們可以影響程式的視覺效果。Spring中的主題功能和國際化功能非常類似。構成Spring主題功能主要包括如下內容。
1. 主題資源
org.Springframework.ui.context.ThemeSource是Spring中主題資源的介面。Spring的主題需要通過ThemeSource介面來實現存放主題資訊的資源。
org.Springframework.ui.context.support.ResourceBundleThemeSource是ThemeSource介面預設實現類(也就是通過ResourceBundle資源的方式定義主題。)在Spring中的配置如下:
1 <bean id="themeSource" class="org.Springframework.ui.context.support.ResourceBundleThemeSource"> 2 <proterty name="basenamePrefix" value="com.text."></proterty> 3 </bean>
預設狀態下是在類路徑根目錄下查詢相應的資原始檔。也可以通過basenamePrefix來制定。這樣,DispatcherServlet就會在com.test包下查詢資原始檔。
2. 主題解析器。
ThemeSource定義了一些主題資源,那麼不同的使用者使用什麼主題資源由誰定義呢?org.Springframework.web.servlet.ThemeResolver是主題解析器的介面,主題解析器的工作便是由它的子類來完成的。
對於主題解析器的子類主要有3個比較常用的實現。以主題檔案summer.properties為例。
①FixedThemeResolver用於選擇一個固定的主題。
1 <bean id="themeSource" class="org.Springframework.web.servlet.theme.FixedThemeResolver"> 2 <proterty name="defaultThemeName" value="summer"/> 3 </bean>
以上配置的作用是設定主題檔案為summer.properties,在整個專案內固定不變。
②CookieThemeResolver用於實現使用者所選的主題,以cookie的形式存放在客戶端的機器上,配置如下:
1 <bean id="themeSource" class="org.Springframework.web.servlet.theme. CookieThemeResolver"> 2 <proterty name="defaultThemeName" value="summer"/> 3 </bean>
③SessionThemeResolver用於主題儲存在使用者的HTTP session中。
1 <bean id="themeSource" class="org.Springframework.web.servlet.theme. SessionThemeResolver"> 2 <proterty name="defaultThemeName" value="summer"/> 3 </bean>
以上配置用於設定主題名稱,並且將該名稱儲存在使用者的HttpSession中。
④AbstractThemeResolver是一個抽象類被SessionThemeResolver和FixedThemeResolver繼承,使用者也可以繼承它來自定義主題解析器。
3. 攔截器。
如果需要根據使用者請求來改變主題,那麼Spring提供了一個已經實現的攔截器ThemeChangeInterceptor攔截器了,配置如下:
1 <bean id="themeChangeInterceptor" class="org.Springframework.web.servlet.theme.ThemeChangeInterceptor"> 2 <proterty name="paramName" value="themeName"/> 3 </bean>
其中設定使用者請求引數名為themeName,即URL為?themeName=具體的主題名稱。此外,還需要在handlerMapping中配置攔截器。當然需要在handleMapping中新增攔截器。
1 <property name="interceptors"> 2 <list> 3 <ref local="themeChangeInterceptor"/> 4 </list> 5 </property>
瞭解了主題檔案的簡單使用方式後,再來檢視解析器的初始化工作。與其他變數的初始化工作相同,主題檔案解析器的初始化工作並沒有任何特別需要說明的地方。
1 private void initThemeResolver(ApplicationContext context) { 2 try { 3 this.themeResolver = context.getBean(THEME_RESOLVER_BEAN_NAME, ThemeResolver.class); 4 if (logger.isTraceEnabled()) { 5 logger.trace("Detected " + this.themeResolver); 6 } 7 else if (logger.isDebugEnabled()) { 8 logger.debug("Detected " + this.themeResolver.getClass().getSimpleName()); 9 } 10 } 11 catch (NoSuchBeanDefinitionException ex) { 12 // We need to use the default. 13 this.themeResolver = getDefaultStrategy(context, ThemeResolver.class); 14 if (logger.isTraceEnabled()) { 15 logger.trace("No ThemeResolver '" + THEME_RESOLVER_BEAN_NAME + 16 "': using default [" + this.themeResolver.getClass().getSimpleName() + "]"); 17 } 18 } 19 }
(3.4)初始化HandlerMapping
當客戶端發出Request時DispatcherServlet會將Request提交給HandlerMapping,然後HandlerMapping根據WebApplicationContext的配置來回傳給DispatcherServlet響應的Controller。
在基於SpringMVC的Web應用程式中,我們可以為DispatcherServlet提供多個HandlerMapping供其使用。DispatcherServlet在選用HandlerMapping的過程中,將根據我們所指定的一系列HandlerMapping的優先順序進行排序,然後優先使用優先順序在簽名的HandlerMapping。如果當前的HandlerMapping能夠返回可用的Handler,DispatcherServlet則使用當前返回的Handler進行Web請求的處理,而不再繼續詢問其他的HandlerMapping。否則,DispatcherServlet將繼續按照各個HandlerMapping的優先順序進行詢問,直到獲取一個可用的Handler為止。初始化配置如下:
1 private void initHandlerMappings(ApplicationContext context) { 2 this.handlerMappings = null; 3 4 if (this.detectAllHandlerMappings) { 5 // Find all HandlerMappings in the ApplicationContext, including ancestor contexts. 6 Map<String, HandlerMapping> matchingBeans = 7 BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false); 8 if (!matchingBeans.isEmpty()) { 9 this.handlerMappings = new ArrayList<>(matchingBeans.values()); 10 // We keep HandlerMappings in sorted order. 11 AnnotationAwareOrderComparator.sort(this.handlerMappings); 12 } 13 } 14 else { 15 try { 16 HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class); 17 this.handlerMappings = Collections.singletonList(hm); 18 } 19 catch (NoSuchBeanDefinitionException ex) { 20 // Ignore, we'll add a default HandlerMapping later. 21 } 22 } 23 24 // Ensure we have at least one HandlerMapping, by registering 25 // a default HandlerMapping if no other mappings are found. 26 if (this.handlerMappings == null) { 27 this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class); 28 if (logger.isTraceEnabled()) { 29 logger.trace("No HandlerMappings declared for servlet '" + getServletName() + 30 "': using default strategies from DispatcherServlet.properties"); 31 } 32 } 33 }
預設情況下,SpringMVC將載入當前系統中所有實現了HandlerMapping介面的bean。如果只期望SpringMVC載入指定的handlerMapping時,可用修改web.xml中的DispatcherServlet的初始引數,將detectAllHandlerMappings的值設定為false:
1 <init-param> 2 <param-name>detectAllHandlerMappings</param-name> 3 <param-value>false</param-value> 4 </init-param>
此時,SpringMVC將查詢名為“HandlerMapping”的bean,並作為當前系統中唯一的handlerMapping。如果沒有定義HandlerMapping的話,則SpringMVC將按照org.Springframework.web.servlet.DispatcherServlet所在目錄下的DispatcherServlet.properties中所定義的org.Springframework.web.servlet.HandlerMapping的內容來載入預設的handlerMapping(使用者沒有自定義Strategies的情況下)。
(3.5)初始化HandlerAdapters
從名字也能聯想到這是一個典型的介面卡模式的使用,在計算機程式設計中,介面卡模式將一個類的介面適配成使用者所期待的。使用介面卡,可以使介面不相容而無法在一起工作的類協同工作。做飯是將類自己的介面包裹在一個已存在的類中。那麼在處理handler時為什麼會使用介面卡模式呢?回答這個問題我們首先要分析它的初始化邏輯。
1 private void initHandlerAdapters(ApplicationContext context) { 2 this.handlerAdapters = null; 3 4 if (this.detectAllHandlerAdapters) { 5 // Find all HandlerAdapters in the ApplicationContext, including ancestor contexts. 6 Map<String, HandlerAdapter> matchingBeans = 7 BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false); 8 if (!matchingBeans.isEmpty()) { 9 this.handlerAdapters = new ArrayList<>(matchingBeans.values()); 10 // We keep HandlerAdapters in sorted order. 11 AnnotationAwareOrderComparator.sort(this.handlerAdapters); 12 } 13 } 14 else { 15 try { 16 HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class); 17 this.handlerAdapters = Collections.singletonList(ha); 18 } 19 catch (NoSuchBeanDefinitionException ex) { 20 // Ignore, we'll add a default HandlerAdapter later. 21 } 22 } 23 24 // Ensure we have at least some HandlerAdapters, by registering 25 // default HandlerAdapters if no other adapters are found. 26 if (this.handlerAdapters == null) { 27 this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class); 28 if (logger.isTraceEnabled()) { 29 logger.trace("No HandlerAdapters declared for servlet '" + getServletName() + 30 "': using default strategies from DispatcherServlet.properties"); 31 } 32 } 33 }
同樣在初始化的過程中涉及了一個變數detectAllHandlerAdapters,detectAllHandlerAdapters的作用和detectAllHandlerMapping類似,只不過作用物件為handlerAdapter。亦可通過如下配置來強制系統只加載bean name為“handlerAdapter”的handlerAdapter。
1 <init-param> 2 <param-name>detectAllHandlerAdapters</param-name> 3 <param-value>false</param-value> 4 </init-param>
如果無法找到對應的bean,那麼系統會嘗試載入預設的介面卡。
1 @SuppressWarnings("unchecked") 2 protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) { 3 String key = strategyInterface.getName(); 4 String value = defaultStrategies.getProperty(key); 5 if (value != null) { 6 String[] classNames = StringUtils.commaDelimite