SpringMVC

時間 2019-12-19

原文原文鏈接

1、首先，咱們先來認識一下SpringMVC的主要組件html

前端控制器（DisatcherServlet）:接收請求，響應結果，返回能夠是json,String等數據類型，也能夠是頁面（Model）。
處理器映射器（HandlerMapping）:根據URL去查找處理器，通常經過xml配置或者註解進行查找。
處理器（Handler）：就是咱們常說的controller控制器啦，由程序員編寫。
處理器適配器（HandlerAdapter）:能夠將處理器包裝成適配器，這樣就能夠支持多種類型的處理器。
視圖解析器（ViewResovler）:進行視圖解析，返回view對象（常見的有JSP,FreeMark等）。
2、SpingMVC的工做原理前端

下面是文字步驟說明：java

一、用戶發送請求到前端控制器（DispatcherServlet）。
二、前端控制器請求處理器映射器（HandlerMapping）去查找處理器（Handler）。
三、找到之後處理器映射器（HandlerMappering）向前端控制器返回執行鏈（HandlerExecutionChain）。
四、前端控制器（DispatcherServlet）調用處理器適配器（HandlerAdapter）去執行處理器（Handler）。
五、處理器適配器去執行Handler。
六、處理器執行完給處理器適配器返回ModelAndView。
七、處理器適配器向前端控制器返回ModelAndView。
八、前端控制器請求視圖解析器（ViewResolver）去進行視圖解析。
九、視圖解析器向前端控制器返回View。
十、前端控制器對視圖進行渲染。
十一、前端控制器向用戶響應結果。
---------------------
做者：小鏡子W
來源：CSDN
原文：https://blog.csdn.net/wdehxiang/article/details/77619512
版權聲明：本文爲博主原創文章，轉載請附上博文連接！程序員

SpringMVC的工做原理圖：web

SpringMVC流程

一、用戶發送請求至前端控制器DispatcherServlet。spring

二、 DispatcherServlet收到請求調用HandlerMapping處理器映射器。json

三、處理器映射器找到具體的處理器(能夠根據xml配置、註解進行查找)，生成處理器對象及處理器攔截器(若是有則生成)一併返回給DispatcherServlet。後端

四、 DispatcherServlet調用HandlerAdapter處理器適配器。設計模式

五、 HandlerAdapter通過適配調用具體的處理器(Controller，也叫後端控制器)。瀏覽器

六、 Controller執行完成返回ModelAndView。

七、 HandlerAdapter將controller執行結果ModelAndView返回給DispatcherServlet。

八、 DispatcherServlet將ModelAndView傳給ViewReslover視圖解析器。

九、 ViewReslover解析後返回具體View。

十、DispatcherServlet根據View進行渲染視圖（即將模型數據填充至視圖中）。

十一、 DispatcherServlet響應用戶。

組件說明：

如下組件一般使用框架提供實現：

DispatcherServlet：做爲前端控制器，整個流程控制的中心，控制其它組件執行，統一調度，下降組件之間的耦合性，提升每一個組件的擴展性。

HandlerMapping：經過擴展處理器映射器實現不一樣的映射方式，例如：配置文件方式，實現接口方式，註解方式等。

HandlAdapter：經過擴展處理器適配器，支持更多類型的處理器。

ViewResolver：經過擴展視圖解析器，支持更多類型的視圖解析，例如：jsp、freemarker、pdf、excel等。

組件：
一、前端控制器DispatcherServlet（不須要工程師開發）,由框架提供
做用：接收請求，響應結果，至關於轉發器，中央處理器。有了dispatcherServlet減小了其它組件之間的耦合度。
用戶請求到達前端控制器，它就至關於mvc模式中的c，dispatcherServlet是整個流程控制的中心，由它調用其它組件處理用戶的請求，dispatcherServlet的存在下降了組件之間的耦合性。

二、處理器映射器HandlerMapping(不須要工程師開發),由框架提供
做用：根據請求的url查找Handler
HandlerMapping負責根據用戶請求找到Handler即處理器，springmvc提供了不一樣的映射器實現不一樣的映射方式，例如：配置文件方式，實現接口方式，註解方式等。

三、處理器適配器HandlerAdapter
做用：按照特定規則（HandlerAdapter要求的規則）去執行Handler
經過HandlerAdapter對處理器進行執行，這是適配器模式的應用，經過擴展適配器能夠對更多類型的處理器進行執行。

四、處理器Handler(須要工程師開發)
注意：編寫Handler時按照HandlerAdapter的要求去作，這樣適配器才能夠去正確執行Handler
Handler 是繼DispatcherServlet前端控制器的後端控制器，在DispatcherServlet的控制下Handler對具體的用戶請求進行處理。
因爲Handler涉及到具體的用戶業務請求，因此通常狀況須要工程師根據業務需求開發Handler。

五、視圖解析器View resolver(不須要工程師開發),由框架提供
做用：進行視圖解析，根據邏輯視圖名解析成真正的視圖（view）
View Resolver負責將處理結果生成View視圖，View Resolver首先根據邏輯視圖名解析成物理視圖名即具體的頁面地址，再生成View視圖對象，最後對View進行渲染將處理結果經過頁面展現給用戶。 springmvc框架提供了不少的View視圖類型，包括：jstlView、freemarkerView、pdfView等。
通常狀況下須要經過頁面標籤或頁面模版技術將模型數據經過頁面展現給用戶，須要由工程師根據業務需求開發具體的頁面。

六、視圖View(須要工程師開發jsp...)
View是一個接口，實現類支持不一樣的View類型（jsp、freemarker、pdf...）

核心架構的具體流程步驟以下：
一、首先用戶發送請求——>DispatcherServlet，前端控制器收到請求後本身不進行處理，而是委託給其餘的解析器進行處理，做爲統一訪問點，進行全局的流程控制；
二、DispatcherServlet——>HandlerMapping， HandlerMapping 將會把請求映射爲HandlerExecutionChain 對象（包含一個Handler 處理器（頁面控制器）對象、多個HandlerInterceptor 攔截器）對象，經過這種策略模式，很容易添加新的映射策略；
三、DispatcherServlet——>HandlerAdapter，HandlerAdapter 將會把處理器包裝爲適配器，從而支持多種類型的處理器，即適配器設計模式的應用，從而很容易支持不少類型的處理器；
四、HandlerAdapter——>處理器功能處理方法的調用，HandlerAdapter 將會根據適配的結果調用真正的處理器的功能處理方法，完成功能處理；並返回一個ModelAndView 對象（包含模型數據、邏輯視圖名）；
五、ModelAndView的邏輯視圖名——> ViewResolver， ViewResolver 將把邏輯視圖名解析爲具體的View，經過這種策略模式，很容易更換其餘視圖技術；
六、View——>渲染，View會根據傳進來的Model模型數據進行渲染，此處的Model實際是一個Map數據結構，所以很容易支持其餘視圖技術；
七、返回控制權給DispatcherServlet，由DispatcherServlet返回響應給用戶，到此一個流程結束。

下邊兩個組件一般狀況下須要開發：

Handler：處理器，即後端控制器用controller表示。

View：視圖，即展現給用戶的界面，視圖中一般須要標籤語言展現模型數據。

在將SpringMVC以前咱們先來看一下什麼是MVC模式

MVC：MVC是一種設計模式

MVC的原理圖：

分析：

M-Model 模型（完成業務邏輯：有javaBean構成，service+dao+entity）

V-View 視圖（作界面的展現 jsp，html……）

C-Controller 控制器（接收請求—>調用模型—>根據結果派發頁面）

springMVC是什麼：

　　springMVC是一個MVC的開源框架，springMVC=struts2+spring，springMVC就至關因而Struts2加上sring的整合，可是這裏有一個疑惑就是，springMVC和spring是什麼樣的關係呢？這個在百度百科上有一個很好的解釋：意思是說，springMVC是spring的一個後續產品，其實就是spring在原有基礎上，又提供了web應用的MVC模塊，能夠簡單的把springMVC理解爲是spring的一個模塊（相似AOP，IOC這樣的模塊），網絡上常常會說springMVC和spring無縫集成，其實springMVC就是spring的一個子模塊，因此根本不須要同spring進行整合。

SpringMVC的原理圖：

看到這個圖你們可能會有不少的疑惑，如今咱們來看一下這個圖的步驟：（能夠對比MVC的原理圖進行理解）

第一步:用戶發起請求到前端控制器（DispatcherServlet）

第二步：前端控制器請求處理器映射器（HandlerMappering）去查找處理器（Handle）：經過xml配置或者註解進行查找

第三步：找到之後處理器映射器（HandlerMappering）像前端控制器返回執行鏈（HandlerExecutionChain）

第四步：前端控制器（DispatcherServlet）調用處理器適配器（HandlerAdapter）去執行處理器（Handler）

第五步：處理器適配器去執行Handler

第六步：Handler執行完給處理器適配器返回ModelAndView

第七步：處理器適配器向前端控制器返回ModelAndView

第八步：前端控制器請求視圖解析器（ViewResolver）去進行視圖解析

第九步：視圖解析器像前端控制器返回View

第十步：前端控制器對視圖進行渲染

第十一步：前端控制器向用戶響應結果

看到這些步驟我相信你們很感受很是的亂，這是正常的，可是這裏主要是要你們理解springMVC中的幾個組件：

前端控制器（DispatcherServlet）：接收請求，響應結果，至關於電腦的CPU。

處理器映射器（HandlerMapping）：根據URL去查找處理器

處理器（Handler）：（須要程序員去寫代碼處理邏輯的）

處理器適配器（HandlerAdapter）：會把處理器包裝成適配器，這樣就能夠支持多種類型的處理器，類比筆記本的適配器（適配器模式的應用）

視圖解析器（ViewResovler）：進行視圖解析，多返回的字符串，進行處理，能夠解析成對應的頁面

SpringMVC實現原理及詳解

2018年05月24日 11:16:14 yanweihpu 閱讀數：28995

一、Spring mvc介紹

SpringMVC框架是以請求爲驅動，圍繞Servlet設計，將請求發給控制器，而後經過模型對象，分派器來展現請求結果視圖。其中核心類是DispatcherServlet，它是一個Servlet，頂層是實現的Servlet接口。

二、SpringMVC使用

須要在web.xml中配置DispatcherServlet。而且須要配置spring監聽器ContextLoaderListener

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring/springmvc-servlet.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>

三、SpringMVC運行原理

如圖所示：

流程說明：

（1）客戶端（瀏覽器）發送請求，直接請求到DispatcherServlet。

（2）DispatcherServlet根據請求信息調用HandlerMapping，解析請求對應的Handler。

（3）解析到對應的Handler後，開始由HandlerAdapter適配器處理。

（4）HandlerAdapter會根據Handler來調用真正的處理器開處理請求，並處理相應的業務邏輯。

（5）處理器處理完業務後，會返回一個ModelAndView對象，Model是返回的數據對象，View是個邏輯上的View。

（6）ViewResolver會根據邏輯View查找實際的View。

（7）DispaterServlet把返回的Model傳給View。

（8）經過View返回給請求者（瀏覽器）

四、DispatcherServlet詳細解析

首先看下源碼：

package org.springframework.web.servlet;
@SuppressWarnings("serial")
public class DispatcherServlet extends FrameworkServlet {
public static final String MULTIPART_RESOLVER_BEAN_NAME = "multipartResolver";
public static final String LOCALE_RESOLVER_BEAN_NAME = "localeResolver";
public static final String THEME_RESOLVER_BEAN_NAME = "themeResolver";
public static final String HANDLER_MAPPING_BEAN_NAME = "handlerMapping";
public static final String HANDLER_ADAPTER_BEAN_NAME = "handlerAdapter";
public static final String HANDLER_EXCEPTION_RESOLVER_BEAN_NAME = "handlerExceptionResolver";
public static final String REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME = "viewNameTranslator";
public static final String VIEW_RESOLVER_BEAN_NAME = "viewResolver";
public static final String FLASH_MAP_MANAGER_BEAN_NAME = "flashMapManager";
public static final String WEB_APPLICATION_CONTEXT_ATTRIBUTE = DispatcherServlet.class.getName() + ".CONTEXT";
public static final String LOCALE_RESOLVER_ATTRIBUTE = DispatcherServlet.class.getName() + ".LOCALE_RESOLVER";
public static final String THEME_RESOLVER_ATTRIBUTE = DispatcherServlet.class.getName() + ".THEME_RESOLVER";
public static final String THEME_SOURCE_ATTRIBUTE = DispatcherServlet.class.getName() + ".THEME_SOURCE";
public static final String INPUT_FLASH_MAP_ATTRIBUTE = DispatcherServlet.class.getName() + ".INPUT_FLASH_MAP";
public static final String OUTPUT_FLASH_MAP_ATTRIBUTE = DispatcherServlet.class.getName() + ".OUTPUT_FLASH_MAP";
public static final String FLASH_MAP_MANAGER_ATTRIBUTE = DispatcherServlet.class.getName() + ".FLASH_MAP_MANAGER";
public static final String EXCEPTION_ATTRIBUTE = DispatcherServlet.class.getName() + ".EXCEPTION";
public static final String PAGE_NOT_FOUND_LOG_CATEGORY = "org.springframework.web.servlet.PageNotFound";
private static final String DEFAULT_STRATEGIES_PATH = "DispatcherServlet.properties";
protected static final Log pageNotFoundLogger = LogFactory.getLog(PAGE_NOT_FOUND_LOG_CATEGORY);
private static final Properties defaultStrategies;
static {
try {
ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
}
catch (IOException ex) {
throw new IllegalStateException("Could not load 'DispatcherServlet.properties': " + ex.getMessage());
}
}
/** Detect all HandlerMappings or just expect "handlerMapping" bean? */
private boolean detectAllHandlerMappings = true;
/** Detect all HandlerAdapters or just expect "handlerAdapter" bean? */
private boolean detectAllHandlerAdapters = true;
/** Detect all HandlerExceptionResolvers or just expect "handlerExceptionResolver" bean? */
private boolean detectAllHandlerExceptionResolvers = true;
/** Detect all ViewResolvers or just expect "viewResolver" bean? */
private boolean detectAllViewResolvers = true;
/** Throw a NoHandlerFoundException if no Handler was found to process this request? **/
private boolean throwExceptionIfNoHandlerFound = false;
/** Perform cleanup of request attributes after include request? */
private boolean cleanupAfterInclude = true;
/** MultipartResolver used by this servlet */
private MultipartResolver multipartResolver;
/** LocaleResolver used by this servlet */
private LocaleResolver localeResolver;
/** ThemeResolver used by this servlet */
private ThemeResolver themeResolver;
/** List of HandlerMappings used by this servlet */
private List<HandlerMapping> handlerMappings;
/** List of HandlerAdapters used by this servlet */
private List<HandlerAdapter> handlerAdapters;
/** List of HandlerExceptionResolvers used by this servlet */
private List<HandlerExceptionResolver> handlerExceptionResolvers;
/** RequestToViewNameTranslator used by this servlet */
private RequestToViewNameTranslator viewNameTranslator;
private FlashMapManager flashMapManager;
/** List of ViewResolvers used by this servlet */
private List<ViewResolver> viewResolvers;
public DispatcherServlet() {
super();
}
public DispatcherServlet(WebApplicationContext webApplicationContext) {
super(webApplicationContext);
}
@Override
protected void onRefresh(ApplicationContext context) {
initStrategies(context);
}
protected void initStrategies(ApplicationContext context) {
initMultipartResolver(context);
initLocaleResolver(context);
initThemeResolver(context);
initHandlerMappings(context);
initHandlerAdapters(context);
initHandlerExceptionResolvers(context);
initRequestToViewNameTranslator(context);
initViewResolvers(context);
initFlashMapManager(context);
}
}