springmvc⼯作原理和源码分析
springmvc⼯作原理以及源码分析(基于spring3.1.0)
springmvc是⼀个基于spring的web框架.本篇⽂章对它的⼯作原理以及源码进⾏深⼊分析.
⼀、springmvc请求处理流程
⼆、springmvc的⼯作机制
三、springmvc核⼼源码分析
四、谈谈springmvc的优化
⼀、springmvc请求处理流程
引⽤spring in action上的⼀张图来说明了springmvc的核⼼组件和请求处理流程:
①：DispatcherServlet是springmvc中的前端控制器(front controller)，负责接收request并将request转发给对应的处理组件.
②：HanlerMapping是springmvc中完成url到controller映射的组件.DispatcherServlet接收request，然后从HandlerMapping查处理request的controller.
③：Cntroller处理request，并返回ModelAndView对象,Controller是springmvc中负责处理request的组
件(类似于struts2中的Action),ModelAndView是封装结果视图的组件.
④⑤⑥：视图解析器解析ModelAndView对象并返回对应的视图给客户端.
⼆、springmvc的⼯作机制
在容器初始化时会建⽴所有url和controller的对应关系，保存到Map<url,controller>中.tomcat启动时会通知spring初始化容器(加载bean的定义信息和初始化所有单例bean)，然后springmvc会遍历容器中的bean，获取每⼀个controller中的所有⽅法访问的url，然后将url和controller保存到⼀个Map中;
这样就可以根据request快速定位到controller，因为最终处理request的是controller中的⽅法,Map中只保留了url和controller中的对应关系，所以要根据request的url进⼀步确认controller中的method，这⼀步⼯作的原理就是拼接controller的url(controller上@RequestMapping的值)和⽅法的url(method上@RequestMapping的值)，与request的url进⾏匹配，到匹配的那个⽅法;
确定处理请求的method后，接下来的任务就是参数绑定，把request中参数绑定到⽅法的形式参数上，这⼀步是整个请求处理过程中最复杂的⼀个步骤。springmvc提供了两种request参数与⽅法形参的绑定⽅法:
①通过注解进⾏绑定,@RequestParam
②通过参数名称进⾏绑定.
使⽤注解进⾏绑定，我们只要在⽅法参数前⾯声明@RequestParam("a")，就可以将request中参数a的值绑定到⽅法的该参数上.使⽤参数名称进⾏绑定的前提是必须要获取⽅法中参数的名称,Java反射只提供了获取⽅法的参数的类型，并没有提供获取参数名称的⽅法.springmvc解决这个问题的⽅法是⽤asm框架读取字节码⽂件，来获取⽅法的参数名称.asm框架是⼀个字节码操作框架，关于asm更多介绍可以参考它的官⽹.个⼈建议，使⽤注解来完成参数绑定，这样就可以省去asm框架的读取字节码的操作.
三、源代码的分析
我们根据⼯作机制中三部分来分析springmvc的源代码.
其⼀,ApplicationContext初始化时建⽴所有url和controller类的对应关系(⽤Map保存);
其⼆，根据请求url到对应的controller，并从controller中到处理请求的⽅法;
其三,request参数绑定到⽅法的形参，执⾏⽅法处理请求，并返回结果视图.
第⼀步、建⽴Map<urls,controller>的关系
我们⾸先看第⼀个步骤，也就是建⽴Map<url,controller>关系的部分.第⼀部分的⼊⼝类为ApplicationObjectSupport的setApplicationContext⽅法.setApplicationContext⽅法中核⼼部分就是初始化容器initApplicationContext(context),⼦类AbstractDetectingUrlHandlerMapping实现了该⽅法，所以我们直接看⼦类中的初始化容器⽅法.
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)，该⽅法由对应的⼦类实现
String[] urls = determineUrlsForHandler(beanName);
if (!ObjectUtils.isEmpty(urls)) {
// 保存urls和beanName的对应关系,put it to Map<urls,beanName>，该⽅法在⽗类AbstractUrlHandlerMapping中实现
registerHandler(urls, beanName);
}
else {
if (logger.isDebugEnabled()) {
logger.debug("Rejected bean name '" + beanName + "': no URL paths identified");
}
}
}
}
/** 获取controller中所有⽅法的url，由⼦类实现，典型的模板模式 /
protected abstract String[] determineUrlsForHandler(String beanName);
determineUrlsForHandler(String beanName)⽅法的作⽤是获取每个controller中的url，不同的⼦类有不同的实现，这是⼀个典型的模板设计模式.因为开发中我们⽤的最多的就是⽤注解来配置controller中的url,DefaultAnnotationHandlerMapping是AbstractDetectingUrlHandlerMapping的⼦类，处理注解形式的url映射.所以我们这⾥以DefaultAnnotationHandlerMapping来进⾏分析.我们看DefaultAnnotationHandlerMapping是如何查beanName上所有映射的url.
/
* 获取controller中所有的url
*/
protected String[] determineUrlsForHandler(String beanName) {
// 获取ApplicationContext容器
ApplicationContext context = getApplicationContext();
//从容器中获取controller
Class<?> handlerType = Type(beanName);
// 获取controller上的@RequestMapping注解
RequestMapping mapping = context.findAnnotationOnBean(beanName, RequestMapping.class);
if (mapping != null) { // controller上有注解
this.cachedMappings.put(handlerType, mapping);
// 返回结果集
Set urls = new LinkedHashSet();
// 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;
404页面网站源码}
boolean hasEmptyMethodLevelMappings = false;
for (String methodLevelPattern : methodLevelPatterns) {
if (methodLevelPattern == null) {
hasEmptyMethodLevelMappings = true;
}
else {
// controller的映射url+⽅法映射的url
String combinedPattern = getPathMatcher()bine(typeLevelPattern, methodLevelPattern);
// 保存到set集合中
addUrlsForPath(urls, combinedPattern);
}
}
if (hasEmptyMethodLevelMappings ||
org.springframework.web.servlet.mvc.Controller.class.isAssignableFrom(handlerType)) {
addUrlsForPath(urls, typeLevelPattern);
}
}
// 以数组形式返回controller上的所有url
StringArray(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的对应关系。
第⼆步、根据访问url到对应controller中处理请求的⽅法.
下⾯我们开始分析第⼆个步骤，第⼆个步骤是由请求触发的，所以⼊⼝为DispatcherServlet.DispatcherServlet的核⼼⽅法为doService(),doService()中的核⼼逻辑由
doDispatch()实现，我们查看doDispatch()的源代码.
/** 中央控制器，控制请求的转发 **/
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
HttpServletRequest processedRequest = request;
HandlerExecutionChain mappedHandler = null;
int interceptorIndex = -1;
try {
ModelAndView mv;
boolean errorView = false;
try {
// 1.检查是否是⽂件上传的请求
，该对象封 mappedHandler = getHandler(processedRequest, false);
// 如果handler为空，则返回404
if (mappedHandler == null || Handler() == null) {
noHandlerFound(processedRequest, response);
return;
}
//3. 获取处理request的处理器适配器handler adapter
HandlerAdapter ha = Handler());
// 处理 last-modified 请求头
String method = Method();
boolean isGet = "GET".equals(method);
if (isGet || "HEAD".equals(method)) {
long lastModified = ha.getLastModified(request, Handler());
if (logger.isDebugEnabled()) {
String requestUri = RequestUri(request);
logger.debug("Last-Modified value for [" + requestUri + "] is: " + lastModified);
}
if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
return;
}
}
// 4.的预处理⽅法
HandlerInterceptor[] interceptors = Interceptors();
if (interceptors != null) {
for (int i = 0; i < interceptors.length; i++) {
HandlerInterceptor interceptor = interceptors[i];
if (!interceptor.preHandle(processedRequest, response, Handler())) {
triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
return;
}
interceptorIndex = i;
}
}
// 5.实际的处理器处理请求，返回结果视图对象
mv = ha.handle(processedRequest, response, Handler());
/
/ 结果视图对象的处理
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, Handler(), mv);
}
}
}
catch (ModelAndViewDefiningException ex) {
logger.debug("ModelAndViewDefiningException encountered", ex);
mv = ex.getModelAndView();
}
catch (Exception ex) {
Object handler = (mappedHandler != null ? Handler() : 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中的⽅法，我们现在只是知道了controller，还要进⼀步确认controller中处理request的⽅法.由于下⾯的步骤和第三个步骤关系更加紧密，直接转到第三个步骤.
第三步、反射调⽤处理请求的⽅法，返回结果视图
上⾯的⽅法中，第2步其实就是从第⼀个步骤中的Map<urls,beanName>中取得controller，然后经过的预处理⽅法，到最核⼼的部分--第5步调⽤controller的⽅法处理请求.在第2步中我们可以知道处理request的controller，第5步就是要根据url确定controller中处理请求的⽅法，然后通过反射获取该⽅法上的注解和参数，解析⽅法和参数上的注解，最后反射调⽤⽅法获取ModelAndView结果视图。因为上⾯采⽤注解url形式说明的，所以我们这⾥继续以注解处理器适配器来说明.第5步调⽤的就是AnnotationMethodHandlerAdapter的handle().handle()中的核⼼逻辑由invokeHandlerMethod(request, response, handler)实现。
/** 获取处理请求的⽅法，执⾏并返回结果视图 /
protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
// 1.获取⽅法解析器
ServletHandlerMethodResolver methodResolver = getMethodResolver(handler);
// 2.解析request中的url，获取处理request的⽅法
Method handlerMethod = solveHandlerMethod(request);
// 3.⽅法调⽤器
ServletHandlerMethodInvoker methodInvoker = new ServletHandlerMethodInvoker(methodResolver);
ServletWebRequest webRequest = new ServletWebRequest(request, response);
ExtendedModelMap implicitModel = new BindingAwareModelMap();
// 4.执⾏⽅法
Object result = methodInvoker.invokeHandlerMethod(handlerMethod, handler, webRequest, implicitModel);
// 5.封装结果视图
ModelAndView mav =
methodInvoker.updateModelAttributes(handler, (mav != null ? Model() : null), implicitModel, webRequest);
return mav;
}
这⼀部分的核⼼就在2和4了.先看第2步，通过requestcontroller的处理⽅法.实际上就是拼接controller的url和⽅法的url，与request的url进⾏匹配，到匹配的⽅法.
/ 根据url获取处理请求的⽅法 **/
public Method resolveHandlerMethod(HttpServletRequest request) throws ServletException {
// 如果请求url为,localhost:8080/springmvc/helloWorldController/say.action, 则lookupPath=helloWorldController/say.action
String lookupPath = LookupPathForRequest(request);
Comparator pathComparator = PatternComparator(lookupPath);
Map<RequestSpecificMappingInfo, Method> targetHandlerMethods = new LinkedHashMap<RequestSpecificMappingInfo, Method>();
Set allowedMethods = new LinkedHashSet(7);
String resolvedMethodName = null;
// 遍历controller上的所有⽅法，获取url匹配的⽅法
for (Method handlerMethod : getHandlerMethods()) {
RequestSpecificMappingInfo mappingInfo = new RequestSpecificMappingInfo((handlerMethod));
boolean match = false;
if (mappingInfo.hasPatterns()) {// 获取⽅法上的url
for (String pattern : Patterns()) { // ⽅法上可能有多个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.hodNames());
}
break;
}
}
}
mappingInfo.sortMatchedPatterns(pathComparator);
}
else if (useTypeLevelMapping(request)) {
// other
}
通过上⾯的代码，已经可以到处理request的controller中的⽅法了，现在看如何解析该⽅法上的参数，并调⽤该⽅法。也就是执⾏⽅法这⼀步.执⾏⽅法这⼀步最重要的就是获取⽅法的参数，然后我们就可以反射调⽤⽅法了.
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 : ActualSessionAttributeNames()) {
Object attrValue = ieveAttribute(webRequest, attrName);
if (attrValue != null) {
implicitModel.addAttribute(attrName, attrValue);
}
}
for (Method attributeMethod : ModelAttributeMethods()) {
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();
发表评论