SpringMVC系列：DispatcherServlet的小秘密

曾经终败给现在 2023-01-14 10:54 131阅读 0赞

### DispatcherServlet详解 ###

*  常规解释
 *   *  DispatcherServlet
     *  HandlerMapping
     *  HandlerAdapter
     *  Handler
     *  ViewResolver
     *  View
 *  源码解析
 *   *  初始化onRefresh
     *  调用
 *  代码演示
 *   *  controller实现方式,目前流程方式
     *  通过实现Controller重写handlerRequest方式
     *  通过实现HttpRequestHandler重写handleRequest方式
     *  配置拦截器
     *  异常处理的方式
     *   *  实现HandlerExceptionResolver接口
         *  通过@ControllerAdvice、 @ExceptionHandler注解
 *  常见面试题
 *   *  1.SpringMVC是什么
     *  2.@ResponseBody的作用
     *  3.Springmvc 怎么样设定重定向和转发的
     *  4.过滤器与拦截器的区别

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI_size_16_color_FFFFFF_t_70]  
代码下载：[https://codechina.csdn.net/ljcc122/cc][https_codechina.csdn.net_ljcc122_cc]

# 常规解释 #

## DispatcherServlet ##

DispatcherServlet 前端控制器框架实现，处理请求处理响应结果。

## HandlerMapping ##

HandlerMapping管理映射器，框架实现，依据请求找到具体Adapter。

## HandlerAdapter ##

HandlerAdapter管理适配器，框架实现，调用具体的Handler(Controller)。

## Handler ##

Handler 后端处理器,由程序员实现。接收用户请求，处理具体业务【MVC-之C】

## ViewResolver ##

ViewResolver 视图解析器，框架实现。

## View ##

View具体视图，程序员实现。将数据展现给用户。

# 源码解析 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI_size_16_color_FFFFFF_t_70 1]

## 初始化onRefresh ##

SpringMVC源码：https://github.com/spring-projects/spring-framework/tags

protected void onRefresh(ApplicationContext context) { 
       this.initStrategies(context);
    }
    //本次仅分析个人认为重点方法
    protected void initStrategies(ApplicationContext context) { 
       	initMultipartResolver(context);
        initLocaleResolver(context);
        initThemeResolver(context);
        //处理器映射器(url和Controller方法的映射)//三大组件HandlerMappings
        initHandlerMappings(context);
        //处理器适配器(实际执行Controller方法)//三大组件HandlerAdapters
        initHandlerAdapters(context);
        //处理器异常解析器
        initHandlerExceptionResolvers(context);
       //RequestToViewName解析器
    	initRequestToViewNameTranslator(context);
    	//视图解析器(视图的匹配和渲染) //三大组件ViewResolvers
    	initViewResolvers(context);
    	initFlashMapManager(context);
    }
    
    //initHandlerAdapters,initViewResolvers,initHandlerExceptionResolvers同理
    private void initHandlerMappings(ApplicationContext context) { 
    	this.handlerMappings = null;
    	if (this.detectAllHandlerMappings) { 
    		// 在ApplicationContext中找到所有HandlerMappings，包括父类上下文。
    		Map<String, HandlerMapping> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
    		if (!matchingBeans.isEmpty()) { 
    			this.handlerMappings = new ArrayList<>(matchingBeans.values());
    			// 我们将HandlerMappings保持在已排序的顺序中
    			AnnotationAwareOrderComparator.sort(this.handlerMappings);
    		}
    	} else { 
    		try { 
    			HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
    			this.handlerMappings = Collections.singletonList(hm);
    		}
    		catch (NoSuchBeanDefinitionException ex) { 
    		}
    	}
    
    	//通过注册确保至少有一个HandlerMapping如果未找到其他映射，则为默认的HandlerMapping。
    	if (this.handlerMappings == null) { 
    		this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
    	}
    	
    	for (HandlerMapping mapping : this.handlerMappings) { 
    		if (mapping.usesPathPatterns()) { 
    			this.parseRequestPath = true;
    			break;
    		}
    	}
    }

## 调用 ##

doGet、doPost、doPost等最终都会调用到doService方法,而doService方法最终调用到doDispathc方法  
![doGet/][doGet]

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 { 
    			processedRequest = checkMultipart(request);
    			multipartRequestParsed = (processedRequest != request);
    			mappedHandler = getHandler(processedRequest);//获取当前请求的处理程序
    			if (mappedHandler == null) { //没有处理器
    				noHandlerFound(processedRequest, response);//返回404或者抛出异常
    				return;
    			}
    			// 获取当前请求的处理程序适配器。
    			HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    			// Process last-modified header, if supported by the handler.
    			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;
    				}
    			}
    			//执行拦截器的PreHandle方法
    			if (!mappedHandler.applyPreHandle(processedRequest, response)) { 
    				return;//拦截器返回false 退出调用
    			}
    			//调用具体的handler即controller业务，包含参数解析
    			mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    			if (asyncManager.isConcurrentHandlingStarted()) { 
    				return;//并发处理
    			}
    			applyDefaultViewName(processedRequest, mv);
    			//执行拦截器PostHandle 方法 可以修改ModelAndView
    			mappedHandler.applyPostHandle(processedRequest, response, mv);
    		}
    		catch (Exception ex) { //记录异常
    			dispatchException = ex;
    		} catch (Throwable err) {  
    			dispatchException = new NestedServletException("Handler dispatch failed", err);
    		}
    		//处理请求的结果 如果有异常，会执行相关异常方法 ，同时也会执行拦截器的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);
    			}
    		}
    	}
    }

# 代码演示 #

## controller实现方式,目前流程方式 ##

@Controller
    @RequestMapping(value = "/user")
    public class UserController { 
        @RequestMapping(value = "/getUserById",produces="text/html;charset=UTF-8;")
        public String getUserById(String userId){ 
            if(userId == null || "".equals(userId)) { 
                System.out.println("缺少用户id，请检查参数！");
            }
            int uId = Integer.parseInt(userId);
            System.out.println(1/uId);
            User user = new User("cc百川", uId);
            System.out.println(user.toString());
            return "success";
        }
        @ResponseBody
        @RequestMapping(value = "/getUserByIds",produces="text/html;charset=UTF-8;")
        public String getUserByIds(String userId, String userName){ 
            if(userId == null || "".equals(userId)) { 
                System.out.println("缺少用户id，请检查参数！");
            }
             User user = new User("cc百川", Integer.parseInt(userId));
            System.out.println(user.toString());
            return JSON.toJSONString(user);
        }
    }

## 通过实现Controller重写handlerRequest方式 ##

注意都需要配置mvc扫描  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI_size_16_color_FFFFFF_t_70 2]

public class UseImplController implements Controller { 
        @Override
        public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception { 
            System.out.println("---->UseImplController---->handleRequest---->");
            ModelAndView mv = new ModelAndView();
            mv.setViewName("success2");
            mv.addObject("hello","cc百川");
            return mv;
        }
    }

## 通过实现HttpRequestHandler重写handleRequest方式 ##

public class UseImplHttpRequestHandler implements HttpRequestHandler { 
        public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { 
            System.out.println("---->进入CcRequestHandler---->handleRequest方法---->");
            request.getRequestDispatcher("/WEB-INF/pages/success3.jsp").forward(request,response);
            return;
        }
    }

## 配置拦截器 ##

<mvc:interceptors>
            <mvc:interceptor>
                <mvc:mapping path="/**"/>
                <bean id="cutonInterceptor" class="com.cc.interceptors.CustInterceptor"></bean> 
            </mvc:interceptor>
        </mvc:interceptors>

public class CustInterceptor implements HandlerInterceptor { 
        //执行handler之前，返回false不执行handler
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { 
            System.out.println("前置连接器");
            String uri = request.getRequestURI();
            System.out.println(request.getRequestURL()+":"+uri);;
            if(uri.indexOf("getUserById")!=-1) { 
                String param = request.getParameter("userId")+"";
                return "1".equals(param.trim()) || "0".equals(param.trim());
            }
            return true;
        }
    
    	//只是handler之后，视图返回返回之前，可以动态的修改视图
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { 
            System.out.println("后置拦截器");
        }
    
    	//创建视图后，渲染视图之前，已经不能修改视图
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { 
            System.out.println("最终拦截器");
        }
    }

![在这里插入图片描述][20210420183454932.gif]

## 异常处理的方式 ##

### 实现HandlerExceptionResolver接口 ###

public class CustomExc implements HandlerExceptionResolver { 
        @Override
        public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) { 
            System.out.println("===============>统一异常拦截机制 ");
    
            System.out.println(o.toString()+":"+e.getMessage());
            ModelAndView m = new ModelAndView();
            m.setViewName("error");
            return m;
        }
    }

需要配置加载bean

### 通过@ControllerAdvice、 @ExceptionHandler注解 ###

public class CustomExcAnn  { 
        @ExceptionHandler(Throwable.class)
        @ResponseBody
        public ModelAndView error(Throwable error, HttpServletRequest request, HttpServletResponse response) { 
            ModelAndView mv = new ModelAndView();
            System.out.println("===========>异常拦截");
    
            mv.setViewName("error");
            System.out.println(error.getMessage());
            return mv;
        }
    }

# 常见面试题 #

## 1.SpringMVC是什么 ##

Spring Web MVC 框架提供 模型-视图-控制器 架构和随时可用的组件，用于开发灵活且松散耦合的 Web 应用程序

## 2.@ResponseBody的作用 ##

把数据填充到http的response中

## 3.Springmvc 怎么样设定重定向和转发的 ##

在返回值前面加"forward:“就可以让结果转发（默认），在返回值前面加"redirect:“就可以让返回值重定向  
重定向与转发的区别

<table> 
 <thead> 
  <tr> 
   <th>转发</th> 
   <th>重定向</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>一次请求</td> 
   <td>两次请求</td> 
  </tr> 
  <tr> 
   <td>地址不变</td> 
   <td>地址栏发生改变</td> 
  </tr> 
  <tr> 
   <td>数据共享</td> 
   <td>两次请求数据不共享</td> 
  </tr> 
  <tr> 
   <td>只能在站点内跳转</td> 
   <td>可以重定向到任何URL</td> 
  </tr> 
  <tr> 
   <td>服务端行为</td> 
   <td>客户端行为</td> 
  </tr> 
  <tr> 
   <td>效率高</td> 
   <td>效率低</td> 
  </tr> 
 </tbody> 
</table>

## 4.过滤器与拦截器的区别 ##

4.1过滤器是servlet层面的，而拦截器是框架层面。
    4.2过滤器在拦截器之前执行。
    4.3拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。
    4.4拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。
    4.5拦截器是基于java的反射机制的，而过滤器是基于函数回调。
    4.6拦截器可以获取IOC容器中的各个bean，而过滤器就不行

--------------------

望指导，持续更新中。。。

--------------------

急流勇退，方见人生差距。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI_size_16_color_FFFFFF_t_70]: /images/20221022/1bc9eeeb09df449dbb754e98bef20616.png
[https_codechina.csdn.net_ljcc122_cc]: https://codechina.csdn.net/ljcc122/cc
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI_size_16_color_FFFFFF_t_70 1]: /images/20221022/086874c5f02b4fa28e0c93de9137d050.png
[doGet]: /images/20221022/220ee79f73f044898946042561caaa4c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI_size_16_color_FFFFFF_t_70 2]: /images/20221022/dc6ded60a4234b16b6671b7c7fa43e2c.png
[20210420183454932.gif]: /images/20221022/96d3d83f68204eea8f1df34b349877c7.png