Spring 源码解析

文章15 |   阅读 8471 |   点赞0

来源：https://github.com/senntyou/blogs

Spring 源码解析六：处理器映射与处理器适配处理

x33g5p2x  于2022-02-11 发布在 Spring  
字(29.7k)|赞(0)|评价(0)|浏览(505)

在 Spring 源码解析一：SpringMVC 的加载机制 中，留有一些点待解析：

  1. ConfigurableWebApplicationContext.refresh 刷新上下文
  2. ApplicationContext.getBean 从上下文中获取 bean
  3. DispatcherServlet.properties 文件中定义的策略处理
  4. ContextLoader.properties 文件中定义的策略处理
  5. View.render 视图渲染

其中第一、二、四条已在Spring 源码解析二：上下文组件(WebApplicationContext)中解析了，这一节来看看后面第三条：DispatcherServlet.properties 文件中定义的策略处理

DispatcherServlet.properties
文件内容如下：

  1. org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver
  3. org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver
  5. org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
  6.     org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,\
  7.     org.springframework.web.servlet.function.support.RouterFunctionMapping
  9. org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
  10.     org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
  11.     org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter,\
  12.     org.springframework.web.servlet.function.support.HandlerFunctionAdapter
  15. org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
  16.     org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
  17.     org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver
  19. org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator
  21. org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver
  23. org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

DispatcherServlet.properties 文件中指明：

LocaleResolver、ThemeResolver、FlashMapManager 策略比较简单，这里就不解析了

1. BeanNameUrlHandlerMapping

BeanNameUrlHandlerMapping
的主要功能是映射 url 到 bean

继承关系如下

  1. - AbstractHandlerMapping
  2.   - AbstractUrlHandlerMapping
  3.     - AbstractDetectingUrlHandlerMapping
  4.       - BeanNameUrlHandlerMapping

1.1. AbstractHandlerMapping

AbstractHandlerMapping
的主要功能是支持处理器排序、指定默认处理器、处理器拦截等

  1. public abstract class AbstractHandlerMapping extends WebApplicationObjectSupport
  2.         implements HandlerMapping, Ordered, BeanNameAware {
  3.     // 获取处理器
  4.     public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
  5.         // 获取匹配的处理器
  6.         Object handler = getHandlerInternal(request);
  7.         // 没有匹配的处理器，则获取默认的处理器
  8.         if (handler == null) {
  9.             handler = getDefaultHandler();
  10.         }
  11.         // 没有处理器，返回null
  12.         if (handler == null) {
  13.             return null;
  14.         }
  15.         // handler是String的话，当做一个bean名字去获取bean实例
  16.         if (handler instanceof String) {
  17.             String handlerName = (String) handler;
  18.             handler = obtainApplicationContext().getBean(handlerName);
  19.         }
  21.         // 获取处理器执行链
  22.         HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
  24.         // ... 代码省略
  26.         return executionChain;
  27.     }
  29.     // 获取匹配的处理器，子类实现
  30.     protected abstract Object getHandlerInternal(HttpServletRequest request) throws Exception;
  32.     // 获取处理器执行链
  33.     protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
  34.         // 创建处理器执行链
  35.         HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
  36.                 (HandlerExecutionChain) handler : new HandlerExecutionChain(handler));
  38.         // 添加连接器，如安全验证、CORS、CSRF等
  39.         for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
  40.             if (interceptor instanceof MappedInterceptor) {
  41.                 MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
  42.                 if (mappedInterceptor.matches(request)) {
  43.                     chain.addInterceptor(mappedInterceptor.getInterceptor());
  44.                 }
  45.             }
  46.             else {
  47.                 chain.addInterceptor(interceptor);
  48.             }
  49.         }
  50.         return chain;
  51.     }
  52. }

1.2. AbstractUrlHandlerMapping

AbstractUrlHandlerMapping
的主要功能是实现 url 映射

先来看看 handler 的注册

  1. public abstract class AbstractUrlHandlerMapping extends AbstractHandlerMapping implements MatchableHandlerMapping {
  2.     // 容器 urlPath => handler
  3.     private final Map<String, Object> handlerMap = new LinkedHashMap<>();
  4.     // 容器 urlPattern => handler
  5.     private final Map<PathPattern, Object> pathPatternHandlerMap = new LinkedHashMap<>();
  7.     // 注册一个handler
  8.     protected void registerHandler(String urlPath, Object handler) throws BeansException, IllegalStateException {
  9.         Object resolvedHandler = handler;
  11.         // handler是String的话，当做一个bean名字去获取bean实例
  12.         if (handler instanceof String) {
  13.             String handlerName = (String) handler;
  14.             ApplicationContext applicationContext = obtainApplicationContext();
  15.             if (applicationContext.isSingleton(handlerName)) {
  16.                 resolvedHandler = applicationContext.getBean(handlerName);
  17.             }
  18.         }
  20.         Object mappedHandler = this.handlerMap.get(urlPath);
  21.         if (mappedHandler != null) {
  22.             if (mappedHandler != resolvedHandler) {
  23.                 // 已经注册过了，报错
  24.             }
  25.         }
  26.         else {
  27.             if (urlPath.equals("/")) {
  28.                 // 设为根处理器，只匹配 /
  29.                 setRootHandler(resolvedHandler);
  30.             }
  31.             else if (urlPath.equals("/*")) {
  32.                 // 设为默认处理器，匹配所有
  33.                 setDefaultHandler(resolvedHandler);
  34.             }
  35.             else {
  36.                 // 装进容器
  37.                 this.handlerMap.put(urlPath, resolvedHandler);
  38.                 if (getPatternParser() != null) {
  39.                     // 装进模式匹配的容器
  40.                     this.pathPatternHandlerMap.put(getPatternParser().parse(urlPath), resolvedHandler);
  41.                 }
  42.             }
  43.         }
  44.     }
  45. }

再来看看 handler 的获取

  1. public abstract class AbstractUrlHandlerMapping extends AbstractHandlerMapping implements MatchableHandlerMapping {
  2.     // 获取匹配的处理器
  3.     @Override
  4.     protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
  5.         // 获取真实的path部分
  6.         String lookupPath = initLookupPath(request);
  7.         Object handler;
  9.         // 使用模式匹配
  10.         if (usesPathPatterns()) {
  11.             RequestPath path = ServletRequestPathUtils.getParsedRequestPath(request);
  12.             handler = lookupHandler(path, lookupPath, request);
  13.         }
  14.         // 直接匹配路径
  15.         else {
  16.             handler = lookupHandler(lookupPath, request);
  17.         }
  19.         // 如果都没有
  20.         if (handler == null) {
  21.             Object rawHandler = null;
  22.             // 如果是 /，则调用根处理器
  23.             if (StringUtils.matchesCharacter(lookupPath, '/')) {
  24.                 rawHandler = getRootHandler();
  25.             }
  26.             // 如果仍没有，获取默认的解析器，/*
  27.             if (rawHandler == null) {
  28.                 rawHandler = getDefaultHandler();
  29.             }
  30.             if (rawHandler != null) {
  31.                 // handler是String的话，当做一个bean名字去获取bean实例
  32.                 if (rawHandler instanceof String) {
  33.                     String handlerName = (String) rawHandler;
  34.                     rawHandler = obtainApplicationContext().getBean(handlerName);
  35.                 }
  36.                 // 包裹handler为HandlerExecutionChain
  37.                 handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
  38.             }
  39.         }
  40.         return handler;
  41.     }
  43.     // 查找处理器
  44.     protected Object lookupHandler(
  45.             RequestPath path, String lookupPath, HttpServletRequest request) throws Exception {
  46.         // 直接通过lookupPath获取处理器
  47.         Object handler = getDirectMatch(lookupPath, request);
  48.         // 存在就返回
  49.         if (handler != null) {
  50.             return handler;
  51.         }
  53.         // 用模式匹配
  54.         List<PathPattern> matches = null;
  55.         for (PathPattern pattern : this.pathPatternHandlerMap.keySet()) {
  56.             if (pattern.matches(path.pathWithinApplication())) {
  57.                 matches = (matches != null ? matches : new ArrayList<>());
  58.                 matches.add(pattern);
  59.             }
  60.         }
  61.         // 没有匹配的模式，返回null
  62.         if (matches == null) {
  63.             return null;
  64.         }
  66.         // ... 代码省略
  68.         // 获取第一个匹配的模式
  69.         PathPattern pattern = matches.get(0);
  70.         // 获取第一个匹配的模式处理器
  71.         handler = this.pathPatternHandlerMap.get(pattern);
  72.         // handler是String的话，当做一个bean名字去获取bean实例
  73.         if (handler instanceof String) {
  74.             String handlerName = (String) handler;
  75.             handler = obtainApplicationContext().getBean(handlerName);
  76.         }
  78.         // 提取pattern匹配的部分，如
  79.         // '/docs/cvs/commit.html' and '/docs/cvs/commit.html' => ''
  80.         // '/docs/*' and '/docs/cvs/commit' => 'cvs/commit'
  81.         // '/docs/cvs/*.html' and '/docs/cvs/commit.html' => 'commit.html'
  82.         // '/docs/**' and '/docs/cvs/commit' => 'cvs/commit'
  83.         PathContainer pathWithinMapping = pattern.extractPathWithinPattern(path.pathWithinApplication());
  84.         // 包裹handler为HandlerExecutionChain
  85.         return buildPathExposingHandler(handler, pattern.getPatternString(), pathWithinMapping.value(), null);
  86.     }
  87. }

1.3. AbstractDetectingUrlHandlerMapping

AbstractDetectingUrlHandlerMapping
的主要功能是侦测上下文中的 bean，然后注册 handler

  1. public abstract class AbstractDetectingUrlHandlerMapping extends AbstractUrlHandlerMapping {
  2.     // 初始化上下文后，侦测上下文中的bean，然后注册handler
  3.     @Override
  4.     public void initApplicationContext() throws ApplicationContextException {
  5.         super.initApplicationContext();
  6.         detectHandlers();
  7.     }
  9.     // 侦测上下文中的bean，然后注册handler
  10.     protected void detectHandlers() throws BeansException {
  11.         ApplicationContext applicationContext = obtainApplicationContext();
  12.         // 使用Object.class，就是获取所有的bean
  13.         String[] beanNames = (this.detectHandlersInAncestorContexts ?
  14.                 BeanFactoryUtils.beanNamesForTypeIncludingAncestors(applicationContext, Object.class) :
  15.                 applicationContext.getBeanNamesForType(Object.class));
  17.         // 遍历beanNames
  18.         for (String beanName : beanNames) {
  19.             // 获取一个handler的多个url匹配
  20.             String[] urls = determineUrlsForHandler(beanName);
  21.             // 如果是url=>bean的匹配，就注册
  22.             // 如果beanName是以斜线"/"开头的，则认为是url
  23.             if (!ObjectUtils.isEmpty(urls)) {
  24.                 // 注册url和beanName
  25.                 registerHandler(urls, beanName);
  26.             }
  27.         }
  28.     }
  31.     // 获取一个handler的多个url匹配，由子类实现
  32.     protected abstract String[] determineUrlsForHandler(String beanName);
  33. }

1.4. BeanNameUrlHandlerMapping

BeanNameUrlHandlerMapping
的主要功能是侦测 handler 的 url

  1. public class BeanNameUrlHandlerMapping extends AbstractDetectingUrlHandlerMapping {
  2.     // 侦测handler的url
  3.     @Override
  4.     protected String[] determineUrlsForHandler(String beanName) {
  5.         List<String> urls = new ArrayList<>();
  6.         // 如果beanName是 / 开头，表示是url
  7.         if (beanName.startsWith("/")) {
  8.             urls.add(beanName);
  9.         }
  10.         String[] aliases = obtainApplicationContext().getAliases(beanName);
  11.         for (String alias : aliases) {
  12.             // 如果别名是 / 开头，表示是url
  13.             if (alias.startsWith("/")) {
  14.                 urls.add(alias);
  15.             }
  16.         }
  17.         return StringUtils.toStringArray(urls);
  18.     }
  19. }

2. RequestMappingHandlerMapping

RequestMappingHandlerMapping
的主要功能是处理@RequestMapping与@Controller注解

继承关系如下

  1. - AbstractHandlerMapping
  2.   - AbstractHandlerMethodMapping
  3.     - RequestMappingInfoHandlerMapping
  4.       - RequestMappingHandlerMapping

2.1. AbstractHandlerMethodMapping

AbstractHandlerMethodMapping
的主要功能是定义 request 到 HandlerMethod 映射

先来看看 handler 的注册

  1. public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping implements InitializingBean {
  2.     // 注册一个映射
  3.     public void registerMapping(T mapping, Object handler, Method method) {
  4.         this.mappingRegistry.register(mapping, handler, method);
  5.     }
  7.     // 当属性都注入后，由上下文环境调用此方法初始化
  8.     @Override
  9.     public void afterPropertiesSet() {
  10.         initHandlerMethods();
  11.     }
  13.     // 初始化所有处理器方法
  14.     protected void initHandlerMethods() {
  15.         // 获取上下文环境所有的bean
  16.         for (String beanName : getCandidateBeanNames()) {
  17.             // beanName以"scopedTarget."开头
  18.             if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
  19.                 processCandidateBean(beanName);
  20.             }
  21.         }
  23.         // ... 代码省略
  24.     }
  26.     // 处理bean
  27.     protected void processCandidateBean(String beanName) {
  28.         Class<?> beanType = null;
  29.         try {
  30.             beanType = obtainApplicationContext().getType(beanName);
  31.         }
  32.         catch (Throwable ex) {
  33.             // ... 代码省略
  34.         }
  35.         // 如果有`@RequestMapping`与`@Controller`注解，则是处理器
  36.         if (beanType != null && isHandler(beanType)) {
  37.             // 探测处理器方法
  38.             detectHandlerMethods(beanName);
  39.         }
  40.     }
  42.     // 探测处理器方法
  43.     protected void detectHandlerMethods(Object handler) {
  44.         // 获取bean类型
  45.         Class<?> handlerType = (handler instanceof String ?
  46.                 obtainApplicationContext().getType((String) handler) : handler.getClass());
  48.         if (handlerType != null) {
  49.             Class<?> userType = ClassUtils.getUserClass(handlerType);
  50.             // 查找bean类型上的方法
  51.             Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
  52.                     (MethodIntrospector.MetadataLookup<T>) method -> {
  53.                         try {
  54.                             // 包裹为RequestMappingInfo
  55.                             return getMappingForMethod(method, userType);
  56.                         }
  57.                         catch (Throwable ex) {
  58.                             // ... 代码省略
  59.                         }
  60.                     });
  62.             methods.forEach((method, mapping) -> {
  63.                 // 使用mappingRegistry注册处理器映射
  64.                 registerHandlerMethod(handler, method, mapping);
  65.             });
  66.         }
  67.     }
  68. }

再来看看 handler 的获取

  1. public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping implements InitializingBean {
  2.     // 获取匹配的处理器
  3.     @Override
  4.     protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
  5.         // 获取真实的path部分
  6.         String lookupPath = initLookupPath(request);
  8.         // ... 代码省略
  10.         try {
  11.             // 获取path匹配的方法处理器
  12.             HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
  13.             // handlerMethod的bean是String的话，当做一个bean名字去获取bean实例
  14.             return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
  15.         }
  16.         finally {
  17.             // ... 代码省略
  18.         }
  19.     }
  21.     // 获取path匹配的方法处理器
  22.     protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
  23.         List<Match> matches = new ArrayList<>();
  25.         // 直接匹配path
  26.         List<T> directPathMatches = this.mappingRegistry.getMappingsByDirectPath(lookupPath);
  27.         // 直接匹配到了path
  28.         if (directPathMatches != null) {
  29.             // 添加匹配映射到matches中
  30.             addMatchingMappings(directPathMatches, matches, request);
  31.         }
  32.         // 如果没有直接匹配到path
  33.         if (matches.isEmpty()) {
  34.             // 把所有的注册模式拿来匹配
  35.             addMatchingMappings(this.mappingRegistry.getRegistrations().keySet(), matches, request);
  36.         }
  37.         // 匹配到了
  38.         if (!matches.isEmpty()) {
  39.             // 默认取第一个匹配
  40.             Match bestMatch = matches.get(0);
  41.             if (matches.size() > 1) {
  42.                 // 如果匹配到了多个模式，则进行排序，取最优的
  43.                 Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
  44.                 matches.sort(comparator);
  45.                 bestMatch = matches.get(0);
  47.                 // ... 代码省略
  48.             }
  50.             // ... 代码省略
  52.             return bestMatch.handlerMethod;
  53.         }
  54.         else {
  55.             // 未匹配到，返回null
  56.             return handleNoMatch(this.mappingRegistry.getRegistrations().keySet(), lookupPath, request);
  57.         }
  58.     }
  59. }

对处理器的注册与管理，其实都是内部类 RequestMappingHandlerMapping.MappingRegistry
完成的

  1. class MappingRegistry {
  2.     // 处理器注册容器
  3.     private final Map<T, MappingRegistration<T>> registry = new HashMap<>();
  4.     // 路径查找容器
  5.     private final MultiValueMap<String, T> pathLookup = new LinkedMultiValueMap<>();
  6.     // 名字查找容器
  7.     private final Map<String, List<HandlerMethod>> nameLookup = new ConcurrentHashMap<>();
  9.     // 注册一个处理器
  10.     public void register(T mapping, Object handler, Method method) {
  11.         try {
  12.             // 包裹为HandlerMethod
  13.             HandlerMethod handlerMethod = createHandlerMethod(handler, method);
  15.             // 获取非模式匹配的路径
  16.             Set<String> directPaths = AbstractHandlerMethodMapping.this.getDirectPaths(mapping);
  17.             for (String path : directPaths) {
  18.                 // 添加到路径查找容器
  19.                 this.pathLookup.add(path, mapping);
  20.             }
  22.             String name = null;
  23.             if (getNamingStrategy() != null) {
  24.                 // 获取bean名字
  25.                 name = getNamingStrategy().getName(handlerMethod, mapping);
  26.                 // 添加到名字查找容器
  27.                 addMappingName(name, handlerMethod);
  28.             }
  30.             // ... 代码省略
  32.             // 添加到处理器注册容器
  33.             this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directPaths, name));
  34.         }
  35.         finally {
  36.             // ... 代码省略
  37.         }
  38.     }
  39. }

2.2. RequestMappingInfoHandlerMapping

RequestMappingInfoHandlerMapping
的主要功能是通过 RequestMappingInfo 实现 request 到 HandlerMethod 映射

  1. public abstract class RequestMappingInfoHandlerMapping extends AbstractHandlerMethodMapping<RequestMappingInfo> {
  2.     // 检查请求与路径映射是否匹配
  3.     @Override
  4.     protected void handleMatch(RequestMappingInfo info, String lookupPath, HttpServletRequest request) {
  5.         super.handleMatch(info, lookupPath, request);
  7.         // 获取模式匹配的条件
  8.         RequestCondition<?> condition = info.getActivePatternsCondition();
  9.         // 路径匹配，会解析通配符，如*?
  10.         if (condition instanceof PathPatternsRequestCondition) {
  11.             extractMatchDetails1((PathPatternsRequestCondition) condition, lookupPath, request);
  12.         }
  13.         // 普通字符串匹配
  14.         else {
  15.             extractMatchDetails2((PatternsRequestCondition) condition, lookupPath, request);
  16.         }
  18.         // ... 代码省略
  19.     }
  21.     // 路径匹配，会解析通配符，如*?
  22.     private void extractMatchDetails1(
  23.             PathPatternsRequestCondition condition, String lookupPath, HttpServletRequest request) {
  24.         // 最佳匹配
  25.         PathPattern bestPattern;
  26.         // uri变量，如 /path/:userId/:page
  27.         Map<String, String> uriVariables;
  29.         // 匹配到空字符串 ""
  30.         if (condition.isEmptyPathMapping()) {
  31.             bestPattern = condition.getFirstPattern();
  32.             uriVariables = Collections.emptyMap();
  33.         }
  34.         else {
  35.             PathContainer path = ServletRequestPathUtils.getParsedRequestPath(request).pathWithinApplication();
  36.             bestPattern = condition.getFirstPattern();
  37.             // PathPattern解析匹配，并提取变量（PathPattern是AntPathMatcher的增强版）
  38.             PathPattern.PathMatchInfo result = bestPattern.matchAndExtract(path);
  40.             uriVariables = result.getUriVariables();
  42.             // ... 代码省略
  43.         }
  45.         // ... 代码省略
  46.     }
  48.     // 普通字符串匹配
  49.     private void extractMatchDetails2(
  50.             PatternsRequestCondition condition, String lookupPath, HttpServletRequest request) {
  51.         // 最佳匹配
  52.         PathPattern bestPattern;
  53.         // uri变量，如 /path/:userId/:page
  54.         Map<String, String> uriVariables;
  56.         // 匹配到空字符串 ""
  57.         if (condition.isEmptyPathMapping()) {
  58.             bestPattern = lookupPath;
  59.             uriVariables = Collections.emptyMap();
  60.         }
  61.         else {
  62.             bestPattern = condition.getPatterns().iterator().next();
  63.             // AntPathMatcher解析匹配，并提取变量
  64.             uriVariables = getPathMatcher().extractUriTemplateVariables(bestPattern, lookupPath);
  65.             uriVariables = getUrlPathHelper().decodePathVariables(request, uriVariables);
  66.         }
  68.         // ... 代码省略
  69.     }
  70. }

2.3. RequestMappingHandlerMapping

RequestMappingHandlerMapping
的主要功能是实现@RequestMapping与@Controller注解的处理器映射注册

  1. public class RequestMappingHandlerMapping extends RequestMappingInfoHandlerMapping
  2.         implements MatchableHandlerMapping, EmbeddedValueResolverAware {
  3.     // 获取方法的映射信息
  4.     @Override
  5.     protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
  6.         RequestMappingInfo info = createRequestMappingInfo(method);
  7.         if (info != null) {
  8.             RequestMappingInfo typeInfo = createRequestMappingInfo(handlerType);
  9.             if (typeInfo != null) {
  10.                 info = typeInfo.combine(info);
  11.             }
  12.             String prefix = getPathPrefix(handlerType);
  13.             if (prefix != null) {
  14.                 info = RequestMappingInfo.paths(prefix).options(this.config).build().combine(info);
  15.             }
  16.         }
  17.         return info;
  18.     }
  20.     // 创建映射信息对象
  21.     private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
  22.         // 找到@RequestMapping注解
  23.         RequestMapping requestMapping = AnnotatedElementUtils.findMergedAnnotation(element, RequestMapping.class);
  25.         // ... 代码省略
  27.         return (requestMapping != null ? createRequestMappingInfo(requestMapping, condition) : null);
  28.     }
  30.     // 根据RequestMapping创建映射信息对象
  31.     protected RequestMappingInfo createRequestMappingInfo(
  32.             RequestMapping requestMapping, @Nullable RequestCondition<?> customCondition) {
  34.         RequestMappingInfo.Builder builder = RequestMappingInfo
  35.                 // path元信息
  36.                 .paths(resolveEmbeddedValuesInPatterns(requestMapping.path()))
  37.                 // method元信息
  38.                 .methods(requestMapping.method())
  39.                 // params元信息
  40.                 .params(requestMapping.params())
  41.                 // headers元信息
  42.                 .headers(requestMapping.headers())
  43.                 // consumes元信息
  44.                 .consumes(requestMapping.consumes())
  45.                 // produces元信息
  46.                 .produces(requestMapping.produces())
  47.                 // name元信息
  48.                 .mappingName(requestMapping.name());
  49.         if (customCondition != null) {
  50.             builder.customCondition(customCondition);
  51.         }
  52.         return builder.options(this.config).build();
  53.     }
  54. }

3. RouterFunctionMapping

RouterFunctionMapping
的主要功能是实现对RouterFunction
的支持，使用 RouterFunctions.route 来定义路由，比如

  1. @Configuration
  2. public class MyRoutes {
  3.     @Bean
  4.     RouterFunction<ServerResponse> home() {
  5.         return route(GET("/"), request -> ok().body(fromObject("Home page")));
  6.     }
  8.     @Bean
  9.     RouterFunction<ServerResponse> about() {
  10.         return route(GET("/about"), request -> ok().body(fromObject("About page")));
  11.     }
  12. }

RouterFunctionMapping 继承关系如下

  1. - AbstractHandlerMapping
  2.   - RouterFunctionMapping
  1. public class RouterFunctionMapping extends AbstractHandlerMapping implements InitializingBean {
  2.     // 当属性都注入后，由上下文环境调用此方法初始化
  3.     @Override
  4.     public void afterPropertiesSet() throws Exception {
  5.         if (this.routerFunction == null) {
  6.             // 初始化RouterFunction
  7.             initRouterFunction();
  8.         }
  10.         // ... 代码省略
  11.     }
  13.     // 初始化RouterFunction
  14.     private void initRouterFunction() {
  15.         ApplicationContext applicationContext = obtainApplicationContext();
  16.         // 获取RouterFunction的bean
  17.         Map<String, RouterFunction> beans =
  18.                 (this.detectHandlerFunctionsInAncestorContexts ?
  19.                         BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, RouterFunction.class) :
  20.                         applicationContext.getBeansOfType(RouterFunction.class));
  22.         List<RouterFunction> routerFunctions = new ArrayList<>(beans.values());
  24.         // 把这些bean组合起来
  25.         this.routerFunction = routerFunctions.stream()
  26.                 .reduce(RouterFunction::andOther)
  27.                 .orElse(null);
  28.     }
  30.     // 获取匹配的处理器
  31.     @Override
  32.     protected Object getHandlerInternal(HttpServletRequest servletRequest) throws Exception {
  33.         if (this.routerFunction != null) {
  34.             ServerRequest request = ServerRequest.create(servletRequest, this.messageConverters);
  35.             setAttributes(servletRequest, request);
  37.             // 使用routerFunction来路由请求，没有则返回null
  38.             return this.routerFunction.route(request).orElse(null);
  39.         }
  40.         else {
  41.             return null;
  42.         }
  43.     }
  44. }

4. RequestMappingHandlerAdapter

HttpRequestHandlerAdapter与SimpleControllerHandlerAdapter策略比较简单，这里就不解析了

RequestMappingHandlerAdapter
的主要功能是支持 @RequestMapping 定义路由适配调用

继承关系如下

  1. - WebContentGenerator
  2.   - AbstractHandlerMethodAdapter
  3.     - RequestMappingHandlerAdapter

WebContentGenerator
的主要功能是处理响应的头信息，如Pragma、Expires、Cache-Control等

AbstractHandlerMethodAdapter
的主要功能是支持响应 HandlerMethod

  1. public abstract class AbstractHandlerMethodAdapter extends WebContentGenerator implements HandlerAdapter, Ordered {
  2.     // 调用处理器，响应请求
  3.     public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
  4.             throws Exception {
  6.         return handleInternal(request, response, (HandlerMethod) handler);
  7.     }
  9.     // 调用处理器，响应请求，子类实现
  10.     protected abstract ModelAndView handleInternal(HttpServletRequest request,
  11.             HttpServletResponse response, HandlerMethod handlerMethod) throws Exception;
  12. }

现在来看 RequestMappingHandlerAdapter

4.1. RequestMappingHandlerAdapter.afterPropertiesSet

  1. public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
  2.         implements BeanFactoryAware, InitializingBean {
  3.     // 当属性都注入后，由上下文环境调用此方法初始化
  4.     @Override
  5.     public void afterPropertiesSet() {
  6.         // 初始化`@ControllerAdvice`注解标注的组件
  7.         initControllerAdviceCache();
  9.         if (this.argumentResolvers == null) {
  10.             // 获取默认的参数解析器
  11.             List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
  12.             this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
  13.         }
  14.         if (this.initBinderArgumentResolvers == null) {
  15.             // 获取默认的@InitBinder解析器
  16.             List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers();
  17.             this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
  18.         }
  19.         if (this.returnValueHandlers == null) {
  20.             // 获取默认的响应值处理器
  21.             List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
  22.             this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
  23.         }
  24.     }
  26.     // 初始化`@ControllerAdvice`注解标注的组件
  27.     private void initControllerAdviceCache() {
  28.         // ... 代码省略
  30.         // 获取有`@ControllerAdvice`注解的bean
  31.         List<ControllerAdviceBean> adviceBeans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
  32.         // 可用的bean
  33.         List<Object> requestResponseBodyAdviceBeans = new ArrayList<>();
  34.         // 进行遍历
  35.         for (ControllerAdviceBean adviceBean : adviceBeans) {
  36.             Class<?> beanType = adviceBean.getBeanType();
  37.             if (beanType == null) {
  38.                 // 没有类型，报错
  39.             }
  40.             // 查找有`@RequestMapping`与`@ModelAttribute`注解的方法
  41.             Set<Method> attrMethods = MethodIntrospector.selectMethods(beanType, MODEL_ATTRIBUTE_METHODS);
  42.             if (!attrMethods.isEmpty()) {
  43.                 // 添加进容器
  44.                 this.modelAttributeAdviceCache.put(adviceBean, attrMethods);
  45.             }
  46.             // 查找有`@InitBinder`注解的方法
  47.             Set<Method> binderMethods = MethodIntrospector.selectMethods(beanType, INIT_BINDER_METHODS);
  48.             if (!binderMethods.isEmpty()) {
  49.                 // 添加进容器
  50.                 this.initBinderAdviceCache.put(adviceBean, binderMethods);
  51.             }
  52.             // 如何bean类型是RequestBodyAdvice或ResponseBodyAdvice的子类
  53.             if (RequestBodyAdvice.class.isAssignableFrom(beanType) || ResponseBodyAdvice.class.isAssignableFrom(beanType)) {
  54.                 // 添加进容器
  55.                 requestResponseBodyAdviceBeans.add(adviceBean);
  56.             }
  57.         }
  59.         if (!requestResponseBodyAdviceBeans.isEmpty()) {
  60.             // 添加进容器
  61.             this.requestResponseBodyAdvice.addAll(0, requestResponseBodyAdviceBeans);
  62.         }
  64.         // ... 代码省略
  65.     }
  66. }
  1. public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
  2.         implements BeanFactoryAware, InitializingBean {
  3.     // 获取默认的参数解析器
  4.     private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {
  5.         List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>(30);
  7.         // @RequestParam 解析
  8.         resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
  9.         resolvers.add(new RequestParamMapMethodArgumentResolver());
  10.         // @PathVariable 解析
  11.         resolvers.add(new PathVariableMethodArgumentResolver());
  12.         resolvers.add(new PathVariableMapMethodArgumentResolver());
  13.         // @MatrixVariable 解析
  14.         resolvers.add(new MatrixVariableMethodArgumentResolver());
  15.         resolvers.add(new MatrixVariableMapMethodArgumentResolver());
  16.         // 数据绑定解析
  17.         resolvers.add(new ServletModelAttributeMethodProcessor(false));
  18.         // @RequestBody @ResponseBody 解析
  19.         resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
  20.         // @RequestPart 解析
  21.         resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters(), this.requestResponseBodyAdvice));
  22.         // @RequestHeader 解析
  23.         resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory()));
  24.         resolvers.add(new RequestHeaderMapMethodArgumentResolver());
  25.         // Cookie 解析
  26.         resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory()));
  27.         // @Value 解析
  28.         resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));
  29.         // @SessionAttribute 解析
  30.         resolvers.add(new SessionAttributeMethodArgumentResolver());
  31.         // @RequestAttribute 解析
  32.         resolvers.add(new RequestAttributeMethodArgumentResolver());
  34.         // 从原生 ServletRequest 对象的输入流中解析请求头、请求体等
  35.         resolvers.add(new ServletRequestMethodArgumentResolver());
  36.         // 把处理器最终的数据写入到原生 ServletResponse 对象的输出流中，包括响应头、响应体等
  37.         resolvers.add(new ServletResponseMethodArgumentResolver());
  38.         // HttpEntity 处理
  39.         resolvers.add(new HttpEntityMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
  40.         // 重定向处理
  41.         resolvers.add(new RedirectAttributesMethodArgumentResolver());
  42.         // Model 处理
  43.         resolvers.add(new ModelMethodProcessor());
  44.         // Map 处理
  45.         resolvers.add(new MapMethodProcessor());
  46.         // 错误方法解析
  47.         resolvers.add(new ErrorsMethodArgumentResolver());
  48.         // SessionStatus 解析
  49.         resolvers.add(new SessionStatusMethodArgumentResolver());
  50.         // UriComponentsBuilder 解析
  51.         resolvers.add(new UriComponentsBuilderMethodArgumentResolver());
  53.         // ... 代码省略
  55.         return resolvers;
  56.     }
  58.     // 获取默认的@InitBinder解析器
  59.     private List<HandlerMethodArgumentResolver> getDefaultInitBinderArgumentResolvers() {
  60.         List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>(20);
  62.         resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
  63.         resolvers.add(new RequestParamMapMethodArgumentResolver());
  64.         resolvers.add(new PathVariableMethodArgumentResolver());
  65.         resolvers.add(new PathVariableMapMethodArgumentResolver());
  66.         resolvers.add(new MatrixVariableMethodArgumentResolver());
  67.         resolvers.add(new MatrixVariableMapMethodArgumentResolver());
  68.         resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));
  69.         resolvers.add(new SessionAttributeMethodArgumentResolver());
  70.         resolvers.add(new RequestAttributeMethodArgumentResolver());
  72.         resolvers.add(new ServletRequestMethodArgumentResolver());
  73.         resolvers.add(new ServletResponseMethodArgumentResolver());
  75.         // ... 代码省略
  77.         return resolvers;
  78.     }
  79. }
  1. public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
  2.         implements BeanFactoryAware, InitializingBean {
  3.     // 获取默认的响应值处理器
  4.     private List<HandlerMethodReturnValueHandler> getDefaultReturnValueHandlers() {
  5.         List<HandlerMethodReturnValueHandler> handlers = new ArrayList<>(20);
  7.         // ModelAndView 处理
  8.         handlers.add(new ModelAndViewMethodReturnValueHandler());
  9.         // Model 处理
  10.         handlers.add(new ModelMethodProcessor());
  11.         // View 处理
  12.         handlers.add(new ViewMethodReturnValueHandler());
  13.         // ResponseBodyEmitter 处理
  14.         handlers.add(new ResponseBodyEmitterReturnValueHandler(getMessageConverters(),
  15.                 this.reactiveAdapterRegistry, this.taskExecutor, this.contentNegotiationManager));
  16.         // StreamingResponseBody 处理
  17.         handlers.add(new StreamingResponseBodyReturnValueHandler());
  18.         // HttpEntity 处理
  19.         handlers.add(new HttpEntityMethodProcessor(getMessageConverters(),
  20.                 this.contentNegotiationManager, this.requestResponseBodyAdvice));
  21.         // HttpHeaders 处理
  22.         handlers.add(new HttpHeadersReturnValueHandler());
  23.         // Callable 处理
  24.         handlers.add(new CallableMethodReturnValueHandler());
  25.         // DeferredResult 处理
  26.         handlers.add(new DeferredResultMethodReturnValueHandler());
  27.         // WebAsyncTask 处理
  28.         handlers.add(new AsyncTaskMethodReturnValueHandler(this.beanFactory));
  30.         // 数据绑定解析
  31.         handlers.add(new ServletModelAttributeMethodProcessor(false));
  32.         // @RequestBody @ResponseBody 解析
  33.         handlers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(),
  34.                 this.contentNegotiationManager, this.requestResponseBodyAdvice));
  36.         // 视图名字处理
  37.         handlers.add(new ViewNameMethodReturnValueHandler());
  38.         // Map 处理
  39.         handlers.add(new MapMethodProcessor());
  41.         // ... 代码省略
  43.         return handlers;
  44.     }
  45. }

上面的这些解析器和处理器，都在 web/servlet/mvc/method/annotation
包和 web/method/annotation
包下，后面再具体解析

4.2. RequestMappingHandlerAdapter.handleInternal

  1. public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
  2.         implements BeanFactoryAware, InitializingBean {
  3.     // 调用处理器，响应请求
  4.     @Override
  5.     protected ModelAndView handleInternal(HttpServletRequest request,
  6.             HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
  7.         // 响应对象，可能是视图、数据、视图数据绑定
  8.         ModelAndView mav;
  10.         // ... 代码省略
  12.         // 调用处理器
  13.         mav = invokeHandlerMethod(request, response, handlerMethod);
  15.         // ... 代码省略
  17.         return mav;
  18.     }
  20.     // 调用处理器
  21.     protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
  22.             HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
  23.         // 请求对象
  24.         ServletWebRequest webRequest = new ServletWebRequest(request, response);
  25.         try {
  26.             // 处理`@ControllerAdvice`与`@InitBinder`，并注入参数解析器argumentResolvers
  27.             // 再加上响应模型的数据绑定，生成一个绑定工厂binderFactory
  28.             WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
  29.             // 把binderFactory绑定到模型上，并注入参数解析器argumentResolvers
  30.             // 生成一个模型工厂modelFactory
  31.             ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
  33.             // 封装成一个对象
  34.             ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
  35.             if (this.argumentResolvers != null) {
  36.                 // 注入参数解析器argumentResolvers
  37.                 invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
  38.             }
  39.             if (this.returnValueHandlers != null) {
  40.                 // 注入响应处理returnValueHandlers
  41.                 invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
  42.             }
  43.             // 设置数据绑定工厂
  44.             invocableMethod.setDataBinderFactory(binderFactory);
  46.             // ... 代码省略
  48.             // 响应容器
  49.             ModelAndViewContainer mavContainer = new ModelAndViewContainer();
  50.             // 初始化模型及容器
  51.             modelFactory.initModel(webRequest, mavContainer, invocableMethod);
  53.             // ... 代码省略
  55.             // 调用处理器，获取处理结果，应用响应处理returnValueHandlers
  56.             invocableMethod.invokeAndHandle(webRequest, mavContainer);
  58.             // ... 代码省略
  60.             // 获取最终的ModelAndView
  61.             return getModelAndView(mavContainer, modelFactory, webRequest);
  62.         }
  63.         finally {
  64.             // 标记当前请求为已完成
  65.             webRequest.requestCompleted();
  66.         }
  67.     }
  69.     // 获取最终的ModelAndView
  70.     private ModelAndView getModelAndView(ModelAndViewContainer mavContainer,
  71.             ModelFactory modelFactory, NativeWebRequest webRequest) throws Exception {
  72.         // 更新模型工厂数据
  73.         modelFactory.updateModel(webRequest, mavContainer);
  74.         // 如果是已经处理过了，返回null
  75.         if (mavContainer.isRequestHandled()) {
  76.             return null;
  77.         }
  78.         // 获取模型对象
  79.         ModelMap model = mavContainer.getModel();
  80.         // 生成ModelAndView
  81.         ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, mavContainer.getStatus());
  83.         // ... 代码省略
  85.         // 处理重定向
  86.         if (model instanceof RedirectAttributes) {
  87.             // ... 代码省略
  88.         }
  89.         return mav;
  90.     }
  91. }

5. HandlerFunctionAdapter

HandlerFunctionAdapter
的主要功能是实现对RouterFunction
的适配处理

  1. public class HandlerFunctionAdapter implements HandlerAdapter, Ordered {
  2.     @Override
  3.     public ModelAndView handle(HttpServletRequest servletRequest,
  4.             HttpServletResponse servletResponse,
  5.             Object handler) throws Exception {
  7.         // ... 代码省略
  9.         ServerRequest serverRequest = getServerRequest(servletRequest);
  10.         ServerResponse serverResponse;
  12.         // ... 代码省略
  14.         // 直接调用HandlerFunction.handle方法处理
  15.         HandlerFunction<?> handlerFunction = (HandlerFunction<?>) handler;
  16.         serverResponse = handlerFunction.handle(serverRequest);
  18.         if (serverResponse != null) {
  19.             // 把响应数据直接写入到原生的ServletResponse对象输出流中
  20.             return serverResponse.writeTo(servletRequest, servletResponse, new ServerRequestContext(serverRequest));
  21.         }
  22.         else {
  23.             return null;
  24.         }
  25.     }
  26. }

后续

更多博客，查看 https://github.com/senntyou/blogs

作者：深予之 (@senntyou)

版权声明：自由转载-非商用-非衍生-保持署名（创意共享 3.0 许可证）

内容来源于网络，如有侵权，请联系作者删除！

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com