【小家Spring】Spring MVC容器的web九大组件之---HandlerMapping源码详解(一)---BeanNameUrlHandlerMapping系列（下）

// @since 4.3.1 出现得挺晚的接口
public interface MatchableHandlerMapping extends HandlerMapping {
  // 确定给定的请求是否符合请求条件  pattern：模版
  @Nullable
  RequestMatchResult match(HttpServletRequest request, String pattern);
}

// 虽然附加实现了MatchableHandlerMapping ，但本文并不准备详细分析
public abstract class AbstractUrlHandlerMapping extends AbstractHandlerMapping implements MatchableHandlerMapping {
  // 根路径 / 的处理器~
  @Nullable
  private Object rootHandler;
  // 是否使用斜线/匹配   如果为true  那么`/users`它也会匹配上`/users/`  默认是false的
  private boolean useTrailingSlashMatch = false;
  // 设置是否延迟初始化handler。仅适用于单实例handler   默认是false表示立即实例化
  private boolean lazyInitHandlers = false;
  // 这个Map就是缓存下，URL对应的Handler（注意这里只是handler，而不是chain）
  private final Map<String, Object> handlerMap = new LinkedHashMap<>();
  ...
  // 这个就是父类留给子类实现的抽象方法，此抽象类相当于进行了进一步的模版实现~
  @Override
  @Nullable
  protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
    // 找到URL的后半段：如`/api/v1/hello`  由此可见Spring MVC处理URL路径匹配都是从工程名后面开始匹配的~~~~
    String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
    // 根据url查找handler 
    // 1、先去handlerMap里找，若找到了那就实例化它，并且并且给chain里加入一个拦截器：`PathExposingHandlerInterceptor`  它是个private私有类的HandlerInterceptor
    // 该拦截器的作用：request.setAttribute()请求域里面放置四个属性 key见HandlerMapping的常量们~~~
    // 2、否则就使用PathMatcher去匹配URL，这里面光匹配其实是比较简单的。但是这里面还解决了一个问题：那就是匹配上多个路径的问题
    // 因此：若匹配上多个路径了，就按照PathMatcher的排序规则排序，取值get(0)~~~最后就是同上，加上那个HandlerInterceptor即可
    // 需要注意的是：若存在uriTemplateVariables，也就是路径里都存在多个最佳的匹配的情况  比如/book/{id}和/book/{name}这两种。
    // 还有就是URI完全一样，但是一个是get方法，一个是post方法之类的  那就再加一个拦截器`UriTemplateVariablesHandlerInterceptor`  它request.setAttribute()了一个属性：key为 xxx.uriTemplateVariables
    // 这些Attribute后续都是有用滴~~~~~~ 请注意：这里默认的两个拦截器每次都是new出来的和Handler可议说是绑定的，所以不会存在线程安全问题~~~~
    Object handler = lookupHandler(lookupPath, request);
    // 若没找到：
    if (handler == null) {
      // 处理跟路径 / 和默认的Handler~~~~
      Object rawHandler = null;
      if ("/".equals(lookupPath)) {
        rawHandler = getRootHandler();
      }
      if (rawHandler == null) {
        rawHandler = getDefaultHandler();
      }
      if (rawHandler != null) {
        if (rawHandler instanceof String) {
          String handlerName = (String) rawHandler;
          rawHandler = obtainApplicationContext().getBean(handlerName);
        }
        validateHandler(rawHandler, request);
        // 就是注册上面说的默认的两个拦截器~~~~~~~  第四个参数为null，就只会注册一个拦截器~~~
        // 然后把rawHandler转换成chain（这个时候chain里面可能已经有两个拦截器了，然后父类还会继续把用户自定义的拦截器放上去~~~~）
        handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
      }
    }
    return handler;
  }
  // =========该抽象类提供的这个方法就特别重要了：向handlerMap里面put值的唯一入口~~~  可以批量urls
  protected void registerHandler(String[] urlPaths, String beanName) throws BeansException, IllegalStateException {
    Assert.notNull(urlPaths, "URL path array must not be null");
    for (String urlPath : urlPaths) {
      registerHandler(urlPath, beanName);
    }
  }
  protected void registerHandler(String urlPath, Object handler) throws BeansException, IllegalStateException {
    Assert.notNull(urlPath, "URL path must not be null");
    Assert.notNull(handler, "Handler object must not be null");
    Object resolvedHandler = handler;
    // 如果是beanName，并且它是立马加载的~~~~
    if (!this.lazyInitHandlers && handler instanceof String) {
      String handlerName = (String) handler;
      ApplicationContext applicationContext = obtainApplicationContext();
      // 并且还需要是单例的，那就立马实例化吧~~~~
      if (applicationContext.isSingleton(handlerName)) {
        resolvedHandler = applicationContext.getBean(handlerName);
      }
    }
    // 先尝试从Map中去获取
    Object mappedHandler = this.handlerMap.get(urlPath);
    if (mappedHandler != null) {
      // 这个异常错误信息，相信我们在开发中经常碰到吧：简单就是说就是一个URL只能映射到一个Handler上（但是一个Handler是可以处理多个URL的，这个需要注意）
      // 这个校验必不可少啊~~~~
      if (mappedHandler != resolvedHandler) {
        throw new IllegalStateException("Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +
            "]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");
      }
    } else {
      // 如果你的handler处理的路径是根路径，那太好了  你的这个处理器就很特殊啊~~~~
      if (urlPath.equals("/")) {
        setRootHandler(resolvedHandler);
      }
      // 这个路径相当于处理所有  优先级是最低的  所以当作默认的处理器来使用~~~~
      else if (urlPath.equals("/*")) {
        setDefaultHandler(resolvedHandler);
      }
      // 正常的路径了~~~
      // 注意此处：好像是Spring5之后 把这句Mapped的日志级别   直接降低到trace级别了，简直太低了有木有~~~
      // 在Spring 5之前，这里的日志级别包括上面的setRoot等是info（所以我们在控制台经常能看见大片的'Mapped URL path'日志~~~~）
      // 所以：自Spring5之后不再会看controller这样的映射的日志了（除非你日志界别调低~~~）可能Spring认为这种日志多，且不认为是重要的信息吧~~~
      else {
        this.handlerMap.put(urlPath, resolvedHandler);
        if (logger.isTraceEnabled()) {
          logger.trace("Mapped [" + urlPath + "] onto " + getHandlerDescription(handler));
        }
      }
    }
  }
  // 该缓存也提供了一个只读视图给调用者访问~~~
  public final Map<String, Object> getHandlerMap() {
    return Collections.unmodifiableMap(this.handlerMap);
  }
}

// @since 2.5  它Spring2.5后才出来
public abstract class AbstractDetectingUrlHandlerMapping extends AbstractUrlHandlerMapping {
  // 是否要去祖先容器里面检测所有的Handlers    默认是false表示只在自己的容器里面找
  // 若设置为true，相当于在父容器里的Controller也会被挖出来~~~~ 一般我并不建议这么去做
  private boolean detectHandlersInAncestorContexts = false;
  public void setDetectHandlersInAncestorContexts(boolean detectHandlersInAncestorContexts) {
    this.detectHandlersInAncestorContexts = detectHandlersInAncestorContexts;
  }
  // 说白了，这里是检测的入口 detectHandlers();
  @Override
  public void initApplicationContext() throws ApplicationContextException {
    super.initApplicationContext();
    detectHandlers();
  }
  protected void detectHandlers() throws BeansException {
    // 这个就不解释了：默认只会在当前容器里面去查找检测~~~
    // 注意：这里使用的Object.class  说明是把本容器内所有类型的Bean定义都拿出来了~~~~
    String[] beanNames = (this.detectHandlersInAncestorContexts ? BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
        getApplicationContext().getBeanNamesForType(Object.class));
    // Take any bean name that we can determine URLs for.
    for (String beanName : beanNames) {
      // 这是个抽象方法由子类去实现。  它的作用就是看看url和bean怎么才算是匹配呢？也就是说这个handler到底能够处理哪些URL呢？
      // 注意：此处还是类级别（Bean），相当于一个类就是一个Handler哦~~~~
      String[] urls = determineUrlsForHandler(beanName);
      if (!ObjectUtils.isEmpty(urls)) {
        // 注册进去  缓存起来~
        registerHandler(urls, beanName);
      }
    }
  }
}

public class BeanNameUrlHandlerMapping extends AbstractDetectingUrlHandlerMapping {
  @Override
  protected String[] determineUrlsForHandler(String beanName) {
    List<String> urls = new ArrayList<>();
    // 意思就是必须以/开头才行~~~~~~这算是一种约定吧~~~
    // 这种方式和@WebServlet方式一毛一样~~~~~
    if (beanName.startsWith("/")) {
      urls.add(beanName);
    }
    // 当然别名也是可以的
    String[] aliases = obtainApplicationContext().getAliases(beanName);
    for (String alias : aliases) {
      if (alias.startsWith("/")) {
        urls.add(alias);
      }
    }
    return StringUtils.toStringArray(urls);
  }
}

public class SimpleUrlHandlerMapping extends AbstractUrlHandlerMapping {
  private final Map<String, Object> urlMap = new LinkedHashMap<>();
  public void setMappings(Properties mappings) {
    CollectionUtils.mergePropertiesIntoMap(mappings, this.urlMap);
  }
  public void setUrlMap(Map<String, ?> urlMap) {
    this.urlMap.putAll(urlMap);
  }
  @Override
  public void initApplicationContext() throws BeansException {
    super.initApplicationContext();
    registerHandlers(this.urlMap);
  }
  // 这个实现简单到令人发指
  protected void registerHandlers(Map<String, Object> urlMap) throws BeansException {
    if (urlMap.isEmpty()) {
      logger.trace("No patterns in " + formatMappingName());
    } else {
      urlMap.forEach((url, handler) -> {
        // 如果还没有斜线，在前面加上斜线
        if (!url.startsWith("/")) {
          url = "/" + url;
        }
        if (handler instanceof String) {
          handler = ((String) handler).trim();
        }
        registerHandler(url, handler);
      });
    }
  }
}

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
  <property>
    <map>
      <entry key="/hello.do" value="myController"/>
      <entry key="/my.do" value="myController"/>
    </map>
  </property>
</bean>

@Controller("/hello") // 注意此处BeanName必须是/开头，否则是不会作为handler的
public class HelloController { }

org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping.registerHandler Mapped URL path [/hello] onto handler '/hello'

No adapter for handler [com.fsx.controller.HelloController@5e31e1a4]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler

// 实现`org.springframework.web.servlet.mvc.Controller`这个接口,才被认为是一个控制器~
@Controller("/hello")
public class HelloController extends AbstractController {
    @Override
    protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response) throws Exception {
        System.out.println("this is my demo");
        return null;
    }
}