Spring MVC URL映射学习（上）

2018-03-09 本文已影响13人 jwfy

spring中的controller设置好URL之后，服务启动后spring会管理好所有的URL映射，在接收到新的http请求时，按照URL的映射规则进行对应的处理，现在就来具体学习下spring是如何管理URL的。

spring会获取项目中所有的URL配置的属性，然后存储到对于的容器中。

如图是开始处理URL的方法调用图，从dispatchservlet的initHandlerMappings开始，然后在getDefaultStrategies函数中从DispatcherServlet.properties配置中获取到类的名称是org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping，也就是BeanNameUrlHandlerMapping和DefaultAnnotationHandlerMapping两个URL映射管理类。后续主要处理是围绕这两个类展开的。

image

这两个类都会进行下面的操作的，只是会分别介绍两个类各自不一样的情况。

AbstractDetectingUrlHandlerMapping类的detectHandlers方法

    protected void detectHandlers() throws BeansException {
        if (logger.isDebugEnabled()) {
            logger.debug("Looking for URL mappings in application context: " + getApplicationContext());
        }
        String[] beanNames = (this.detectHandlersInAncestorContexts ?
                BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
                getApplicationContext().getBeanNamesForType(Object.class));
        // 获取所有的bean信息
        for (String beanName : beanNames) {
            String[] urls = determineUrlsForHandler(beanName);
            // 获取bean对应的类的包含的URL信息
            if (!ObjectUtils.isEmpty(urls)) {
                // URL paths found: Let's consider it a handler.
                registerHandler(urls, beanName);
            }
            else {
                if (logger.isDebugEnabled()) {
                    logger.debug("Rejected bean name '" + beanName + "': no URL paths identified");
                }
            }
        }
    }

determineUrlsForHandler 方法

BeanNameUrlHandlerMapping 类

protected String[] determineUrlsForHandler(String beanName) {
    List<String> urls = new ArrayList<String>();
    // beanName是以`/`开始的
    if (beanName.startsWith("/")) {
        urls.add(beanName);
    }
    String[] aliases = getApplicationContext().getAliases(beanName);
    // 获取bean的alias信息
    for (String alias : aliases) {
        if (alias.startsWith("/")) {
            urls.add(alias);
        }
    }
    // 返回URL对应的list信息
    return StringUtils.toStringArray(urls);
}

所以也并没有进行什么操作，只是获取了bean的name是**开头的类，然后返回

DefaultAnnotationHandlerMapping 类

protected String[] determineUrlsForHandler(String beanName) {
    ApplicationContext context = getApplicationContext();
    Class<?> handlerType = context.getType(beanName);
    RequestMapping mapping = context.findAnnotationOnBean(beanName, RequestMapping.class);
    // 查找该bean信息是否加上了RequestMapping注解信息
    if (mapping != null) {
        // 存在注解信息（这里需要注意一下，存在类注解和函数注解的URL拼接的情况）
        this.cachedMappings.put(handlerType, mapping);
        Set<String> urls = new LinkedHashSet<String>();
        String[] typeLevelPatterns = mapping.value();
        if (typeLevelPatterns.length > 0) {
           // 如果类的注解包含了有效URL配置信息
            String[] methodLevelPatterns = determineUrlsForHandlerMethods(handlerType, true);
            // 获取该类所有的方法的URL配置信息
            for (String typeLevelPattern : typeLevelPatterns) {
                if (!typeLevelPattern.startsWith("/")) {
                   // 如果根URL不是/ 开头的，则加上/ 表示路径信息
                    typeLevelPattern = "/" + typeLevelPattern;
                }
                boolean hasEmptyMethodLevelMappings = false;
                // 先设定方法中无有效URL路径为false
                for (String methodLevelPattern : methodLevelPatterns) {
                    if (methodLevelPattern == null) {
                        hasEmptyMethodLevelMappings = true;
                        // 存在空的URL，也就是下面方法获取URL信息说的无有效URL
                    }
                    else {
                        String combinedPattern = getPathMatcher().combine(typeLevelPattern, methodLevelPattern);
                        addUrlsForPath(urls, combinedPattern);
                        // 组合类URL属性和函数URL属性，添加到集合中去
                    }
                }
                if (hasEmptyMethodLevelMappings ||
                        org.springframework.web.servlet.mvc.Controller.class.isAssignableFrom(handlerType)) {
                        // 如果是只有类URL或者类是controller类，则添加类信息
                    addUrlsForPath(urls, typeLevelPattern);
                }
            }
            return StringUtils.toStringArray(urls);
        }
        else {
            // 类上没有URL注解信息，那就获取方法里面的所有URL信息
            return determineUrlsForHandlerMethods(handlerType, false);
        }
    }
    else if (AnnotationUtils.findAnnotation(handlerType, Controller.class) != null) {
        // 如果方法没有注解信息，但是是实现了Controller类，也可以扫描处理其函数
        return determineUrlsForHandlerMethods(handlerType, false);
    }
    else {
       // 既没有注解信息，类也不是实现自Controller,则该bean不存在URL注解信息，返回null
        return null;
    }
}


// 获取handleType所有的方法包含的URL配置信息
protected String[] determineUrlsForHandlerMethods(Class<?> handlerType, final boolean hasTypeLevelMapping) {
    String[] subclassResult = determineUrlsForHandlerMethods(handlerType);
    // 子类结果，如果有，则直接返回
    if (subclassResult != null) {
        return subclassResult;
    }

    final Set<String> urls = new LinkedHashSet<String>();
    Set<Class<?>> handlerTypes = new LinkedHashSet<Class<?>>();
    handlerTypes.add(handlerType);
    handlerTypes.addAll(Arrays.asList(handlerType.getInterfaces()));
    // 存储着该类的信息和该类的接口信息
    for (Class<?> currentHandlerType : handlerTypes) {
       // doWithMethods会反射获取类的所有方法信息，组合成一个list，遍历调用doWith
        ReflectionUtils.doWithMethods(currentHandlerType, new ReflectionUtils.MethodCallback() {
            @Override
            public void doWith(Method method) {
               // 循环调用该方法，处理函数
                RequestMapping mapping = AnnotationUtils.findAnnotation(method, RequestMapping.class);
                // 获取方法包含的RequestMapping信息
                if (mapping != null) {
                    String[] mappedPatterns = mapping.value();
                    // 获取URL数据，例如`/index`
                    if (mappedPatterns.length > 0) {
                        for (String mappedPattern : mappedPatterns) {
                        //hasTypeLevelMapping 值为真意味着 类包含了URL信息，否则不包含URL信息
                            if (!hasTypeLevelMapping && !mappedPattern.startsWith("/")) {
                                mappedPattern = "/" + mappedPattern;
                            }
                            addUrlsForPath(urls, mappedPattern);
                            // 添加到mappedPattern中
                            // 并且会确认如果URL中不包含.而且不包含/，则添加url
                            // urls.add(path + ".*");
                        // urls.add(path + "/");
                        }
                    }
                    else if (hasTypeLevelMapping) {
                        // 类包含了URL属性，但是方法却没有，保存一个空的URL
                        // 这里就是上面函数说的hasEmptyMethodLevelMappings为true的情况
                        urls.add(null);
                    }
                }
            }
        }, ReflectionUtils.USER_DECLARED_METHODS);
    }
    return StringUtils.toStringArray(urls);
}

registerHandler 方法

无论是BeanNameUrlHandlerMapping还是DefaultAnnotationHandlerMapping在经过determineUrlsForHandler函数的处理之后，返回的都会是个包含了URL信息的list，接下来就是去注册到各自的容器中去。

protected void registerHandler(String urlPath, Object handler) throws BeansException, IllegalStateException {

    // 获取类信息（包含了注册该bean信息）
    if (!this.lazyInitHandlers && handler instanceof String) {
        String handlerName = (String) handler;
        if (getApplicationContext().isSingleton(handlerName)) {
            resolvedHandler = getApplicationContext().getBean(handlerName);
        }
    }

    Object mappedHandler = this.handlerMap.get(urlPath);
    // 如果该路径已经存在了，而且不是同一个类，则认为出现了冲突
    // 这个在URL设置中，如果出现重复了，就会提示该错误信息了
    if (mappedHandler != null) {
        if (mappedHandler != resolvedHandler) {
            throw new IllegalStateException(
                    "Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +
                    "]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");
        }
    }
    else {
       // 如果是第一次设置的时候
        if (urlPath.equals("/")) {
            if (logger.isInfoEnabled()) {
                logger.info("Root mapping to " + getHandlerDescription(handler));
            }
            // 设置rootHandler
            setRootHandler(resolvedHandler);
        }
        else if (urlPath.equals("/*")) {
            if (logger.isInfoEnabled()) {
                logger.info("Default mapping to " + getHandlerDescription(handler));
            }
            // 设置默认（全量匹配）的defaultHandler
            setDefaultHandler(resolvedHandler);
        }
        else {
           // 往该handlerMap存入该键值对
            this.handlerMap.put(urlPath, resolvedHandler);
            if (logger.isInfoEnabled()) {
                logger.info("Mapped URL path [" + urlPath + "] onto " + getHandlerDescription(handler));
            }
        }
    }
}