devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

一次Request请求在Spring中的实现_spring 某一开头的请求

作者：羊村懒王 | 2024-03-25 13:11:53

赞

踩

spring 某一开头的请求

一次request看spring的细节处理

spring获取处理一次请求的类的方式有两种

1.从配置文件spring-configs.xml中获取

‌2.从注解中获取

1.1从spring-configs.xml配置来看：

客户端：请求资源URL，web.xml中<servlet-mapping>标签<url-pattern>匹配请求资源
如果匹配到就调用对应的<servlet-name>中对应的servlet 通过<servlet-class>创建servlet对象dispatcherservlet
执行初始化方法通过set方法注入初始化属性值
classpath：spring-configs.xml，通过读取这个配置文件，创建出由spring管理的bean对象handlermapping处理映射，通过property标签实现set注入mapping的值，并将处理的结果以map集合的形式返还给dispatcherservlet，map集合中key为请求URL中／请求资源的名字，value对应业务层自己实现的controller对象，与要创建此对象的bean标签中id或name的属性值对应。dispatcherservlet将请求的URL交给业务层处理
问题：不同对象间获取request域中携带的参数是转发还是包含？
controller对象处理过后返回modelandview对象，交给viewresolver解析，视图解析器做的工作是从mv对象解析出要响应的资源，前缀＋名字＋后缀组成响应资源的地址，最终呈现给客户端，一次请求结束。
思考：在这一次请求中，request只创建一次且一直在整个请求链中存在并共享数据，直到一次请求结束才销毁request和response对象。
.do是个请求,这个站点在web.xml配置文件中配置了.do的请求都转发给一个servlet来处理,不是个文件,系统遇到这个.do的请求
后就会提交给某个servlet来处理,这个servlet会根据具体的配置转发给某个后台的程序进行数据处理,然后给数据传递到页面,最终给页面展现在
用户面前,不一定是struts的,这个请求是可以自己随便配置的，你可以配置成.html,这样就是经常看到假静态

2.1从注解模式理解spring框架：

@concroller是在告诉spring当前类为业务处理类
@service请求服务
@respontiry持久层
@compoent组件类   

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

以下内容摘抄自JAVA API中的源代码：

今天来探索SpringMVC一次请求过程的源码，首先需要找到程序运行的类及主要方法：

我们使用StringMVC首先需要在web.xml中设置一个前端控制器来处理请求，这个前端控制器是：org.springframework.web.servlet.DispatcherServlet

那么我们程序运行的入口就在这里。

从这里可以看出前端控制器是一个Servlet，我们寻找他的service方法，在DispatherServlet中并没有找到service方法，在其父类FrameworkServlet中找到service方法。如下：


FrameworkServlet：

[java] 源码：
  1. @Override  
  2. protected void service(HttpServletRequest request, HttpServletResponse response)  
  3.         throws ServletException, IOException {  
  4.   
  5.   
  6.     String method = request.getMethod();  
  7.     if (method.equalsIgnoreCase(RequestMethod.PATCH.name())) {  
  8.         // 处理请求  
  9.         processRequest(request, response);  
  10.     }  
  11.     else {  
  12.         super.service(request, response);  
  13.     }  
  14. } 
调用本类的processRequest方法
  1. protected final void processRequest(HttpServletRequest request, HttpServletResponse response)  
  2.         throws ServletException, IOException {
  3.  
  4.     long startTime = System.currentTimeMillis();  
  5.     Throwable failureCause = null;  
  6.   
  7.     LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();  
  8.     LocaleContext localeContext = buildLocaleContext(request);  
  9.   
  10.     RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();  
  11.     ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);  
  12.   
  13.     WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);  
  14.     asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());  
  15.   
  16.     initContextHolders(request, localeContext, requestAttributes);  
  17.   
  18.     try {  
  19.         // 调用doService方法处理请求  
  20.         doService(request, response);  
  21.     }  
  22.     ...  
调用本类的doService方法
  1. @Override  
  2. protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {  
  3.     ...  
  4.     try {  
  5.         // 调用doDispatch方法处理请求  
  6.         doDispatch(request, response);  
  7.     }  
  8.     ...
调用 DispatherServlet的doDispatch方法处理请求，主要程序在此方法中进行
  1. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {  
  2.     HttpServletRequest processedRequest = request;  
  3.     HandlerExecutionChain mappedHandler = null;  
  4.     boolean multipartRequestParsed = false;  
  5.   
  6.     WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);  
  7.   
  8.     try {  
  9.         ModelAndView mv = null;  
  10.         Exception dispatchException = null;  
  11.   
  12.         try {  
  13.             processedRequest = checkMultipart(request);  
  14.             multipartRequestParsed = processedRequest != request;  
  15.   
  16.             // Determine handler for the current request.  
  17.             // 通过processedRequest,决定使用哪个handler来处理请求  
  18.             mappedHandler = getHandler(processedRequest);  
  19.             if (mappedHandler == null || mappedHandler.getHandler() == null) {  
  20.                 noHandlerFound(processedRequest, response);  
  21.                 return;  
  22.             }  
  23.   
  24.             // Determine handler adapter for the current request.  
  25.             // 决定使用那个适配器处理请求（适配器模式）  
  26.             HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());  
  27.   
  28.             // Process last-modified header, if supported by the handler.  
  29.             String method = request.getMethod();  
  30.             boolean isGet = "GET".equals(method);  
  31.             if (isGet || "HEAD".equals(method)) {  
  32.                 long lastModified = ha.getLastModified(request, mappedHandler.getHandler());  
  33.                 if (logger.isDebugEnabled()) {  
  34.                     String requestUri = urlPathHelper.getRequestUri(request);  
  35.                     logger.debug("Last-Modified value for [" + requestUri + "] is: " + lastModified);  
  36.                 }  
  37.                 if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {  
  38.                     return;  
  39.                 }  
  40.             }  
  41.   
  42.             // 执行预处理方法  
  43.             if (!mappedHandler.applyPreHandle(processedRequest, response)) {  
  44.                 return;  
  45.             }  
  46.   
  47.             try {  
  48.                 // Actually invoke the handler.  
  49.                 // 使用适配器执行目标方法，返回ModleAndView  
  50.                 mv = ha.handle(processedRequest, response, mappedHandler.getHandler());  
  51.             }  
  52.             finally {  
  53.                 if (asyncManager.isConcurrentHandlingStarted()) {  
  54.                     return;  
  55.                 }  
  56.             }  
  57.   
  58.             applyDefaultViewName(request, mv);  
  59.             mappedHandler.applyPostHandle(processedRequest, response, mv);  
  60.         }  
  61.         catch (Exception ex) {  
  62.             dispatchException = ex;  
  63.         }  
  64.         // 处理业务逻辑执行以后的返回结果，即处理视图  
  65.         processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);  
  66.     }  
  67.     catch (Exception ex) {  
  68.         triggerAfterCompletion(processedRequest, response, mappedHandler, ex);  
  69.     }  
  70.     catch (Error err) {  
  71.         triggerAfterCompletionWithError(processedRequest, response, mappedHandler, err);  
  72.     }  
  73.     finally {  
  74.         if (asyncManager.isConcurrentHandlingStarted()) {  
  75.             // Instead of postHandle and afterCompletion  
  76.             mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);  
  77.             return;  
  78.         }  
  79.         // Clean up any resources used by a multipart request.  
  80.         if (multipartRequestParsed) {  
  81.             cleanupMultipart(processedRequest);  
  82.         }  
  83.     }  
  84. } 

到这里我们可以看出这个前端控制器主要工作是在 DispatherServlet的 doDispatch方法中完成。

大致流程如下：


通过processedRequest,决定使用哪个handler来处理请求

  1. HandlerExecutionChain mappedHandler = null;  
  2. // Determine handler for the current request.  
  3. mappedHandler = getHandler(processedRequest);  

决定使用那个适配器处理请求（适配器模式）
  1. // Determine handler adapter for the current request.  
  2. HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());  

执行预处理方法
  1. if (!mappedHandler.applyPreHandle(processedRequest, response)) {  
  2.     return;  
  3. } 

使用适配器执行目标方法，返回ModleAndView
  1. // Actually invoke the handler.  
  2. mv = ha.handle(processedRequest, response, mappedHandler.getHandler()); 
执行目标后处理方法
  1. mappedHandler.applyPostHandle(processedRequest, response, mv); 

处理业务逻辑执行以后的返回结果，即处理视图，

调用本类的processDispatchResult方法

  1. private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,  
  2.         HandlerExecutionChain mappedHandler, ModelAndView mv, Exception exception) throws Exception {  
  3.     ...  
  4.     // Did the handler return a view to render?  
  5.     if (mv != null && !mv.wasCleared()) {  
  6.         render(mv, request, response);//渲染视图  
  7.         if (errorView) {  
  8.             WebUtils.clearErrorRequestAttributes(request);  
  9.         }  
  10.     }     
  11.     ..  

调用本类的render(mv, request, response);渲染视图。是将方法的返回值，最终变为一个View对象。
这个View对象正是我们在xml中配置的InternalResourceView
  1. protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {  
  2.     ..  
  3.     // Determine locale for request and apply it to the response.  
  4.     Locale locale = this.localeResolver.resolveLocale(request);  
  5.     response.setLocale(locale);  
  6.   
  7.     // View对象  
  8.     View view;  
  9.     if (mv.isReference()) {  
  10.         // We need to resolve the view name.  
  11.         view = resolveViewName(mv.getViewName(), mv.getModelInternal(), locale, request);  
  12.         if (view == null) {  
  13.             throw new ServletException(  
  14.                     "Could not resolve view with name '" + mv.getViewName() + "' in servlet with name '" +  
  15.                             getServletName() + "'");  
  16.         }  
  17.     }  
  18.     else {  
  19.         // No need to lookup: the ModelAndView object contains the actual View object.  
  20.         // 获得真正的view对象  
  21.         view = mv.getView();  
  22.         if (view == null) {  
  23.             throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " +  
  24.                     "View object in servlet with name '" + getServletName() + "'");  
  25.         }  
  26.     }  
  27.     // Delegate to the View object for rendering.  
  28.     if (logger.isDebugEnabled()) {  
  29.         logger.debug("Rendering view [" + view + "] in DispatcherServlet with name '" + getServletName() + "'");  
  30.     }  
  31.     try {  
  32.         // 内部视图解析器继续解析视图：  
  33.         view.render(mv.getModelInternal(), request, response);  
  34.     }  
  35.     catch (Exception ex) {  
  36.         if (logger.isDebugEnabled()) {  
  37.             logger.debug("Error rendering view [" + view + "] in DispatcherServlet with name '"  
  38.                     + getServletName() + "'", ex);  
  39.         }  
  40.         throw ex;  
  41.     }  
  42. } 

调用 AbstractView类中的render方法
  1. @Override  
  2. public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception {  
  3.     if (logger.isTraceEnabled()) {  
  4.         logger.trace("Rendering view with name '" + this.beanName + "' with model " + model +  
  5.             " and static attributes " + this.staticAttributes);  
  6.     }  
  7.   
  8.   
  9.     Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);  
  10.   
  11.   
  12.     prepareResponse(request, response);  
  13.     // 渲染模型  
  14.     renderMergedOutputModel(mergedModel, request, response);  
  15. }    

调用 InternalResourceView类中的renderMergedOutputModel方法进行渲染模型、转发操作：
  1. //拿到转发器，进行转发  
  2. @Override  
  3. protected void renderMergedOutputModel(  
  4.         Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {  
  5.   
  6.     // Determine which request handle to expose to the RequestDispatcher.  
  7.     HttpServletRequest requestToExpose = getRequestToExpose(request);  
  8.   
  9.     // Expose the model object as request attributes.  
  10.     exposeModelAsRequestAttributes(model, requestToExpose);  
  11.   
  12.     // Expose helpers as request attributes, if any.  
  13.     exposeHelpers(requestToExpose);  
  14.   
  15.     // Determine the path for the request dispatcher.  
  16.     String dispatcherPath = prepareForRendering(requestToExpose, response);  
  17.       
  18.     //获得转发器  
  19.     // Obtain a RequestDispatcher for the target resource (typically a JSP).  
  20.     RequestDispatcher rd = getRequestDispatcher(requestToExpose, dispatcherPath);  
  21.     if (rd == null) {  
  22.         throw new ServletException("Could not get RequestDispatcher for [" + getUrl() +  
  23.                 "]: Check that the corresponding file exists within your web application archive!");  
  24.     }  
  25.   
  26.     // If already included or response already committed, perform include, else forward.  
  27.     if (useInclude(requestToExpose, response)) {  
  28.         response.setContentType(getContentType());  
  29.         if (logger.isDebugEnabled()) {  
  30.             logger.debug("Including resource [" + getUrl() + "] in InternalResourceView '" + getBeanName() + "'");  
  31.         }  
  32.         rd.include(requestToExpose, response);  
  33.     }  
  34.   
  35.     else {  
  36.         // Note: The forwarded resource is supposed to determine the content type itself.  
  37.         if (logger.isDebugEnabled()) {  
  38.             logger.debug("Forwarding to resource [" + getUrl() + "] in InternalResourceView '" + getBeanName() + "'");  
  39.         }  
  40.         //进行转发  
  41.         rd.forward(requestToExpose, response);  
  42.     }

以下内容摘抄自want_water_fish的博客 ：

一个请求在spring中的流程  （参与处理的类及主要方法）

DispatcherServlet.doDispatch （请求第一次处理、所有的请求都会执行这个方法。在这个方法中请求会被解析、分发。）-->
WebAsyncUtils.getAsyncManager （request中创建一个属性WebAsyncManager）-->
DispatcherServlet.checkMultipart （request是否是多文件类的请求）-->
DispatcherServlet.getHandler （获得当前requst的处理handler–spring提供了两个RequestMappingHandlerMapping、BeanNameUrlHandlerMapping）-->
AbstractHandlerMapping.getHandler （获得当前requst的处理handler）-->
AbstractHandlerMapping.getHandlerExecutionChain-->
UrlPathHelper.getLookupPathForRequest-->
DispatcherServlet.getHandlerAdapter （获得当前requst的处理handlerAdapter–spring提供了两个RequestMappingHandlerAdapter、HttpRequestHandlerAdapter、SimpleControllerHandlerAdapter）-->
HandlerExecutionChain.applyPreHandle （处理拦截器）-->
AbstractHandlerMethodAdapter.handle （开始处理该请求）-->
RequestMappingHandlerAdapter.handleInternal （跳转至方法）-->
WebContentGenerator.checkRequest （检查方法是否支持、是否有session）-->
RequestMappingHandlerAdapter.invokeHandlerMethod （准备调用具体的执行方法）-->
RequestMappingHandlerAdapter.getDataBinderFactory （获得DataBinderFactory）-->
RequestMappingHandlerAdapter.createDataBinderFactory （创建DataBinderFactory）-->
RequestMappingHandlerAdapter.getModelFactory （获得ModelFactory）-->
ModelFactory.ModelFactory （创建ModelFactory）-->
RequestMappingHandlerAdapter.createInvocableHandlerMethod （创建ServletInvocableHandlerMethod）-->
ModelFactory.initModel （按照参数、初始化ModelFactory）-->
ModelFactory.invokeModelAttributeMethods （调用@ModelAttribute修饰的方法）-->
InvocableHandlerMethod.invokeForRequest （具体的调用执行方法）-->
InvocableHandlerMethod.getMethodArgumentValues （获取方法参数值）-->
HandlerMethodArgumentResolverComposite.resolveArgument （获得参数）-->
RequestResponseBodyMethodProcessor.resolveArgument （获得参数）-->
RequestResponseBodyMethodProcessor.readWithMessageConverters （将request中的参数转化成对象）-->
AbstractMessageConverterMethodArgumentResolver.readWithMessageConverters （将request中的参数转化成对象）-->
AbstractMessageConverterMethodArgumentResolver.readWithMessageConverters （将request中的参数转化成json对象、该系统用的是json数据传输）-->
ServletInvocableHandlerMethod.invokeAndHandle （调用真正的方法）-->
InvocableHandlerMethod.invokeForRequest （执行）-->
InvocableHandlerMethod.doInvoke （执行）-->
-->
自己controller中的方法
-->
InvocableHandlerMethod.doInvoke （执行返回）-->
InvocableHandlerMethod.invokeForRequest （执行返回）-->
ServletInvocableHandlerMethod.invokeAndHandle （执行返回）-->
HandlerMethodReturnValueHandlerComposite.handleReturnValue （处理方法返回的参数）-->
RequestResponseBodyMethodProcessor.handleReturnValue （处理方法返回的参数）-->
AbstractMessageConverterMethodProcessor.writeWithMessageConverters （处理方法返回的参数）-->
RequestMappingHandlerAdapter.invokeHandlerMethod （执行返回）-->
RequestMappingHandlerAdapter.getModelAndView （获得ModelAndView）-->
RequestMappingHandlerAdapter.handleInternal （执行返回）-->
AbstractHandlerMethodAdapter.handle （执行返回）-->
DispatcherServlet.doDispatch （执行返回）-->

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/310090?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号