[Java]SpringMVC工作原理之二:HandlerMapping和HandlerAdapter
一、HandlerMapping
作用是根據當前請求的找到對應的 Handler,並將 Handler(執行程序)與一堆 HandlerInterceptor(攔截器)封裝到 HandlerExecutionChain 對象中,在 HandlerMapping 接口的內部只有一個方法,如下:
- HandlerExecutionChain getHandler(HttpServletRequest request);
上面說到的 Handler 有可能是一個 HandlerMethod(封裝了 Controller 中的方法)對象,也有可能是一個 Controller 對象、 HttpRequestHandler 對象或 Servlet 對象,而這個 Handler 具體是什麽對象,是與所使用的 HandlerMapping 實現類有關。如下圖所示,可以看到它有兩個分支,分別繼承自 AbstractHandlerMethodMapping(得到 HandlerMethod)和 AbstractUrlHandlerMapping(得到 HttpRequestHandler、Controller 或 Servlet),它們又統一繼承於 AbstractHandlerMapping。
先來看一下 AbstractHandlerMapping,它實現了 HandlerMapping 接口中的 getHandler() 方法,源碼如下所示
@Override public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception { // 根據請求獲取執行程序,具體的獲取方式由子類決定,getHandlerInternal() 是抽象方法 Object handler = getHandlerInternal(request); if (handler == null) { handler = getDefaultHandler(); } if (handler == null) { return null; } // Bean name or resolved handler? if (handler instanceof String) { String handlerName = (String) handler; handler = getApplicationContext().getBean(handlerName); } // 將 Handler 與一堆攔截器包裝到 HandlerExecutionChain 對象中return getHandlerExecutionChain(handler, request); }
可以看到在這個方法中又調用了 getHandlerInternal() 方法獲取到了 Handler 對象,而 Handler 對象具體內容是由它的子類去定義的。下面就來一看下 AbstractHandlerMapping 的兩個分支子類
1 AbstractUrlHandlerMapping
AbstractUrlHandlerMapping 這個分支獲取的 Handler 的類型實際就是一個 Controller 類,所以一個 Controller 只能對應一個請求(或者像 Struts2 那樣定位到方法,使同一個業務的方法放在同一個類裏),源碼如下所示
protected Object getHandlerInternal(HttpServletRequest request) throws Exception { // 根據當前請求獲取“查找路徑” String lookupPath = getUrlPathHelper().getLookupPathForRequest(request); // 根據路徑獲取 Handler(即Controller),先嘗試直接匹配,再嘗試模式匹配 Object handler = lookupHandler(lookupPath, request); if (handler == null) { // We need to care for the default handler directly, since we need to // expose the PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE for it as well. Object rawHandler = null; if ("/".equals(lookupPath)) { rawHandler = getRootHandler(); } if (rawHandler == null) { rawHandler = getDefaultHandler(); } if (rawHandler != null) { // Bean name or resolved handler? if (rawHandler instanceof String) { String handlerName = (String) rawHandler; rawHandler = getApplicationContext().getBean(handlerName); } validateHandler(rawHandler, request); handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null); } } return handler; }
1.1 AbstractUrlHandlerMapping 實現類及使用
1) ControllerClassNameHandlerMapping:根據類名訪問 Controller。
<!-- 註冊 HandlerMapping --> <bean class="org.springframework.web.servlet.handler.ControllerClassNameHandlerMapping" /> <!-- 註冊 Handler --> <bean class="com.controller.TestController" />
2) ControllerBeanNameHandlerMapping:根據 Bean 名訪問 Controller,與 BeanNameUrlHandlerMapping 類似,但是bean名稱不用遵循URL公約。
<!-- 註冊 HandlerMapping --> <bean class="org.springframework.web.servlet.handler.ControllerBeanNameHandlerMapping" /> <!-- 註冊 Handler --> <bean id="test" class="com.controller.TestController" />
3) BeanNameUrlHandlerMapping:利用 BeanName 來作為 URL 使用。
<!-- 註冊 HandlerMapping --> <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" /> <!-- 註冊 Handler --> <bean id="/test.do" class="com.controller.TestController" />
4) SimpleUrlHandlerMapping:可以將 URL 與處理器的定義分離,還可以對 URL 進行統一的映射管理。
<!-- 註冊 HandlerMapping --> <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping"> <property name="mappings"> <props> <prop key="/test.do">testController</prop> <prop key="/hello.do">testController</prop> </props> </property> </bean> <!-- 註冊 Handler --> <bean id="testController" class="com.controller.TestController" />
1.2 Controller 類
使用 AbstractUrlHandlerMapping 的實現類時,需要讓控制層的類實現 Controller 接口(一般繼承 AbstractController 即可),另外還有一些已經實現了的 Controller 類,如下圖所示。但是不論是自己實現 Controller 接口還是使用系統已經實現的類,都只能處理一個請求(除了 MultiActionController 可以通過參數的方式讓一個類可以處理多個請求)。
另外下面所有的 Controller 均采用 SimpleUrlHandlerMapping 方式的。
1) UrlFilenameViewController:用於跳轉界面,控制器根據請求的URL直接解析出視圖名,省去了自己實現 Ccntroller 跳轉頁面。
<bean id="indexController" class="org.springframework.web.servlet.mvc.UrlFilenameViewController" />
2) ParameterizableViewController:同樣用於界面跳轉,控制器根據配置的參數來跳轉界面,使用方式如下
<bean id="indexController" class="org.springframework.web.servlet.mvc.ParameterizableViewController"> <property name="viewName" value="/index.jsp" /> </bean>
3) ServletForwardingController:將請求轉發到 Servlet,使用方式如下
<bean id="indexController" class="org.springframework.web.servlet.mvc.ServletForwardingController"> <property name="servletName" value="indexServlet" /> </bean>
另外還要在 web.xml 中配置要轉發到的 Servlet
<servlet> <servlet-name>indexServlet</servlet-name> <servlet-class>com.servlet.ServletForwarding</servlet-class> </servlet>
4) ServletWrappingController:將某個 Servlet 包裝為 Controller,所有到 ServletWrappingController 的請求實際上是由它內部所包裝的這個 Servlet 實例來處理的,這樣可以將這個 Servlet 隱藏起來
5) MultiActionController:一個 Controller 可以寫多個方法,分別對應不同的請求,使同一業務的方法可以放在一起了。在使用時讓自己的 Controller 類繼承 MultiActionController 類,使用方式如下
public class IndexController extends MultiActionController { public ModelAndView add(HttpServletRequest request,HttpServletResponse response) { ModelAndView mv = new ModelAndView(); mv.addObject("message","add"); mv.setViewName("add"); return mv; } public ModelAndView delete(HttpServletRequest request,HttpServletResponse response) { ModelAndView mv = new ModelAndView(); mv.addObject("message","delete"); mv.setViewName("delete"); return mv; } }
配置自己的 Controller 時要配置一個方法名解析器(默認是 InternalPathMethodNameResolver )
<bean id="indexController" class="com.controller.IndexController"> <property name="methodNameResolver"> <!-- InternalPathMethodNameResolver 根據請求路徑解析執行方法名 ParameterMethodNameResolver 根據參數解析執行方法名 PropertiesMethodNameResolver 根據 key/value 列表解析執行方法名 --> <bean class="org.springframework.web.servlet.mvc.multiaction.ParameterMethodNameResolver"> <!-- 指定參數名為action --> <property name="paramName" value="action" /> </bean> </property> </bean>
當我們訪問 http://localhost:8080/***/indexAction.do?action=add 時,進入 add() 方法;
當我們訪問 http://localhost:8080/***/indexAction.do?action=delete 時,進入 delete() 方法。
2 AbstractHandlerMethodMapping
AbstractHandlerMethodMapping 這個分支獲取的 Handler 的類型是 HandlerMethod,即這個 Handler 是一個方法,它保存了方法的信息(如Method),這樣一個 Controller 就可以處理多個請求了,源碼如下所示
@Override protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception { // 根據當前請求獲取“查找路徑” String lookupPath = getUrlPathHelper().getLookupPathForRequest(request); // 獲取當前請求最佳匹配的處理方法(即Controller類的方法中) HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request); return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null); }
看完上述代碼後有一個疑問,HandlerMethod 是怎麽創建的(即怎麽把 Controller 的方法變成了它),繼續看一下源碼,如下所示
protected void initHandlerMethods() { // 獲取了所有已經註冊的 Bean 的名稱 String[] beanNames = (this.detectHandlerMethodsInAncestorContexts ? BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) : getApplicationContext().getBeanNamesForType(Object.class)); for (String beanName : beanNames) { // isHandler()方法由子類實現,判斷這個 Bean 是否擁有 @Controller 註解或 @RequestMapping 註解 if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX) && isHandler(getApplicationContext().getType(beanName))){ // 在這個 Bean 中查找 HandlerMethod 並添加到 Map 中 detectHandlerMethods(beanName); } } handlerMethodsInitialized(getHandlerMethods()); }
看完上述代碼後,可以知道是在 detectHandlerMethods() 方法中將指定 Bean 的方法轉換為 HandlerMethod 對象,具體實現如下
protected void detectHandlerMethods(final Object handler) { Class<?> handlerType = (handler instanceof String ? getApplicationContext().getType((String) handler) : handler.getClass()); // Avoid repeated calls to getMappingForMethod which would rebuild RequestMappingInfo instances final Map<Method, T> mappings = new IdentityHashMap<Method, T>(); final Class<?> userType = ClassUtils.getUserClass(handlerType); Set<Method> methods = HandlerMethodSelector.selectMethods(userType, new MethodFilter() { @Override public boolean matches(Method method) { T mapping = getMappingForMethod(method, userType); if (mapping != null) { mappings.put(method, mapping); return true; } else { return false; } } }); for (Method method : methods) { registerHandlerMethod(handler, method, mappings.get(method)); } }
上述代碼通過 HandlerMethodSelector.selectMethods() 方法獲取了 java.lang.reflect.Method 對象,即將 Bean 的方法利用反射獲取出來,然後將其包裝到 HandlerMethod 對象中。
1.1 AbstractHandlerMapping 實現類及使用
AbstractHandlerMapping 只有一個實現類 RequestMappingHandlerMapping
二、HandlerAdapter
根據 Handler 來找到支持它的 HandlerAdapter,通過 HandlerAdapter 執行這個 Handler 得到 ModelAndView 對象。HandlerAdapter 接口中的方法如下:
- boolean supports(Object handler); // 當前 HandlerAdapter 是否支持這個 Handler
- ModelAndView handle(HttpServletRequest req, HttpServletResponse res, Object handler); // 利用 Handler 處理請求
- long getLastModified(HttpServletRequest request, Object handler);
1 RequestMappingHandlerAdapter
從上面的文章中可以知道,利用 RequestMappingHandlerMapping 獲取的 Handler 是 HadnlerMethod 類型,它代表 Controller 裏要執行的方法,而 RequestMappingHandlerAdapter 可以執行 HadnlerMethod 對象。
RequestMappingHandlerAdapter 的 handle() 方法是在它的父類 AbstractHandlerMethodAdapter 類中實現的,源碼如下所示
@Override public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { return handleInternal(request, response, (HandlerMethod) handler); }
handleInternal() 方法是由 RequestMappingHandlerAdapter 自己來實現的,源碼如下所示
@Override protected ModelAndView handleInternal(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception { // 是否通過 @SessionAttributes 註釋聲明了 session 屬性。 if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {management. checkAndPrepare(request, response, this.cacheSecondsForSessionAttributeHandlers, true); } else { checkAndPrepare(request, response, true); } // 是否需要在 synchronize 塊中執行 if (this.synchronizeOnSession) { HttpSession session = request.getSession(false); if (session != null) { Object mutex = WebUtils.getSessionMutex(session); synchronized (mutex) { // 執行 HandlerMethod return invokeHandleMethod(request, response, handlerMethod); } } } // 執行 HandlerMethod,得到 ModelAndView return invokeHandleMethod(request, response, handlerMethod); }
2 HttpRequestHandlerAdapter
HttpRequestHandlerAdapter 可以執行 HttpRequestHandler 類型的 Handler,源碼如下
@Override public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { ((HttpRequestHandler) handler).handleRequest(request, response); return null; }
3 SimpleControllerHandlerAdapter
SimpleControllerHandlerAdapter 可以執行 Controller 類型的 Handler,源碼如下
@Override public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { return ((Controller) handler).handleRequest(request, response); }
4 SimpleServletHandlerAdapter
SimpleServletHandlerAdapter 可以執行 Servlet 類型的 Handler,源碼如下
@Override public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { ((Servlet) handler).service(request, response); return null; }
三、HandlerExceptionResolver
負責處理異常的類,負責根據異常來設置 ModelAndView,然後交由 render 渲染界面。HandlerExecptionResolver 接口中只有一個方法,如下:
- ModelAndView resolveException(HttpServletRequest req, HttpServletResponse res, Object handler, Exception ex);
[Java]SpringMVC工作原理之二:HandlerMapping和HandlerAdapter