Flutter網路請求與JSON解析
很多人會用 SpringMVC，但對它的處理請求的方式並不清楚，當我們學習一個知識的時候，瞭解它會讓我們更好地使用它，下面我們來看看 SpringMVC 是如何處理請求的。
請求流程的方式
Spring MVC 框架也是一個基於請求驅動的 Web 框架，並且使用了前端控制器模式（是用來提供一個集中的請求處理機制，所有的請求都將由一個單一的處理程式處理來進行設計，再根據請求對映規則分發給相應的頁面控制器（動作/處理器）進行處理。首先讓我們整體看一下 Spring MVC 處理請求的流程：
首先使用者傳送請求，請求被 SpringMVC前端控制器（DispatherServlet）捕獲；
前端控制器（DispatherServlet）對請求 URL 解析獲取請求 URI，根據 URI，呼叫 HandlerMapping；
前端控制器（DispatherServlet）獲得返回的 HandlerExecutionChain（包括 Handler 物件以及 Handler 物件對應的攔截器）；
DispatcherServlet 根據獲得的 HandlerExecutionChain，選擇一個合適的 HandlerAdapter。（附註：如果成功獲得 HandlerAdapter 後，此時將開始執行攔截器的 preHandler(…) 方法）；
HandlerAdapter 根據請求的 Handler 適配並執行對應的 Handler；HandlerAdapter 提取 Request 中的模型資料，填充 Handler 入參，開始執行 Handler（Controller）。 在填充 Handler 的入參過程中，根據配置，Spring 將做一些額外的工作：
資料轉換：對請求訊息進行資料轉換。如 String 轉換成 Integer、Double 等；
資料格式化：如將字串轉換成格式化數字或格式化日期等；
資料驗證： 驗證資料的有效性（長度、格式等），驗證結果儲存到 BindingResult 或 Error 中）；
Handler 執行完畢，返回一個 ModelAndView （即模型和檢視）給 HandlerAdaptor；
HandlerAdaptor 介面卡將執行結果 ModelAndView 返回給前端控制器；
前端控制器接收到 ModelAndView 後，請求對應的檢視解析器；
檢視解析器解析 ModelAndView 後返回對應 View；
渲染檢視並返回渲染後的檢視給前端控制器；
最終前端控制器將渲染後的頁面響應給使用者或客戶端。
案例實操
SpringMVC 請求執行原始碼解讀
對於 SpringMVC 專案所有的請求入口（靜態資源除外）這裡都是從 web.xml 檔案配置的前端控制器 DispatcherServlet 開始：
這裡關注藍線部分繼承結構：DispatcherServlet–>FrameworkServlet–>HttpServletBean–>HttpServlet–>GenericServlet–>Servlet，對於請求核心時序圖如下：
對於 web 請求的處理，大家都知道是通過繼承 HttpServlet 重寫其 service 方法，這裡開啟 DispatcherServlet 原始碼發現這裡並沒有看到我們要找的 service 方法，此時到父類 FrameworkServlet 查詢如下：可以看到父類重寫 HttpServlet service 方法。
FrameworkServlet#service
/**
-
Override the parent class implementation in order to intercept PATCH requests.
*/
@Override
protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
if (httpMethod == HttpMethod.PATCH || httpMethod == null) {
processRequest(request, response);
}
else {
super.service(request, response);
}
}
複製程式碼
從原始碼分析來看當請求方法為 patch 請求或者為 null 時執行 processRequest0 方法，其他情況則呼叫父類 service 方法，大家都知道 SpringMVC 請求大多請求是 get|post 請求為主，此時繼續向上檢視 FrameworkServlet 父類 HttpServletBean（抽象類繼承 HttpServlet 並未重寫 service 方法，所以向上繼續尋找)–> HttpServlet service 方法：
HttpServlet#service
@Override
public void service(ServletRequest req, ServletResponse res)
throws ServletException, IOException
{
HttpServletRequest request;
HttpServletResponse response;if (!(req instanceof HttpServletRequest && res instanceof HttpServletResponse)) { throw new ServletException("non-HTTP request or response"); } request = (HttpServletRequest) req; response = (HttpServletResponse) res; service(request, response);}
}
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException
{
String method = req.getMethod();
if (method.equals(METHOD_GET)) {
long lastModified = getLastModified(req);
if (lastModified == -1) {
// servlet doesn't support if-modified-since, no reason
// to go through further expensive logic
doGet(req, resp);
} else {
long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
if (ifModifiedSince < lastModified) {
// If the servlet mod time is later, call doGet()
// Round down to the nearest second for a proper compare
// A ifModifiedSince of -1 will always be less
maybeSetLastModified(resp, lastModified);
doGet(req, resp);
} else {
resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
}
}
} else if (method.equals(METHOD_HEAD)) {
long lastModified = getLastModified(req);
maybeSetLastModified(resp, lastModified);
doHead(req, resp);
} else if (method.equals(METHOD_POST)) {
doPost(req, resp);
} else if (method.equals(METHOD_PUT)) {
doPut(req, resp);
} else if (method.equals(METHOD_DELETE)) {
doDelete(req, resp);
} else if (method.equals(METHOD_OPTIONS)) {
doOptions(req,resp);
} else if (method.equals(METHOD_TRACE)) {
doTrace(req,resp);
} else {
//
// Note that this means NO servlet supports whatever
// method was requested, anywhere on this server.
//
String errMsg = lStrings.getString("http.method_not_implemented");
Object[] errArgs = new Object[1];
errArgs[0] = method;
errMsg = MessageFormat.format(errMsg, errArgs);
resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
}
}
複製程式碼
可以看到 HttpServlet service 進行了過載，根據不同的請求型別然後呼叫不同處理方法，這裡以 get 請求為例，當請求方法為 get 請求時在過載 service 方法中呼叫 doGet 方法進行處理，這裡需要特別注意的是：HttpServlet 存在 doGet 方法實現，然而在繼承的子類中也存在 doGet 方法實現，到底呼叫哪個方法？很明顯呼叫子類的 doGet 方法（面向物件多型思想！！！）從繼承 UML 關係圖上看，最外層子類實現 doGet 方法的為 FrameworkServlet ：
FrameworkServlet#doGet&processRequest
@Override
protected final void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
processRequest(request, response);
}
protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// 系統計時開始時間
long startTime = System.currentTimeMillis();
Throwable failureCause = null;
// 國際化
LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
LocaleContext localeContext = buildLocaleContext(request);
//構建ServletRequestAttributes物件
RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);
//非同步管理
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());
//初始化ContextHolders
initContextHolders(request, localeContext, requestAttributes);
try {
doService(request, response);
}
catch (ServletException | IOException ex) {
failureCause = ex;
throw ex;
}
catch (Throwable ex) {
failureCause = ex;
throw new NestedServletException("Request processing failed", ex);
}
finally {
//恢復原來的LocaleContext和ServiceRequestAttributes到LocaleContextHolder和RequestContextHolder，避免影響Servlet以外的處理，如Filter
resetContextHolders(request, previousLocaleContext, previousAttributes);
if (requestAttributes != null) {
requestAttributes.requestCompleted();
}
logResult(request, response, failureCause, asyncManager);
//釋出ServletRequestHandlerEvent訊息，這個請求是否執行成功都會發布訊息的
publishRequestHandledEvent(request, response, startTime, failureCause);
}
}
// initContextHolders(request, localeContext, requestAttributes);
private void initContextHolders(HttpServletRequest request,
@Nullable LocaleContext localeContext, @Nullable RequestAttributes requestAttributes) {
if (localeContext != null) {
LocaleContextHolder.setLocaleContext(localeContext, this.threadContextInheritable);
}
if (requestAttributes != null) {
RequestContextHolder.setRequestAttributes(requestAttributes, this.threadContextInheritable);
}
}
複製程式碼
該方法大概做了這幾件事：國際化的設定，建立 ServletRequestAttributes 物件，初始化上下文 holders （即將 Request 物件放入到執行緒上下文中，如後續想要在方法中獲取 request、response物件此時可以通過呼叫 LocaleContextHolder 對應方法即可），然後呼叫 doService 方法。對於 doService 方法，FrameworkServlet 類並未提供實現，該方法由 DispatcherServlet 子類實現：
DispatcherServlet#doService
DispatcherServlet 裡面執行處理的入口方法是 doService，由於這個類繼承於 FrameworkServlet 類，重寫了 doService() 方法：
@Override
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
logRequest(request);
// Keep a snapshot of the request attributes in case of an include,
// to be able to restore the original attributes after the include.
Map<String, Object> attributesSnapshot = null;
if (WebUtils.isIncludeRequest(request)) {
attributesSnapshot = new HashMap<>();
Enumeration<?> attrNames = request.getAttributeNames();
while (attrNames.hasMoreElements()) {
String attrName = (String) attrNames.nextElement();
if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
attributesSnapshot.put(attrName, request.getAttribute(attrName));
}
}
}
//Spring上下文
request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
//國際化解析器
request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
//主題解析器
request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
//主題
request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());
//重定向的資料
if (this.flashMapManager != null) {
FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
if (inputFlashMap != null) {
request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
}
request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
}
try {
//request設定完相關的屬性做真正的請求處理
doDispatch(request, response);
}
finally {
if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
// Restore the original attribute snapshot, in case of an include.
if (attributesSnapshot != null) {
restoreAttributesAfterInclude(request, attributesSnapshot);
}
}
}
}
複製程式碼
整個方法看下來處理的操作有：處理 include 標籤的請求，將上下文放到 request 的屬性中，將國際化解析器放到 request 的屬性中，將主題解析器放到 request 屬性中，將主題放到 request 的屬性中，處理重定向的請求資料最後呼叫 doDispatch 這個核心的方法對請求進行處理：
DispatcherServlet#doDispatch
該方法是在 doService 方法中呼叫的，從底層設計了整個請求的處理流程：
根據 request 找到 Handler
根據 Handler 找到對應的 HandlerAdapter
用 HandlerAdapter 處理 Handler
呼叫 processDispatchResult 方法處理上面之後的結果（包含View渲染並輸出給使用者）
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
HttpServletRequest processedRequest = request;
HandlerExecutionChain mappedHandler = null;
boolean multipartRequestParsed = false;
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
try {
ModelAndView mv = null;
Exception dispatchException = null;
try {
// 校驗是否為上傳請求 是上傳請求執行解析 否則返回request
processedRequest = checkMultipart(request);
multipartRequestParsed = (processedRequest != request);
// 根據訪問的Handler 返回指定對應的HandlerExecutionChain物件 這裡從HandlerMapping 集合中查詢 HandlerExecutionChain 物件包含Handler與攔截器HandlerInterceptor列表
mappedHandler = getHandler(processedRequest);
if (mappedHandler == null) {
noHandlerFound(processedRequest, response);
return;
}
// 根據得到的Handler 獲取對應的HandlerAdaptor物件
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
// 處理GET、HEAD請求的Last-Modified
String method = request.getMethod();
boolean isGet = "GET".equals(method);
if (isGet || "HEAD".equals(method)) {
long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
//當資料沒有更改時，就直接返回上次的資料，提高效率
if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
return;
}
}
//執行Interceptor的preHandle
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
// 執行Handler 返回ModelAndView
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
//如果需要非同步處理，直接返回
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
//當view為空時，根據request設定預設view，如Handler返回值為void
applyDefaultViewName(processedRequest, mv);
//執行相應Interceptor的postHandle
mappedHandler.applyPostHandle(processedRequest, response, mv);
}
catch (Exception ex) {
dispatchException = ex;
}
catch (Throwable err) {
// As of 4.3, we're processing Errors thrown from handler methods as well,
// making them available for @ExceptionHandler methods and other scenarios.
dispatchException = new NestedServletException("Handler dispatch failed", err);
}
//處理返回結果，包括處理異常、渲染頁面，發出完成通知觸發Interceptor的afterCompletion
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
}
catch (Exception ex) {
triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
}
catch (Throwable err) {
triggerAfterCompletion(processedRequest, response, mappedHandler,
new NestedServletException(“Handler processing failed”, err));
}
finally {
if (asyncManager.isConcurrentHandlingStarted()) {
// Instead of postHandle and afterCompletion
if (mappedHandler != null) {
mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
}
}
else {
// Clean up any resources used by a multipart request.
if (multipartRequestParsed) {
cleanupMultipart(processedRequest);
}
}
}
}
複製程式碼
doDispatcher 首先檢查是不是上傳請求，如果是則將 request 轉換為 MultipartHttpServletRequest，並將 multipartRequestParsed 標誌設定為 true；
通過 getHandler 獲取 Handler 處理器鏈 HandlerExecutionChain；
處理GET、HEAD請求的 Last-Modified，這裡主要判斷 Last-Modified 值是否被修改來處理決定是否採用快取資料；
接下來依次呼叫相應的 Interceptor 的 preHandle，執行攔截器攔截操作；
攔截器 preHandle 方法執行後，此時開始通過 HandlerAdapter 適配對應的 Handler 執行（這裡才是真正要執行的 Controller 方法）， Handler 處理完請求後，如果需要非同步處理則直接返回，如果不需要非同步處理，當 view 為空時，設定預設 view，然後執行相應的 Interceptor 的postHandle。
Handler：處理器，他直接對應著 MVC 中的 C，也就是 Controller 層，它的具體表現形式有很多，可以是類，也可以是方法（通常以方法居多），因為它的定義是 Object，我們在方法中標註的 @RequestMapping 的所有方法都可以看成一個 Handler，只要可以實際處理請求的都可以看成 Handler。
HandlerMapping：用來查詢 Handler，在 SpringMVC 中會處理很多請求，每一個請求都需要一個 Handler 來處理，具體接受到請求後需要哪一個 Handler 來處理，此時通過 HandlerMapping 來實現查詢。
HandlerAdapter：介面卡，不同的 Handler 需要找到不同 HandlerAdapter 來呼叫 Handler。就如工廠裡需要使用工具，工人（HandlerAdapter）使用工具（Handler）完成工作，而 HandlerMapping 用於根據需要完成的工作來找到相應的工具。
DispatcherServlet#processDispatchResult
processDispatchResult 方法主要用來處理前面返回的結果，其中包括處理異常、渲染頁面、觸發 Interceptor 的 afterCompletion 方法三部分內容，處理的異常是在處理請求 doDispatch 方法的過程中產生。
private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
@Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
@Nullable Exception exception) throws Exception {
boolean errorView = false;
// 如果請求過程中有異常丟擲則處理異常
if (exception != null) {
if (exception instanceof ModelAndViewDefiningException) {
logger.debug(“ModelAndViewDefiningException encountered”, exception);
mv = ((ModelAndViewDefiningException) exception).getModelAndView();
}
else {
Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
mv = processHandlerException(request, response, handler, exception);
errorView = (mv != null);
}
}
//執行頁面渲染操作
if (mv != null && !mv.wasCleared()) {
render(mv, request, response);
if (errorView) {
WebUtils.clearErrorRequestAttributes(request);
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace(“No view rendering, null ModelAndView returned.”);
}
}
if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
// Concurrent handling started during a forward
return;
}
// Handler請求處理完，觸發Interceptor的afterCompletion
if (mappedHandler != null) {
// Exception (if any) is already handled…
mappedHandler.triggerAfterCompletion(request, response, null);
}
}
複製程式碼
render 檢視渲染：
protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
// Determine locale for request and apply it to the response.
Locale locale =
(this.localeResolver != null ? this.localeResolver.resolveLocale(request) : request.getLocale());
response.setLocale(locale);
View view;
String viewName = mv.getViewName();
if (viewName != null) {
// We need to resolve the view name.
view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
if (view == null) {
throw new ServletException(“Could not resolve view with name '” + mv.getViewName() +
“’ in servlet with name '” + getServletName() + “’”);
}
}
else {
// No need to lookup: the ModelAndView object contains the actual View object.
view = mv.getView();
if (view == null) {
throw new ServletException(“ModelAndView [” + mv + "] neither contains a view name nor a " +
“View object in servlet with name '” + getServletName() + “’”);
}
}
if (logger.isTraceEnabled()) {
logger.trace(“Rendering view [” + view + "] ");
}
try {
if (mv.getStatus() != null) {
response.setStatus(mv.getStatus().value());
}
// 渲染頁面處理
view.render(mv.getModelInternal(), request, response);
}
catch (Exception ex) {
if (logger.isDebugEnabled()) {
logger.debug(“Error rendering view [” + view + “]”, ex);
}
throw ex;
}
}
複製程式碼
今天我們來了解了一下 SpringMVC 框架中 MVC 核心思想，SpringMVC 內部請求流程分析以及原始碼級別程式碼解讀，讓大家真正能夠從底層級別理解整個框架執行原貌，最後以一張圖來總結今天的原始碼分析執行流程。
擴充套件~MVC
模型-檢視-控制器（MVC）是一個眾所周知的以設計介面應用程式為基礎的設計思想。它主要通過分離模型、檢視及控制器在應用程式中的角色將業務邏輯從介面中解耦。通常，模型負責封裝應用程式資料在檢視層展示。檢視僅僅只是展示這些資料，不包含任何業務邏輯。控制器負責接收來自使用者的請求，並呼叫後臺服務（service或者dao）來處理業務邏輯。處理後，後臺業務層可能會返回了一些資料在檢視層展示。控制器收集這些資料及準備模型在檢視層展示。MVC模式的核心思想是將業務邏輯從介面中分離出來，允許它們單獨改變而不會相互影響。
需領取原始碼文件加【vx: lezijie006】 備註暗號 【B站—123】不加備註會被拒絕的喲～