【SpringMVC】SpringMVC深入内部对象分析执行流程(待整理)

springmvc内部请求的处理流程: 也就是springmvc接收请求，到处理完成的过程
1.用户发起请求some.do

2.DispatcherServlet接收请求some.do,把请求转交给处理器映射器
处理器映射器:
springmvc框架中的一种对象， 框架把实现了HandlerMapping接口的类都叫做映射器(多个)
处理器映射器作用:
根据请求，从springmvc容器对象中获取处理器对象( MyController controller = ctx . getBean (" some.do") )
框架把找到的处理器对象放到一个叫做处理器执行链( HandlerExecutionChain)的类保存

方法调用: HandlerExecutionChain
mappedHandler = getHandler (processedRequest) ;

HandlerExecutionChain类中保存着
1.处理器对象( MyController )
2.项目中的所有的拦截器List interceptorlist

HandlerExecutionChain

package org.springframework.web.servlet;

public class HandlerExecutionChain {
    private static final Log logger = LogFactory.getLog(HandlerExecutionChain.class);
    private final Object handler;
    @Nullable
    private HandlerInterceptor[] interceptors;
    @Nullable
    private List<HandlerInterceptor> interceptorList;
    private int interceptorIndex;
}

HandlerMapping处理器映射器 它的实现类也都是映射器类 它的所以实现类是分别对应不同实现controller方法的方式 因为一种实现controller的方法就对应一种映射器类 不只是目前所用的加入注解 没有注解之前,需要实现各种不同的接口本能做控制器使用 所以相应的也会有很多映射器类作为对应使用

1.RequestMappingHandlerMapping这个才是真正的寻找注解contorller方法的映射器类
@RequestMapping这个注解的方法对应RequestMappingHandlerMapping这个类
2.BeanNameUrlHandlerMapping这个类是一个过期类 之前时使用的这个对应注解的 也是之前默认使用的映射器类

package org.springframework.web.servlet;

public interface HandlerMapping {

    @Nullable
    HandlerExecutionChain getHandler(HttpServletRequest var1) throws Exception;
}

3. DispatcherServlet把2中的HandlerExecutionChain中的处理器对象交给了处理器适配器对象(多个)

处理器适配器: springmvc框 架中的对象，需要实现HandlerAdapter接口。
处理器适配器作用: 执行处理器方法(调用MyController . doSome ()得到返回值ModelAndview )

中央调度器中调用适配器:
HandlerAdapter ha = getHandlerAdapter (mappedHandler . getHandler()) ;|

执行处理器方法: mv = ha . handle (processedRequest, response , mappedHandler . getHandler()) ;

HandlerAdapter

package org.springframework.web.servlet;

public interface HandlerAdapter {
    boolean supports(Object var1);

    @Nullable
    ModelAndView handle(HttpServletRequest var1, HttpServletResponse var2, Object var3) throws Exception;

    long getLastModified(HttpServletRequest var1, Object var2);
}

继承结构也是对应不同的处理器对象

每一个处理器对象假设实现A接口(之前的项目开发没有注解)
A<----->对应一个处理器映射器<------->处理器适配器
所以有好几个接口就有好几个映射器适配器

4.视图解析器对象InternalResourceViewResolver

比如：a.jsp是由视图类view类表示的
4.DispatcherServlet把3中获取的ModelAndView交给了视图解析器对象。
视图解析器: springmvc中 的对象，需要实现ViewResoler接口(可以有多个)
视图解析器作用:组成视图完整路径，使用前缀，后缀。 并 创建view对象。
View是一个接口，表示视图的，
在框架中jsp, htm1不 是string表示，而是使用view和他的实现类表示视图.

InternalResourceView:视图类，表示jsp文件，视图解析器会创建InternalResourceView类对象。这个对象的里面，有一个属性url=/WEB- INF /view/ show. jsp

比如RedirectView就表示重定向视图
使用View对象可以这样使用
mv.setViewName(“other”); 这是视图解析器 这个other会被框架转化成一个View对象
mv. setview( new RedirectView( url: “/a. jsp”) ); 这是直接传入一个View对象 执行重定向作用

主要用来表示jsp页面

视图解析器把所有形式的页面转换成view对象发给了中央调度器

5.DispatcherServlet把4步骤中创建的View对象获取到，调用view类自己的方法，把Model数据放入到request作用域。执行对象视图的forward。请求结束。

所有乱七八糟的处理都是在核心方法doDispatch中进行的

public class DispatcherServlet extends FrameworkServlet {
	
	protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        boolean multipartRequestParsed = false;
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

        try {
            try {
                ModelAndView mv = null;
                Object dispatchException = null;

                try {
                    processedRequest = this.checkMultipart(request);
                    multipartRequestParsed = processedRequest != request;
                    mappedHandler = this.getHandler(processedRequest);
                    if (mappedHandler == null) {
                        this.noHandlerFound(processedRequest, response);
                        return;
                    }

                    HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
                    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;
                        }
                    }

                    if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                        return;
                    }

                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                    if (asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }

                    this.applyDefaultViewName(processedRequest, mv);
                    mappedHandler.applyPostHandle(processedRequest, response, mv);
                } catch (Exception var20) {
                    dispatchException = var20;
                } catch (Throwable var21) {
                    dispatchException = new NestedServletException("Handler dispatch failed", var21);
                }

                this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
            } catch (Exception var22) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
            } catch (Throwable var23) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", var23));
            }

        } finally {
            if (asyncManager.isConcurrentHandlingStarted()) {
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            } else if (multipartRequestParsed) {
                this.cleanupMultipart(processedRequest);
            }

        }
    }
}

mappedHandler = this.getHandler(processedRequest);
这个方法对应中央调度器到映射器到返回处理器执行链这个过程