Spring5MVC——request与Controller方法

作者: 小波同学 | 来源:发表于2020-07-08 19:10 被阅读0次

SpringMVC的核心流程

建立请求和Controller方法的映射集合的流程。
根据请求查找对应的Controller方法的流程。
请求参数绑定到方法形参，执行方法处理请求，返回结果进行视图渲染的流程。

HandlerMapping

HandlerMapping接口作用是将请求映射到处理程序，以及预处理和处理后的拦截器列表，映射是基于一些标准的，其中的细节因不同的实现而不相同。这是官方文档上一段描述，该接口只有一个方法getHandler(request)，返回一个HandlerExecutionChain对象，接口本身很简单。

public interface HandlerMapping {


    String BEST_MATCHING_HANDLER_ATTRIBUTE = HandlerMapping.class.getName() + ".bestMatchingHandler";


    String LOOKUP_PATH = HandlerMapping.class.getName() + ".lookupPath";


    String PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE = HandlerMapping.class.getName() + ".pathWithinHandlerMapping";


    String BEST_MATCHING_PATTERN_ATTRIBUTE = HandlerMapping.class.getName() + ".bestMatchingPattern";


    String INTROSPECT_TYPE_LEVEL_MAPPING = HandlerMapping.class.getName() + ".introspectTypeLevelMapping";


    String URI_TEMPLATE_VARIABLES_ATTRIBUTE = HandlerMapping.class.getName() + ".uriTemplateVariables";


    String MATRIX_VARIABLES_ATTRIBUTE = HandlerMapping.class.getName() + ".matrixVariables";


    String PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE = HandlerMapping.class.getName() + ".producibleMediaTypes";

    // 返回请求的一个处理程序handler和拦截器interceptors
    @Nullable
    HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;

}

DispatcherServlet

DispatcherServlet是Spring MVC核心，它是J2EE规范前端控制器的实现，负责拦截用户请求，并解析请求进行转发。

public class DispatcherServlet extends FrameworkServlet {

    @Override
    protected void onRefresh(ApplicationContext context) {
        initStrategies(context);
    }

    protected void initStrategies(ApplicationContext context) {
        //初始化文件上传处理器
        initMultipartResolver(context);
        
        //初始化国际化配置
        initLocaleResolver(context);

        //初始化主题处理器
        initThemeResolver(context);

        //初始化HanlderMapping
        initHandlerMappings(context);

        //初始化HandlerAdapter
        //HandlerAdapter用来调用具体的方法对用户发来的请求来进行处理
        initHandlerAdapters(context);

        //初始化异常处理器,
        // HandlerExceptionResolver是用来对请求处理过程中产生的异常进行处理
        initHandlerExceptionResolvers(context);

        //RequestToViewNameTranslator用于在视图路径为空的时候，自动解析请求
        //去获取ViewName
        initRequestToViewNameTranslator(context);

        //初始化视图处理器
        //ViewResolvers将逻辑视图转成view对象
        initViewResolvers(context);

        //FlashMapManager用于存储、获取以及管理FlashMap实例
        initFlashMapManager(context);
    }
}

从方法调用链看，DispatcherServlet的initStrategies方法是在OnRefresh方法之后调用的，而initHandlerMappings方法是在initStrategies方法中被调用的。

initHandlerMappings

初始化HanlderMapping

public class DispatcherServlet extends FrameworkServlet {

    private void initHandlerMappings(ApplicationContext context) {
        this.handlerMappings = null;
        //是否检查所有的HandlersMapping实现类并载入，默认为true
        //<init-param>
        //      <param-name>detectAllHandlerMappings</param-name>
        //      <param-value>false</param-value>
        //</init-param>
        if (this.detectAllHandlerMappings) {
            // Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
            //寻找IOC容器中HandlerMapping类型的Bean
            Map<String, HandlerMapping> matchingBeans =
                    BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
            if (!matchingBeans.isEmpty()) {
                this.handlerMappings = new ArrayList<>(matchingBeans.values());
                // We keep HandlerMappings in sorted order.
                // 对找到的HandlerMapping类型的Bean列表进行排序
                AnnotationAwareOrderComparator.sort(this.handlerMappings);
            }
        }
        else {
            try {
                //从容器里获取beanName为handlerMapping的Bean
                HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
                this.handlerMappings = Collections.singletonList(hm);
            }
            catch (NoSuchBeanDefinitionException ex) {
                // Ignore, we'll add a default HandlerMapping later.
            }
        }

        // Ensure we have at least one HandlerMapping, by registering
        // a default HandlerMapping if no other mappings are found.
        // 从context上下文中定义HandlerMapping时，Spring MVC将使用默认HandlerMapping，默认的HandlerMapping在DispatcherServlet.properties属性文件中定义，
        // 该文件是在DispatcherServlet的static静态代码块中加载的
        // 默认的是：BeanNameUrlHandlerMapping和RequestMappingHandlerMapping
        if (this.handlerMappings == null) {
            //如果以上过程都没有找到handlerMapping
            //将赋值handlerMappings为默认的HandlerMapping
            this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
            if (logger.isTraceEnabled()) {
                logger.trace("No HandlerMappings declared for servlet '" + getServletName() +
                        "': using default strategies from DispatcherServlet.properties");
            }
        }
    }
}

这就是HanlderMapping的初始化过程。

HandlerMapping的实现类

从方法调用链可以得知，SpringMvc有四种HandlerMapping：

requestMappingHandlerMapping -> RequestMappingHandlerMapping
beanNameHandlerMapping -> BeanNameUrlHandlerMapping
routerFunctionMapping -> RouterFunctionMapping
defaultServletHandlerMapping -> SimpleUrlHandlerMapping

这里主要关注RequestMappingHandlerMapping

RequestMappingHandlerMapping继承类图

由于RequestMappingHandlerMapping实现了ApplicationContextAware和ServletContextAware两个接口，这说明RequestMappingHandlerMapping可以通过这两个接口获取到Root容器和Servley子容器中的Bean。
RequestMappingHandlerMapping还实现了InitializingBean接口，该接口的afterPropertiesSet方法是在bean初始化的invokeInitMethods方法之后执行的，因此可以在这里加入对标记有RequestMapping标记的Bean进行处理，将相关的映射关系依次保存到RequestMappingHandlerMapping或者其父类的成员变量里面。

AbstractHandlerMethodMapping

在类图中AbstractHandlerMethodMapping实现了InitializingBean接口，重写了afterPropertiesSet方法

public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping implements InitializingBean {

    @Override
    public void afterPropertiesSet() {
        initHandlerMethods();
    }
}

从方法调用链可以看出：

程序在Bean初始化后，会立即执行AbstractHandlerMethodMapping中的afterPropertiesSet方法，这是因为RequestMappingHandlerMapping是需要先在容器中创建出来，后续才能在DispatcherServlet中的initHandlerMappings方法中去作为HandlerMapping的实现类给载入到DispatcherServlet的成员变量handlerMappings集合里。
又因为RequestMappingHandlerMapping在创建的时候会去调用invokeInitMethods方法进行初始化，也会执行afterPropertiesSet里面的逻辑，也就是会先执行initHandlerMethods的逻辑去初始化映射关系。

AbstractHandlerMethodMapping#initHandlerMethods

public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping implements InitializingBean {

    protected void initHandlerMethods() {
        //遍历容器里所有的Bean
        for (String beanName : getCandidateBeanNames()) {
            //忽略掉scopedTarget.打头的bean（session application request之类的作用域内的代理类）
            if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
                processCandidateBean(beanName);
            }
        }
        handlerMethodsInitialized(getHandlerMethods());
    }

    protected String[] getCandidateBeanNames() {
        //从root容器以及子容器里，或者仅从子容器里获取所有的Bean
        return (this.detectHandlerMethodsInAncestorContexts ?
                BeanFactoryUtils.beanNamesForTypeIncludingAncestors(obtainApplicationContext(), Object.class) :
                obtainApplicationContext().getBeanNamesForType(Object.class));
    }
}

根据detectHandlerMethodsInAncestorContexts变量是否为true，来决定是否需要从root容器以及子容器里，或者仅从子容器里获取所有的Bean。
如果为false，则只从当前的子容器即ServletContext里去查找。
而如果Root容器中有bean被标记上RequestMapping的话，detectHandlerMethodsInAncestorContexts就会被标记为true。

AbstractHandlerMethodMapping#processCandidateBean

public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping implements InitializingBean {

    protected void processCandidateBean(String beanName) {
        Class<?> beanType = null;
        try {
            //获取Bean的Class类型
            beanType = obtainApplicationContext().getType(beanName);
        }
        catch (Throwable ex) {
            // An unresolvable bean type, probably from a lazy bean - let's ignore it.
            if (logger.isTraceEnabled()) {
                logger.trace("Could not resolve type for bean '" + beanName + "'", ex);
            }
        }
        //判断Class上是否有Controller注解或是RequestMapping注解
        if (beanType != null && isHandler(beanType)) {
            //提取其url与controller映射关系
            detectHandlerMethods(beanName);
        }
    }
}


public class RequestMappingHandlerMapping extends RequestMappingInfoHandlerMapping
        implements MatchableHandlerMapping, EmbeddedValueResolverAware {

    @Override
    protected boolean isHandler(Class<?> beanType) {
        //判断类上是否存在Controller注解或是RequestMapping注解
        return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||
                AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));
    }
}

首先获取Bean对应的Class对象。
通过判断Class上是否有Controller注解或是RequestMapping注解，为后续提取其url与controller映射关系做好准备。

AbstractHandlerMethodMapping#detectHandlerMethods

发觉Controller方法，并建立与请求url的映射关系。

public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping implements InitializingBean {

    protected void detectHandlerMethods(Object handler) {
        //如果handler是字符串，证明是一个beanName，则从IOC容器中获取其Class对象;否则直接获取Class对象
        Class<?> handlerType = (handler instanceof String ?
                obtainApplicationContext().getType((String) handler) : handler.getClass());

        if (handlerType != null) {
            //为了确保获取到的类是被代理的类
            Class<?> userType = ClassUtils.getUserClass(handlerType);
            //寻找方法上有@RequestMapping注解的Method实例
            Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
                    (MethodIntrospector.MetadataLookup<T>) method -> {
                        try {
                            return getMappingForMethod(method, userType);
                        }
                        catch (Throwable ex) {
                            throw new IllegalStateException("Invalid mapping on handler class [" +
                                    userType.getName() + "]: " + method, ex);
                        }
                    });
            if (logger.isTraceEnabled()) {
                logger.trace(formatMappings(userType, methods));
            }
            //将获取到的Method对象依次注册到HandlerMapping中去
            methods.forEach((method, mapping) -> {
                //获取被AOP代理包装后的方法实例
                Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
                registerHandlerMethod(handler, invocableMethod, mapping);
            });
        }
    }
}

RequestMappingHandlerMapping#getMappingForMethod

创建求映射信息对象RequestMappingInfo。

public class RequestMappingHandlerMapping extends RequestMappingInfoHandlerMapping
        implements MatchableHandlerMapping, EmbeddedValueResolverAware {

    protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
        //创建方法上面的RequestMapping信息
        RequestMappingInfo info = createRequestMappingInfo(method);
        if (info != null) {
            //创建类上面的RequestMapping信息
            RequestMappingInfo typeInfo = createRequestMappingInfo(handlerType);
            if (typeInfo != null) {
                //将两个信息合并
                info = typeInfo.combine(info);
            }
            String prefix = getPathPrefix(handlerType);
            if (prefix != null) {
                info = RequestMappingInfo.paths(prefix).options(this.config).build().combine(info);
            }
        }
        return info;
    }

    @Nullable
    private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
        //如果该函数含有@RequestMapping注解,则根据其注解信息生成RequestMapping实例，
        //否则返回空
        RequestMapping requestMapping = AnnotatedElementUtils.findMergedAnnotation(element, RequestMapping.class);
        RequestCondition<?> condition = (element instanceof Class ?
                getCustomTypeCondition((Class<?>) element) : getCustomMethodCondition((Method) element));
        return (requestMapping != null ? createRequestMappingInfo(requestMapping, condition) : null);
    }

    protected RequestMappingInfo createRequestMappingInfo(
            RequestMapping requestMapping, @Nullable RequestCondition<?> customCondition) {
        //这里用到了一个典型的建造者模式
        RequestMappingInfo.Builder builder = RequestMappingInfo
                //这里对路径进行解析，在path中是支持SpEL表达式的，
                //RequestMappingHandlerMapping实现了EmbeddedValueResolverAware这个接口
                .paths(resolveEmbeddedValuesInPatterns(requestMapping.path()))
                .methods(requestMapping.method())
                .params(requestMapping.params())
                .headers(requestMapping.headers())
                .consumes(requestMapping.consumes())
                .produces(requestMapping.produces())
                .mappingName(requestMapping.name());
        if (customCondition != null) {
            builder.customCondition(customCondition);
        }
        return builder.options(this.config).build();
    }
}

视线拉回到detectHandlerMethods方法中：

在执行完AbstractHandlerMethodMapping类中的detectHandlerMethods方法中的selectMethods方法之后，就能建立起Controller方法实例和RequestMappingInfo的映射关系，并将相关的映射保存到methods这个Map<Method, T>集合中，key为方法实例，value为RequestMappingInfo实例。
之后会遍历methods将相关的映射信息给注册到HandlerMapping中。

public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping implements InitializingBean {

    protected void detectHandlerMethods(Object handler) {
        ......

        if (handlerType != null) {
            ......

            //将获取到的Method对象依次注册到HandlerMapping中去
            methods.forEach((method, mapping) -> {
                //获取被AOP代理包装后的方法实例
                Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
                registerHandlerMethod(handler, invocableMethod, mapping);
            });
        }
    }
}

上面这段代码，会将methods中的Method实例和RequestMappingInfo实例给一一对应的注册到HandlerMapping里面。

AbstractHandlerMethodMapping#registerHandlerMethod

public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping implements InitializingBean {

    protected void registerHandlerMethod(Object handler, Method method, T mapping) {
        this.mappingRegistry.register(mapping, handler, method);
    }

    class MappingRegistry {
        //储存 MappingRegistration 所有的注册信息
        private final Map<T, MappingRegistration<T>> registry = new HashMap<>();
        //储存RequestMappingInfo 与 HandlerMethod
        private final Map<T, HandlerMethod> mappingLookup = new LinkedHashMap<>();
        //储存路径与RequestMappingInfo
        private final MultiValueMap<String, T> urlLookup = new LinkedMultiValueMap<>();
        //储存@RequestMapping 注解的请求路径 与 HandlerMethod列表
        private final Map<String, List<HandlerMethod>> nameLookup = new ConcurrentHashMap<>();
        //跨域配置
        private final Map<HandlerMethod, CorsConfiguration> corsLookup = new ConcurrentHashMap<>();
        //读写锁
        private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

        /**
         * 注册数据：  mapping => RequestMappingInfo ||  handler => beanName  ||  method => Method
         *      1、根据 handle 和 method，创建 HandlerMethod,
         *      2、效验 HandlerMethod 是否存在
         *      3、储存 HandlerMethod
         *      4、储存 RequestMappingInfo 跟 url
         *      5、储存 @RequestMapping 注解 的路径跟所有的方法
         *      6、存储 CorsConfiguration 信息(跨域)
         *      7、储存 MappingRegistration 对象
         */
        public void register(T mapping, Object handler, Method method) {
            // Assert that the handler method is not a suspending one.
            if (KotlinDetector.isKotlinType(method.getDeclaringClass())) {
                Class<?>[] parameterTypes = method.getParameterTypes();
                if ((parameterTypes.length > 0) && "kotlin.coroutines.Continuation".equals(parameterTypes[parameterTypes.length - 1].getName())) {
                    throw new IllegalStateException("Unsupported suspending handler method detected: " + method);
                }
            }
            this.readWriteLock.writeLock().lock();
            try {
                HandlerMethod handlerMethod = createHandlerMethod(handler, method);
                //验证方法的唯一性，即先前是否已经注册过同样的映射
                validateMethodMapping(handlerMethod, mapping);
                //注册RequestMappingInfo 和 HandlerMethod
                this.mappingLookup.put(mapping, handlerMethod);
                //注册请求路径与对应的RequestMappingInfo
                List<String> directUrls = getDirectUrls(mapping);
                for (String url : directUrls) {
                    this.urlLookup.add(url, mapping);
                }

                String name = null;
                if (getNamingStrategy() != null) {
                    //注册请求路径与HandlerMethod
                    name = getNamingStrategy().getName(handlerMethod, mapping);
                    addMappingName(name, handlerMethod);
                }

                CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);
                if (corsConfig != null) {
                    //注册HandlerMethod与跨域信息
                    this.corsLookup.put(handlerMethod, corsConfig);
                }
                //创建及注册 MappingRegistation 信息
                this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));
            }
            finally {
                this.readWriteLock.writeLock().unlock();
            }
        }
    }
}

主要步骤：

1、根据 handle 和 method，创建 HandlerMethod,
2、效验 HandlerMethod 是否存在，验证方法的唯一性，即先前是否已经注册过同样的映射
3、注册RequestMappingInfo 和 HandlerMethod
4、注册请求路径与对应的RequestMappingInfo
5、注册请求路径与HandlerMethod
6、注册HandlerMethod与跨域信息
7、创建及注册 MappingRegistation 信息

最终会将前面获取到的所有信息给包装起来，保存到Map<T, MappingRegistration<T>> registry成员变量中，后续就可以解析请求并选择合适的Controller方法来对请求进行处理。

这样就完成了建立请求和Controller方法的映射集合的流程的分析。

HandlerAdapter

public interface HandlerAdapter {


    //判断适配器是否适配handler，适配策略由子类实现
    boolean supports(Object handler);


    //使用适配的handler执行用户请求
    @Nullable
    ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;


    //返回资源的最后修改时间，如果handler实现类不支持可以返回-1
    long getLastModified(HttpServletRequest request, Object handler);

}

以上是HandlerAdapter接口的源码分析，如需自定义HandlerAdapter，只需要实现该接口，在supports方法中定义适配策略，并实现handle方法进行调用即可。

HandlerAdapter的初始化

顾名思义，是handler的适配器，它能处理参数转换为handler能接受的数据类型，解析参数、处理返回值等。

在DispatcherServlet进行初始化流程调用initStrategies，执行完initHandlerMappings方法后，会接着执行initHandlerAdapters方法。

initHandlerAdapters

初始化HandlerAdapter

public class DispatcherServlet extends FrameworkServlet {

    private void initHandlerAdapters(ApplicationContext context) {
        this.handlerAdapters = null;
        // 在部署描述文件中可控制该参数
        if (this.detectAllHandlerAdapters) {
            // Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
            // 从应用上下文中查找HandlerAdapter
            Map<String, HandlerAdapter> matchingBeans =
                    BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
            if (!matchingBeans.isEmpty()) {
                this.handlerAdapters = new ArrayList<>(matchingBeans.values());
                // We keep HandlerAdapters in sorted order.
                // 对使用的HandlerAdapter进行排序，spring提供的只有RequestMappingHandlerAdapter实现了Ordered接口，其他都不具备排序功能
                AnnotationAwareOrderComparator.sort(this.handlerAdapters);
            }
        }
        else {
            try {
                // 如果在部署描述文件中配置了detectAllHandlerAdapters=false，
                // 此时spring会加载名称为handlerAdapter的bean为处理器适配器
                HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class);
                // 转化为集合赋给handlerAdapters属性
                this.handlerAdapters = Collections.singletonList(ha);
            }
            catch (NoSuchBeanDefinitionException ex) {
                // Ignore, we'll add a default HandlerAdapter later.
            }
        }

        // Ensure we have at least some HandlerAdapters, by registering
        // default HandlerAdapters if no other adapters are found.
        // 如果未配置HandlerAdapter，注册默认的处理器适配器，
        // 即从DispatcherServlet.properties中获取的HttpRequestHandlerAdapter、
        // SimpleControllerHandlerAdapter和ReqeustMappingHandlerAdapter
        if (this.handlerAdapters == null) {
            this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
            if (logger.isTraceEnabled()) {
                logger.trace("No HandlerAdapters declared for servlet '" + getServletName() +
                        "': using default strategies from DispatcherServlet.properties");
            }
        }
    }
}

通过initHandlerAdapters方法的调用栈可知，一共向List<HandlerAdapter> handlerAdapters集合中注册了4个HandlerAdapter的实现类。

requestMappingHandlerAdapter -> RequestMappingHandlerAdapter
handlerFunctionAdapter -> HandlerFunctionAdapter
httpRequestHandlerAdapter -> HttpRequestHandlerAdapter
simpleControllerHandlerAdapter -> SimpleControllerHandlerAdapter

以上就是Spring MVC对HandlerAdapter组件的注册过程。

参考：
https://segmentfault.com/a/1190000014901736

https://segmentfault.com/a/1190000015009343

https://segmentfault.com/a/1190000015027885

Spring5MVC——request与Controller方法

SpringMVC的核心流程

HandlerMapping

DispatcherServlet

initHandlerMappings

HandlerMapping的实现类

这里主要关注RequestMappingHandlerMapping

AbstractHandlerMethodMapping

AbstractHandlerMethodMapping#initHandlerMethods

AbstractHandlerMethodMapping#processCandidateBean

AbstractHandlerMethodMapping#detectHandlerMethods

RequestMappingHandlerMapping#getMappingForMethod

AbstractHandlerMethodMapping#registerHandlerMethod

HandlerAdapter

HandlerAdapter的初始化

initHandlerAdapters

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

设计方案