← 返回学习路线

SYSTEM

请求映射

Java基础请求映射system
src/content/notes/system/请求映射.md

请求映射

映射器

doDispatch() 中调用 getHandler 方法获取所有的映射器

总体流程:

  • 所有的请求映射都在 HandlerMapping 中,RequestMappingHandlerMapping 处理 @RequestMapping 注解的映射规则

  • 遍历所有的 HandlerMapping 看是否可以匹配当前请求,匹配成功后返回,匹配失败设置 HTTP 404 响应码

  • 用户可以自定义的映射处理,也可以给容器中放入自定义 HandlerMapping

访问 URL:http://localhost:8080/user

@GetMapping("/user")
public String getUser(){
    return "GET";
}
@PostMapping("/user")
public String postUser(){
    return "POST";
}
//。。。。。

HandlerMapping 处理器映射器,保存了所有 @RequestMapping 和 handler 的映射规则

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    if (this.handlerMappings != null) {
        // 遍历所有的 HandlerMapping
        for (HandlerMapping mapping : this.handlerMappings) {
            // 尝试去每个 HandlerMapping 中匹配当前请求的处理
            HandlerExecutionChain handler = mapping.getHandler(request);
            if (handler != null) {
                return handler;
            }
        }
    }
    return null;
}

  • mapping.getHandler(request):调用 AbstractHandlerMapping#getHandler

    • Object handler = getHandlerInternal(request):获取映射器,底层调用 RequestMappingInfoHandlerMapping 类的方法,又调用 AbstractHandlerMethodMapping#getHandlerInternal

      • String lookupPath = initLookupPath(request):地址栏的 URI,这里的 lookupPath 为 /user

      • this.mappingRegistry.acquireReadLock():加读锁防止其他线程并发修改

      • handlerMethod = lookupHandlerMethod(lookupPath, request):获取当前 HandlerMapping 中的映射规则

        • directPathMatches = this.mappingRegistry.getMappingsByDirectPath(lookupPath):获取当前的映射器与当前请求的 URI 有关的所有映射规则

        • addMatchingMappings(directPathMatches, matches, request):匹配某个映射规则

          • for (T mapping : mappings):遍历所有的映射规则
          • match = getMatchingMapping(mapping, request):去匹配每一个映射规则,匹配失败返回 null
          • matches.add(new Match()):匹配成功后封装成匹配器添加到匹配集合中
        • matches.sort(comparator):匹配集合排序

        • Match bestMatch = matches.get(0):匹配完成只剩一个,直接获取返回对应的处理方法

        • if (matches.size() > 1):当有多个映射规则符合请求时,报错

        • return bestMatch.getHandlerMethod():返回匹配器中的处理方法

    • executionChain = getHandlerExecutionChain(handler, request):为当前请求和映射器的构建一个拦截器链

      • for (HandlerInterceptor interceptor : this.adaptedInterceptors):遍历所有的拦截器
      • chain.addInterceptor(interceptor):把所有的拦截器添加到 HandlerExecutionChain 中,形成拦截器链
    • return executionChain:返回拦截器链,HandlerMapping 是链的 handler 成员属性


适配器

doDispatch() 中调用 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler())

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
    if (this.handlerAdapters != null) {
        // 遍历所有的 HandlerAdapter
        for (HandlerAdapter adapter : this.handlerAdapters) {
            // 判断当前适配器是否支持当前 handle
            if (adapter.supports(handler)) {
                // 返回的是 【RequestMappingHandlerAdapter】
                // AbstractHandlerMethodAdapter#supports -> RequestMappingHandlerAdapter
                return adapter;
            }
        }
    }
    throw new ServletException();
}

方法执行

实例代码:

@GetMapping("/params")
public String param(Map<String, Object> map, Model model, HttpServletRequest request) {
    map.put("k1", "v1");			// 都可以向请求域中添加数据
    model.addAttribute("k2", "v2");	// 它们两个都在数据封装在 【BindingAwareModelMap】,继承自 LinkedHashMap
    request.setAttribute("m", "HelloWorld");
    return "forward:/success";
}

doDispatch() 中调用 mv = ha.handle(processedRequest, response, mappedHandler.getHandler()) 使用适配器执行方法

AbstractHandlerMethodAdapter#handle → RequestMappingHandlerAdapter#handleInternal → invokeHandlerMethod:

protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
                                           HttpServletResponse response, 
                                           HandlerMethod handlerMethod) throws Exception {
	// 封装成 SpringMVC 的接口,用于通用 Web 请求拦截器,使能够访问通用请求元数据,而不是用于实际处理请求
    ServletWebRequest webRequest = new ServletWebRequest(request, response);
    try {
        // WebDataBinder 用于【从 Web 请求参数到 JavaBean 对象的数据绑定】,获取创建该实例的工厂
        WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
        // 创建 Model 实例,用于向模型添加属性
        ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
		// 方法执行器
        ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
        
        // 参数解析器,有很多
        if (this.argumentResolvers != null) {
            invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
        }
        // 返回值处理器,也有很多
        if (this.returnValueHandlers != null) {
            invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
        }
        // 设置数据绑定器
        invocableMethod.setDataBinderFactory(binderFactory);
        // 设置参数检查器
		invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
   
        // 新建一个 ModelAndViewContainer 并进行初始化和一些属性的填充
        ModelAndViewContainer mavContainer = new ModelAndViewContainer();
            
        // 设置一些属性
        
        // 【执行目标方法】
        invocableMethod.invokeAndHandle(webRequest, mavContainer);
        // 异步请求
        if (asyncManager.isConcurrentHandlingStarted()) {
            return null;
        }
		// 【获取 ModelAndView 对象,封装了 ModelAndViewContainer】
        return getModelAndView(mavContainer, modelFactory, webRequest);
    }
    finally {
        webRequest.requestCompleted();
    }
}

ServletInvocableHandlerMethod#invokeAndHandle:执行目标方法

  • returnValue = invokeForRequest(webRequest, mavContainer, providedArgs):执行自己写的 controller 方法,返回的就是自定义方法中 return 的值

    Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs):参数处理的逻辑,遍历所有的参数解析器解析参数或者将 URI 中的参数进行绑定,绑定完成后开始执行目标方法

    • parameters = getMethodParameters():获取此处理程序方法的方法参数的详细信息

    • Object[] args = new Object[parameters.length]:存放所有的参数

    • for (int i = 0; i < parameters.length; i++):遍历所有的参数

    • args[i] = findProvidedArgument(parameter, providedArgs):获取调用方法时提供的参数,一般是空

    • if (!this.resolvers.supportsParameter(parameter)):获取可以解析当前参数的参数解析器

      return getArgumentResolver(parameter) != null:获取参数的解析是否为空

      • for (HandlerMethodArgumentResolver resolver : this.argumentResolvers):遍历容器内所有的解析器

        if (resolver.supportsParameter(parameter)):是否支持当前参数

        • PathVariableMethodArgumentResolver#supportsParameter:解析标注 @PathVariable 注解的参数
        • ModelMethodProcessor#supportsParameter:解析 Map 和 Model 类型的参数,Model 和 Map 的作用一样
        • ExpressionValueMethodArgumentResolver#supportsParameter:解析标注 @Value 注解的参数
        • RequestParamMapMethodArgumentResolver#supportsParameter:解析标注 @RequestParam 注解
        • RequestPartMethodArgumentResolver#supportsParameter:解析文件上传的信息
        • ModelAttributeMethodProcessor#supportsParameter:解析标注 @ModelAttribute 注解或者不是简单类型
          • 子类 ServletModelAttributeMethodProcessor 是解析自定义类型 JavaBean 的解析器
          • 简单类型有 Void、Enum、Number、CharSequence、Date、URI、URL、Locale、Class
    • args[i] = this.resolvers.resolveArgument():开始解析参数,每个参数使用的解析器不同

      resolver = getArgumentResolver(parameter):获取参数解析器

      return resolver.resolveArgument():开始解析

      • PathVariableMapMethodArgumentResolver#resolveArgument:@PathVariable,包装 URI 中的参数为 Map
      • MapMethodProcessor#resolveArgument:调用 mavContainer.getModel() 返回默认 BindingAwareModelMap 对象
      • ModelAttributeMethodProcessor#resolveArgument:自定义的 JavaBean 的绑定封装,下一小节详解

    return doInvoke(args):真正的执行 Controller 方法

    • Method method = getBridgedMethod():从 HandlerMethod 获取要反射执行的方法
    • ReflectionUtils.makeAccessible(method):破解权限
    • method.invoke(getBean(), args):执行方法,getBean 获取的是标记 @Controller 的 Bean 类,其中包含执行方法
  • 进行返回值的处理,响应部分详解,处理完成进入下面的逻辑

RequestMappingHandlerAdapter#getModelAndView:获取 ModelAndView 对象

  • modelFactory.updateModel(webRequest, mavContainer):Model 数据升级到会话域(请求域中的数据在重定向时丢失)

    • updateBindingResult(request, defaultModel):把绑定的数据添加到 BindingAwareModelMap 中
  • if (mavContainer.isRequestHandled()):判断请求是否已经处理完成了

  • ModelMap model = mavContainer.getModel():获取包含 Controller 方法参数的 BindingAwareModelMap(本节开头)

  • mav = new ModelAndView():把 ModelAndViewContainer 和 ModelMap 中的数据封装到 ModelAndView

  • if (!mavContainer.isViewReference()):是否是通过名称指定视图引用

  • if (model instanceof RedirectAttributes):判断 model 是否是重定向数据,如果是进行重定向逻辑

  • return mav:任何方法执行都会返回 ModelAndView 对象


参数解析

解析自定义的 JavaBean 为例,调用 ModelAttributeMethodProcessor#resolveArgument 处理参数的方法,通过合适的类型转换器把 URL 中的参数转换以后,利用反射获取 set 方法,注入到 JavaBean

  • Person.java:

    @Data
    @Component	//加入到容器中
    public class Person {
        private String userName;
        private Integer age;
        private Date birth;
    }
  • Controller:

    @RestController	//返回的数据不是页面
    public class ParameterController {
        // 数据绑定:页面提交的请求数据(GET、POST)都可以和对象属性进行绑定
        @GetMapping("/saveuser")
        public Person saveuser(Person person){
            return person;
        }
    }
  • 访问 URL:http://localhost:8080/saveuser?userName=zhangsan&age=20

进入源码:ModelAttributeMethodProcessor#resolveArgument

  • name = ModelFactory.getNameForParameter(parameter):获取名字,此例就是 person

  • ann = parameter.getParameterAnnotation(ModelAttribute.class):是否有 ModelAttribute 注解

  • if (mavContainer.containsAttribute(name)):ModelAndViewContainer 中是否包含 person 对象

  • attribute = createAttribute():创建一个实例,空的 Person 对象

  • binder = binderFactory.createBinder(webRequest, attribute, name):Web 数据绑定器,可以利用 Converters 将请求数据转成指定的数据类型,绑定到 JavaBean 中

  • bindRequestParameters(binder, webRequest):利用反射向目标对象填充数据

    servletBinder = (ServletRequestDataBinder) binder:类型强转

    servletBinder.bind(servletRequest):绑定数据

    • mpvs = new MutablePropertyValues(request.getParameterMap()):获取请求 URI 参数中的 k-v 键值对

    • addBindValues(mpvs, request):子类可以用来为请求添加额外绑定值

    • doBind(mpvs):真正的绑定的方法,调用 applyPropertyValues 应用参数值,然后调用 setPropertyValues 方法

      AbstractPropertyAccessor#setPropertyValues():

      • List<PropertyValue> propertyValues:获取到所有的参数的值,就是 URI 上的所有的参数值

      • for (PropertyValue pv : propertyValues):遍历所有的参数值

      • setPropertyValue(pv):填充到空的 Person 实例中

        • nestedPa = getPropertyAccessorForPropertyPath(propertyName):获取属性访问器

        • tokens = getPropertyNameTokens():获取元数据的信息

        • nestedPa.setPropertyValue(tokens, pv):填充数据

        • processLocalProperty(tokens, pv):处理属性

          • if (!Boolean.FALSE.equals(pv.conversionNecessary)):数据是否需要转换了

          • if (pv.isConverted()):数据已经转换过了,转换了直接赋值,没转换进行转换

          • oldValue = ph.getValue():获取未转换的数据

          • valueToApply = convertForProperty():进行数据转换

            TypeConverterDelegate#convertIfNecessary:进入该方法的逻辑

            • if (conversionService.canConvert(sourceTypeDesc, typeDescriptor)):判断能不能转换

              GenericConverter converter = getConverter(sourceType, targetType):获取类型转换器

              • converter = this.converters.find(sourceType, targetType):寻找合适的转换器

                • sourceCandidates = getClassHierarchy(sourceType.getType()):原数据类型

                • targetCandidates = getClassHierarchy(targetType.getType()):目标数据类型

                  for (Class<?> sourceCandidate : sourceCandidates) {
                      //双重循环遍历,寻找合适的转换器
                   	for (Class<?> targetCandidate : targetCandidates) {
                • GenericConverter converter = getRegisteredConverter(..):匹配类型转换器

                • return converter:返回转换器

            • conversionService.convert(newValue, sourceTypeDesc, typeDescriptor):开始转换

              • converter = getConverter(sourceType, targetType):获取可用的转换器
              • result = ConversionUtils.invokeConverter():执行转换方法
                • converter.convert():调用转换器的转换方法(GenericConverter#convert)
              • return handleResult(sourceType, targetType, result):返回结果
          • ph.setValue(valueToApply):设置 JavaBean 属性(BeanWrapperImpl.BeanPropertyHandler)

            • Method writeMethod:获取写数据方法
              • Class<?> cls = getClass0():获取 Class 对象
              • writeMethodName = Introspector.SET_PREFIX + getBaseName():set 前缀 + 属性名
              • writeMethod = Introspector.findMethod(cls, writeMethodName, 1, args):获取只包含一个参数的 set 方法
              • setWriteMethod(writeMethod):加入缓存
            • ReflectionUtils.makeAccessible(writeMethod):设置访问权限
            • writeMethod.invoke(getWrappedInstance(), value):执行方法
  • bindingResult = binder.getBindingResult():获取绑定的结果

  • mavContainer.addAllAttributes(bindingResultModel):把所有填充的参数放入 ModelAndViewContainer

  • return attribute:返回填充后的 Person 对象