spring源碼分析（七）
目錄
五、源碼分析
--5.8 Spring MVC 框架設計原理
----5.8.1 SpringMVC 請求處理流程
----5.8.2 SpringMVC 的工作機制
----5.8.3 SpringMVC 源碼分析
------第一步、建立 Map<urls,controller>的關系
------第二步、根據(jù)訪問 url 找到對應的 controller 中處理請求的方法
------第三步、反射調用處理請求的方法，返回結果視圖
----5.8.4 談談 SpringMVC 的優(yōu)化
五、源碼分析
5.8 Spring MVC 框架設計原理
5.8.1 SpringMVC 請求處理流程
引用 springinaction 上的一張圖來說明了 springmvc 的核心組件和請求處理流程:
①：DispatcherServlet 是 springmvc 中的前端控制器(frontcontroller),負責接收 request 并將 request 轉發(fā)給對應的處理組件.
②：HanlerMapping 是 springmvc 中完成 url 到 controller 映射的組件.DispatcherServlet 接收 request, 然后從 HandlerMapping 查找處理 request 的 controller.
③：Cntroller 處理 request,并返回 ModelAndView 對象,Controller 是 springmvc 中負責處理 request 的組件(類似于 struts2 中的 Action),ModelAndView 是封裝結果視圖的組件.
④⑤⑥：視圖解析器解析 ModelAndView 對象并返回對應的視圖給客戶端.
5.8.2 SpringMVC 的工作機制
在容器初始化時會建立所有url和controller的對應關系,保存到Map<url,controller>中.tomcat啟動時 會通知spring初始化容器(加載bean的定義信息和初始化所有單例bean),然后springmvc會遍歷容器中的 bean,獲取每一個 controller 中的所有方法訪問的 url,然后將 url 和 controller 保存到一個 Map 中;
這樣就可以根據(jù) request 快速定位到 controller,因為最終處理 request 的是 controller 中的方法,Map 中只保留了 url 和 controller 中的對應關系,所以要根據(jù) request 的 url 進一步確認 controller 中的 method, 這一步工作的原理就是拼接 controller 的 url(controller 上@RequestMapping 的值)和方法的 url(method 上 @RequestMapping 的值),與 request 的 url 進行匹配,找到匹配的那個方法;
確定處理請求的method后,接下來的任務就是參數(shù)綁定,把request中參數(shù)綁定到方法的形式參數(shù)上, 這一步是整個請求處理過程中最復雜的一個步驟。springmvc 提供了兩種 request 參數(shù)與方法形參的綁定 方法:
① 通過注解進行綁定,@RequestParam
② 通過參數(shù)名稱進行綁定.
使用注解進行綁定,我們只要在方法參數(shù)前面聲明@RequestParam("a"),就可以將 request 中參數(shù) a 的 值綁定到方法的該參數(shù)上.使用參數(shù)名稱進行綁定的前提是必須要獲取方法中參數(shù)的名稱,Java 反射只提 供了獲取方法的參數(shù)的類型,并沒有提供獲取參數(shù)名稱的方法.springmvc解決這個問題的方法是用asm框 架讀取字節(jié)碼文件,來獲取方法的參數(shù)名稱.asm 框架是一個字節(jié)碼操作框架,關于 asm 更多介紹可以參考 它的官網.個人建議,使用注解來完成參數(shù)綁定,這樣就可以省去 asm 框架的讀取字節(jié)碼的操作.
5.8.3 SpringMVC 源碼分析
我們根據(jù)工作機制中三部分來分析 springmvc 的源代碼.
其一,ApplicationContext 初始化時建立所有 url 和 controller 類的對應關系(用 Map 保存);
其二,根據(jù)請求 url 找到對應的 controller,并從 controller 中找到處理請求的方法;
其三,request 參數(shù)綁定到方法的形參,執(zhí)行方法處理請求,并返回結果視圖.
第一步、建立 Map<urls,controller>的關系
我們首先看第一個步驟,也就是建立 Map<url,controller>關系的部分.第一部分的入口類為 ApplicationObjectSupport 的 setApplicationContext 方法.setApplicationContext 方法中核心部分就是初始化 容器 initApplicationContext(context),子類 AbstractDetectingUrlHandlerMapping 實現(xiàn)了該方法,所以我們直 接看子類中的初始化容器方法.
public void initApplicationContext() throws ApplicationContextException {
super.initApplicationContext();
detectHandlers();
}
/**
* 建立當前ApplicationContext中的所有controller和url的對應關系
*/
protected void detectHandlers() throws BeansException {
if (logger.isDebugEnabled()) {
logger.debug("Looking for URL mappings in application context: " + getApplicationContext());
}
// 獲取ApplicationContext容器中所有bean的Name
String[] beanNames = (this.detectHandlersInAncestorContexts ?
BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
getApplicationContext().getBeanNamesForType(Object.class));
// 遍歷beanNames,并找到這些bean對應的url
for (String beanName : beanNames) {
// 找bean上的所有url(controller上的url+方法上的url),該方法由對應的子類實現(xiàn)
String[] urls = determineUrlsForHandler(beanName);
if (!ObjectUtils.isEmpty(urls)) {
// 保存urls和beanName的對應關系,put it to Map<urls,beanName>,該方法在父類
AbstractUrlHandlerMapping中實現(xiàn)
registerHandler(urls, beanName);
}else {
if (logger.isDebugEnabled()) {
logger.debug("Rejected bean name '" + beanName + "': no URL paths identified");
}
}
}
}
/** 獲取controller中所有方法的url,由子類實現(xiàn),典型的模板模式 **/
protected abstract String[] determineUrlsForHandler(String beanName);
determineUrlsForHandler(StringbeanName)方法的作用是獲取每個controller中的url,不同的子類有不 同的實現(xiàn),這是一個典型的模板設計模式.因為開發(fā)中我們用的最多的就是用注解來配置 controller 中的 url,DefaultAnnotationHandlerMapping 是 AbstractDetectingUrlHandlerMapping 的子類,處理注解形式的 url 映射.所以我們這里以 DefaultAnnotationHandlerMapping 來進行分析.我們看 DefaultAnnotationHandlerMapping 是如何查 beanName 上所有映射的 url.
/**
* 獲取controller中所有的url
*/
protected String[] determineUrlsForHandler(String beanName) {
// 獲取ApplicationContext容器
ApplicationContext context = getApplicationContext();
//從容器中獲取controller
Class<?> handlerType = context.getType(beanName);
// 獲取controller上的@RequestMapping注解
RequestMapping mapping = context.findAnnotationOnBean(beanName, RequestMapping.class);
if (mapping != null) { // controller上有注解
this.cachedMappings.put(handlerType, mapping);
// 返回結果集
Set<String> urls = new LinkedHashSet<String>();
// controller的映射url
String[] typeLevelPatterns = mapping.value();
if (typeLevelPatterns.length > 0) { // url>0
// 獲取controller中所有方法及方法的映射url
String[] methodLevelPatterns = determineUrlsForHandlerMethods(handlerType, true);
for (String typeLevelPattern : typeLevelPatterns) {
if (!typeLevelPattern.startsWith("/")) {
typeLevelPattern = "/" + typeLevelPattern;
}
boolean hasEmptyMethodLevelMappings = false;
for (String methodLevelPattern : methodLevelPatterns) {
if (methodLevelPattern == null) {
hasEmptyMethodLevelMappings = true;
}
else {
// controller的映射url+方法映射的url
String combinedPattern = getPathMatcher().combine(typeLevelPattern, methodLevelPattern);
// 保存到set集合中
addUrlsForPath(urls, combinedPattern);
}
}
if (hasEmptyMethodLevelMappings ||
org.springframework.web.servlet.mvc.Controller.class.isAssignableFrom(handlerType)){
addUrlsForPath(urls, typeLevelPattern);
}
}
// 以數(shù)組形式返回controller上的所有url
return StringUtils.toStringArray(urls);
}else {
// controller上的@RequestMapping映射url為空串,直接找方法的映射url
return determineUrlsForHandlerMethods(handlerType, false);
}
} // controller上沒@RequestMapping注解
else if (AnnotationUtils.findAnnotation(handlerType, Controller.class) != null) {
// 獲取controller中方法上的映射url
return determineUrlsForHandlerMethods(handlerType, false);
}else {
return null;
}
}
到這里 HandlerMapping 組件就已經建立所有 url 和 controller 的對應關系
第二步、根據(jù)訪問 url 找到對應的 controller 中處理請求的方法
下面我們開始分析第二個步驟,第二個步驟是由請求觸發(fā)的,所以入口為 DispatcherServlet 的核心方法為 doService(),doService()中的核心邏輯由 doDispatch()實現(xiàn),我們查看 doDispatch()的源代碼.
/** 中央控制器,控制請求的轉發(fā) **/
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
HttpServletRequest processedRequest = request;
HandlerExecutionChain mappedHandler = null;
int interceptorIndex = -1;
try {
ModelAndView mv;
boolean errorView = false;
// 1.檢查是否是文件上傳的請求
processedRequest = checkMultipart(request);
// 2.取得處理當前請求的controller,這里也稱為hanlder,處理器,第一個步驟的意義就在這里體現(xiàn)了.這里并
不是直接返回controller,而是返回的HandlerExecutionChain請求處理器鏈對象,該對象封裝了handler和interceptors. mappedHandler = getHandler(processedRequest, false);
// 如果handler為空,則返回404
if (mappedHandler == null || mappedHandler.getHandler() == null) {
noHandlerFound(processedRequest, response);
return;
}
//3. 獲取處理request的處理器適配器handler adapter
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
// 處理 last-modified 請求頭
String method = request.getMethod();
boolean isGet = "GET".equals(method);
if (isGet || "HEAD".equals(method)) {
long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
if (logger.isDebugEnabled()) {
String requestUri = urlPathHelper.getRequestUri(request);
logger.debug("Last-Modified value for [" + requestUri + "] is: " +
lastModified);
}
if (new ServletWebRequest(request, response).checkNotModified(lastModified)
&& isGet) {
return;
}
}
// 4.攔截器的預處理方法
HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
if (interceptors != null) {
for (int i = 0; i < interceptors.length; i++) {
HandlerInterceptor interceptor = interceptors[i];
if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())){
triggerAfterCompletion(mappedHandler, interceptorIndex,
processedRequest, response, null);
return;
}
interceptorIndex = i;
}
}
// 5.實際的處理器處理請求,返回結果視圖對象
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
// 結果視圖對象的處理
if (mv != null && !mv.hasView()) {
mv.setViewName(getDefaultViewName(request));
}
// 6.攔截器的后處理方法
if (interceptors != null) {
for (int i = interceptors.length - 1; i >= 0; i--) {
HandlerInterceptor interceptor = interceptors[i];
interceptor.postHandle(processedRequest, response,
mappedHandler.getHandler(), mv);
}
}
}catch (ModelAndViewDefiningException ex) {
logger.debug("ModelAndViewDefiningException encountered", ex);
mv = ex.getModelAndView();
}catch (Exception ex) {
Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
mv = processHandlerException(processedRequest, response, handler, ex);
errorView = (mv != null);
}
if (mv != null && !mv.wasCleared()) {
render(mv, processedRequest, response);
if (errorView) {
WebUtils.clearErrorRequestAttributes(request);
}
}else {
if (logger.isDebugEnabled()) {
logger.debug("Null ModelAndView returned to DispatcherServlet with name '" +
getServletName() +
"': assuming HandlerAdapter completed request handling");
}
}
// 請求成功響應之后的方法
triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
}
第 2 步:getHandler(processedRequest)方法實際上就是從 HandlerMapping 中找到 url 和 controller 的 對應關系.這也就是第一個步驟:建立 Map<url,Controller>的意義.我們知道,最終處理 request 的是 controller中的方法,我們現(xiàn)在只是知道了controller,還要進一步確認controller中處理request的方法.由于 下面的步驟和第三個步驟關系更加緊密,直接轉到第三個步驟.
第三步、反射調用處理請求的方法，返回結果視圖
上面的方法中,第2步其實就是從第一個步驟中的Map<urls,beanName>中取得controller,然后經過攔截器 的預處理方法,到最核心的部分--第 5 步調用 controller 的方法處理請求.在第 2 步中我們可以知道處理 request的controller,第5步就是要根據(jù)url確定controller中處理請求的方法,然后通過反射獲取該方法上 的注解和參數(shù),解析方法和參數(shù)上的注解,最后反射調用方法獲取 ModelAndView 結果視圖。因為上面采用 注解 url 形式說明的,所以我們這里繼續(xù)以注解處理器適配器來說明.第 5 步調用的就是 AnnotationMethodHandlerAdapter 的 handle().handle()中的核心邏輯由 invokeHandlerMethod(request, response,handler)實現(xiàn)。
/** 獲取處理請求的方法,執(zhí)行并返回結果視圖 **/
protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
// 1.獲取方法解析器
ServletHandlerMethodResolver methodResolver = getMethodResolver(handler);
// 2.解析request中的url,獲取處理request的方法
Method handlerMethod = methodResolver.resolveHandlerMethod(request);
// 3.方法調用器
ServletHandlerMethodInvoker methodInvoker = new ServletHandlerMethodInvoker(methodResolver);
ServletWebRequest webRequest = new ServletWebRequest(request, response);
ExtendedModelMap implicitModel = new BindingAwareModelMap();
// 4.執(zhí)行方法
Object result = methodInvoker.invokeHandlerMethod(handlerMethod, handler, webRequest, implicitModel);
// 5.封裝結果視圖
ModelAndView mav = methodInvoker.getModelAndView(handlerMethod, handler.getClass(), result, implicitModel, webRequest);
methodInvoker.updateModelAttributes(handler, (mav != null ? mav.getModel() : null), implicitModel, webRequest);
return mav;
}
這一部分的核心就在 2 和 4 了.先看第 2 步,通過 request 找 controller 的處理方法.實際上就是拼接 controller 的 url 和方法的 url,與 request 的 url 進行匹配,找到匹配的方法.
/** 根據(jù)url獲取處理請求的方法 **/
public Method resolveHandlerMethod(HttpServletRequest request) throws ServletException {
// 如果請求url為,localhost:8080/springmvc/helloWorldController/say.action, 則lookupPath=helloWorldController/say.action
String lookupPath = urlPathHelper.getLookupPathForRequest(request);
Comparator<String> pathComparator = pathMatcher.getPatternComparator(lookupPath);
Map<RequestSpecificMappingInfo, Method> targetHandlerMethods = new LinkedHashMap<RequestSpecificMappingInfo, Method>();
Set<String> allowedMethods = new LinkedHashSet<String>(7);
String resolvedMethodName = null;
// 遍歷controller上的所有方法,獲取url匹配的方法
for (Method handlerMethod : getHandlerMethods()) {
RequestSpecificMappingInfo mappingInfo = new
RequestSpecificMappingInfo(this.mappings.get(handlerMethod));
boolean match = false;
if (mappingInfo.hasPatterns()) {// 獲取方法上的url
for (String pattern : mappingInfo.getPatterns()) { // 方法上可能有多個url,springmvc支持方法映射多個url
if (!hasTypeLevelMapping() && !pattern.startsWith("/")) {
pattern = "/" + pattern;
}
// 獲取controller上的映射和url和方法上的url,拼湊起來與lookupPath是否匹配
String combinedPattern = getCombinedPattern(pattern, lookupPath, request);
if (combinedPattern != null) {
if (mappingInfo.matches(request)) {
match = true;
mappingInfo.addMatchedPattern(combinedPattern);
}else {
if (!mappingInfo.matchesRequestMethod(request)) {
allowedMethods.addAll(mappingInfo.methodNames());
}
break;
}
}
}
mappingInfo.sortMatchedPatterns(pathComparator);
}else if (useTypeLevelMapping(request)) {
// other
}
通過上面的代碼,已經可以找到處理 request 的 controller 中的方法了,現(xiàn)在看如何解析該方法上的參數(shù),并調用該方法。也就是執(zhí)行方法這一步.執(zhí)行方法這一步最重要的就是獲取方法的參數(shù),然后我們就可以反射調用方法了
public final Object invokeHandlerMethod(Method handlerMethod, Object handler, NativeWebRequest webRequest, ExtendedModelMap implicitModel) throws Exception {
Method handlerMethodToInvoke = BridgeMethodResolver.findBridgedMethod(handlerMethod);
try {
boolean debug = logger.isDebugEnabled();
// 處理方法上的其他注解
for (String attrName : this.methodResolver.getActualSessionAttributeNames()) {
Object attrValue = this.sessionAttributeStore.retrieveAttribute(webRequest,
attrName);
if (attrValue != null) {
implicitModel.addAttribute(attrName, attrValue);
}
}
for (Method attributeMethod : this.methodResolver.getModelAttributeMethods()) {
Method attributeMethodToInvoke =
BridgeMethodResolver.findBridgedMethod(attributeMethod);
Object[] args = resolveHandlerArguments(attributeMethodToInvoke, handler, webRequest, implicitModel);
if (debug) {
logger.debug("Invoking model attribute method: " + attributeMethodToInvoke);
}
String attrName = AnnotationUtils.findAnnotation(attributeMethod, ModelAttribute.class).value();
if (!"".equals(attrName) && implicitModel.containsAttribute(attrName)) {
continue;
}
ReflectionUtils.makeAccessible(attributeMethodToInvoke);
Object attrValue = attributeMethodToInvoke.invoke(handler, args);
if ("".equals(attrName)) {
Class resolvedType = GenericTypeResolver.resolveReturnType(attributeMethodToInvoke, handler.getClass());
attrName = Conventions.getVariableNameForReturnType(attributeMethodToInvoke, resolvedType, attrValue);
}
if (!implicitModel.containsAttribute(attrName)) {
implicitModel.addAttribute(attrName, attrValue);
}
}
// 核心代碼,獲取方法上的參數(shù)值
Object[] args = resolveHandlerArguments(handlerMethodToInvoke, handler, webRequest, implicitModel);
if (debug) {
logger.debug("Invoking request handler method: " + handlerMethodToInvoke);
}
ReflectionUtils.makeAccessible(handlerMethodToInvoke);
return handlerMethodToInvoke.invoke(handler, args);
}
resolveHandlerArguments方法實現(xiàn)代碼比較長,它最終要實現(xiàn)的目的就是:完成request中的參數(shù)和方法參 數(shù)上數(shù)據(jù)的綁定.
springmvc 中提供兩種 request 參數(shù)到方法中參數(shù)的綁定方式:
① 通過注解進行綁定,@RequestParam
② 通過參數(shù)名稱進行綁定.
使用注解進行綁定,我們只要在方法參數(shù)前面聲明@RequestParam("a"),就可以將 request 中參數(shù) a 的 值綁定到方法的該參數(shù)上.使用參數(shù)名稱進行綁定的前提是必須要獲取方法中參數(shù)的名稱,Java 反射只提供了獲取方法的參數(shù)的類型,并沒有提供獲取參數(shù)名稱的方法.springmvc解決這個問題的方法是用asm框 架讀取字節(jié)碼文件,來獲取方法的參數(shù)名稱.asm 框架是一個字節(jié)碼操作框架,關于 asm 更多介紹可以參考 它的官網.個人建議,使用注解來完成參數(shù)綁定,這樣就可以省去 asm 框架的讀取字節(jié)碼的操作.
private Object[] resolveHandlerArguments(Method handlerMethod, Object handler, NativeWebRequest webRequest, ExtendedModelMap implicitModel) throws Exception {
// 1.獲取方法參數(shù)類型的數(shù)組
Class[] paramTypes = handlerMethod.getParameterTypes();
// 聲明數(shù)組,存參數(shù)的值
Object[] args = new Object[paramTypes.length];
//2.遍歷參數(shù)數(shù)組,獲取每個參數(shù)的值
for (int i = 0; i < args.length; i++) {
MethodParameter methodParam = new MethodParameter(handlerMethod, i);
methodParam.initParameterNameDiscovery(this.parameterNameDiscoverer);
GenericTypeResolver.resolveParameterType(methodParam, handler.getClass());
String paramName = null;
String headerName = null;
boolean requestBodyFound = false;
String cookieName = null;
String pathVarName = null;
String attrName = null;
boolean required = false;
String defaultValue = null;
boolean validate = false;
int annotationsFound = 0;
Annotation[] paramAnns = methodParam.getParameterAnnotations();
// 處理參數(shù)上的注解
for (Annotation paramAnn : paramAnns) {
if (RequestParam.class.isInstance(paramAnn)) {
RequestParam requestParam = (RequestParam) paramAnn;
paramName = requestParam.value();
required = requestParam.required();
defaultValue = parseDefaultValueAttribute(requestParam.defaultValue());
annotationsFound++;
}
else if (RequestHeader.class.isInstance(paramAnn)) {
RequestHeader requestHeader = (RequestHeader) paramAnn;
headerName = requestHeader.value();
required = requestHeader.required();
defaultValue = parseDefaultValueAttribute(requestHeader.defaultValue());
annotationsFound++;
}
else if (RequestBody.class.isInstance(paramAnn)) {
requestBodyFound = true;
annotationsFound++;
}
else if (CookieValue.class.isInstance(paramAnn)) {
CookieValue cookieValue = (CookieValue) paramAnn;
cookieName = cookieValue.value();
required = cookieValue.required();
defaultValue = parseDefaultValueAttribute(cookieValue.defaultValue());
annotationsFound++;
}
else if (PathVariable.class.isInstance(paramAnn)) {
PathVariable pathVar = (PathVariable) paramAnn;
pathVarName = pathVar.value();
annotationsFound++;
}
else if (ModelAttribute.class.isInstance(paramAnn)) {
ModelAttribute attr = (ModelAttribute) paramAnn;
attrName = attr.value();
annotationsFound++;
}
else if (Value.class.isInstance(paramAnn)) {
defaultValue = ((Value) paramAnn).value();
}
else if ("Valid".equals(paramAnn.annotationType().getSimpleName())) {
validate = true;
}
}
if (annotationsFound > 1) {
throw new IllegalStateException("Handler parameter annotations are exclusive choices - " + "do not specify more than one such annotation on the same parameter: " +
handlerMethod);
}
if (annotationsFound == 0) {// 如果沒有注解
Object argValue = resolveCommonArgument(methodParam, webRequest);
if (argValue != WebArgumentResolver.UNRESOLVED) {
args[i] = argValue;
}
else if (defaultValue != null) {
args[i] = resolveDefaultValue(defaultValue);
}
else {
Class paramType = methodParam.getParameterType();
// 將方法聲明中的Map和Model參數(shù),放到request中,用于將數(shù)據(jù)放到request中帶回頁面
if (Model.class.isAssignableFrom(paramType) ||
Map.class.isAssignableFrom(paramType)){
args[i] = implicitModel;
}else if (SessionStatus.class.isAssignableFrom(paramType)) {
args[i] = this.sessionStatus;
}else if (HttpEntity.class.isAssignableFrom(paramType)) {
args[i] = resolveHttpEntityRequest(methodParam, webRequest);
}else if (Errors.class.isAssignableFrom(paramType)) {
throw new IllegalStateException("Errors/BindingResult argument declared " +
"without preceding model attribute. Check your handler method signature!");
}else if (BeanUtils.isSimpleProperty(paramType)) {
paramName = "";
}else {
attrName = "";
}
}
}
// 從request中取值,并進行賦值操作
if (paramName != null) {
// 根據(jù)paramName從request中取值,如果沒有通過RequestParam注解指定paramName,則使用asm讀取class文件來獲取paramName
args[i] = resolveRequestParam(paramName, required, defaultValue, methodParam, webRequest, handler);
}else if (headerName != null) {
args[i] = resolveRequestHeader(headerName, required, defaultValue, methodParam, webRequest, handler);
}else if (requestBodyFound) {
args[i] = resolveRequestBody(methodParam, webRequest, handler);
}else if (cookieName != null) {
args[i] = resolveCookieValue(cookieName, required, defaultValue, methodParam, webRequest, handler);
}else if (pathVarName != null) {
args[i] = resolvePathVariable(pathVarName, methodParam, webRequest, handler);
}
else if (attrName != null) {
WebDataBinder binder =
resolveModelAttribute(attrName, methodParam, implicitModel, webRequest, handler);
boolean assignBindingResult = (args.length > i + 1 &&
Errors.class.isAssignableFrom(paramTypes[i + 1]));
if (binder.getTarget() != null) {
doBind(binder, webRequest, validate, !assignBindingResult);
}
args[i] = binder.getTarget();
if (assignBindingResult) {
args[i + 1] = binder.getBindingResult();
i++;
}
implicitModel.putAll(binder.getBindingResult().getModel());
}
}
// 返回參數(shù)值數(shù)組
return args;
}
關于 asm 框架獲取方法參數(shù)的部分,這里就不再進行分析了.感興趣的話自己去就能看到這個過程.
到這里,方法的參數(shù)值列表也獲取到了,就可以直接進行方法的調用了.整個請求過程中最復雜的一步 就是在這里了.ok,到這里整個請求處理過程的關鍵步驟都分析完了.理解了 springmvc 中的請求處理流程, 整個代碼還是比較清晰的.
5.8.4 談談 SpringMVC 的優(yōu)化
上面我們已經對 springmvc 的工作原理和源碼進行了分析,在這個過程發(fā)現(xiàn)了幾個優(yōu)化點:
1.controller如果能保持單例,盡量使用單例,這樣可以減少創(chuàng)建對象和回收對象的開銷.也就是說,如果 controller 的類變量和實例變量可以以方法形參聲明的盡量以方法的形參聲明,不要以類變量和實例變量 聲明,這樣可以避免線程安全問題.
2.處理 request 的方法中的形參務必加上@RequestParam 注解,這樣可以避免 springmvc 使用 asm 框 架讀取 class 文件獲取方法參數(shù)名的過程.即便 springmvc 對讀取出的方法參數(shù)名進行了緩存,如果不要讀 取 class 文件當然是更加好.
3.閱讀源碼的過程中,發(fā)現(xiàn) springmvc 并沒有對處理 url 的方法進行緩存,也就是說每次都要根據(jù)請求 url 去匹配 controller 中的方法 url,如果把 url 和 method 的關系緩存起來,會不會帶來性能上的提升呢?有 點惡心的是,負責解析 url 和 method 對應關系的 ServletHandlerMethodResolver 是一個 private 的內部類, 不能直接繼承該類增強代碼,必須要該代碼后重新編譯.當然,如果緩存起來,必須要考慮緩存的線程安全 問題.
