HandlerAdapter顾名思义就是一个适配器，（肯定也采用了适配器模式这里不做过多的解释），那么它的主要作用是什么呢？HandlerMapping存储了所有都请求映射，请求过来找到相应的请求映射后，返回给我们一个Handler

        看这里的代码：

@Nullable
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    if (this.handlerMappings != null) {
        Iterator var2 = this.handlerMappings.iterator();

        while(var2.hasNext()) {
            HandlerMapping mapping = (HandlerMapping)var2.next();
            HandlerExecutionChain handler = mapping.getHandler(request);
            if (handler != null) {
                return handler;
            }
        }
    }

    return null;
}

这里是DispacherServlet的核心控制方法。

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 = HttpMethod.GET.matches(method);
                    if (isGet || HttpMethod.HEAD.matches(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);
            }

        }
    }

我们拿到Handler之后呢？

        接着代码往下走我们可以看到这样一行代码

HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());

这一步就是讲我们的Handler进行一个HandlerAdapter的适配解析，我们继续代码跟进

public interface HandlerAdapter {
    //如果当前支持当前handler就执行handler方法
    boolean supports(Object handler);

    @Nullable
    ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;

    /** @deprecated */
    @Deprecated
    long getLastModified(HttpServletRequest request, Object handler);
}

 我们知道它采用的适配器模式

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
    if (this.handlerAdapters != null) {
        Iterator var2 = this.handlerAdapters.iterator();

        while(var2.hasNext()) {
            HandlerAdapter adapter = (HandlerAdapter)var2.next();
            if (adapter.supports(handler)) {
                return adapter;
            }
        }
    }

    throw new ServletException("No adapter for handler [" + handler + "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}

DispacherServlet中这个方法，就是一个迭代器，给handler找一个适配器，那这一步到底是要做什么呢？

 在HandlerAdapter中有四个实现类，分别处理不同Handler我们看一下我们最常用的HttpRequestHandlerAdapter

public boolean supports(Object handler) {
    return handler instanceof HttpRequestHandler;
}

里面就是去判断了，当前handler是不是HttpRequestHandler类型，其实在我们确认号类型的时候，handler经过RequestMappingHandlerMapping​，返回的就已经是这个类型的了。

        找到适配器之后啊，就是开始参数解析了，

String method = request.getMethod();
boolean isGet = HttpMethod.GET.matches(method);
if (isGet || HttpMethod.HEAD.matches(method)) {
    long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
    if ((new ServletWebRequest(request, response)).checkNotModified(lastModified) && isGet) {
        return;
    }
}

核心在这里，利用的HandlerAdapter，也就是刚才找到的适配器，和目标方法传进去，执行目标方法。​

执行完上面代码，就是判断了一下是不是get请求，HEAD这个不是由我们 去处理的。

mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

上面这行代码去执行的目标方法。

到这里基本是完成了HandlerAdapter的一个准备工作，找到适配的HandlerAdapter之后，还要进行相应的参数解析啊。