Spring Webflux DispatcherHandler源码整理

DispatcherHandler的构造(以RequestMappingHandlerMapping为例)

1. WebFluxAutoConfiguration中EnableWebFluxConfiguration继承WebFluxConfigurationSupport

   @Bean
   public DispatcherHandler webHandler() {
       return new DispatcherHandler();
   }
   

2. DispatcherHandler#setApplicationContext => initStrategies(applicationContext)

   protected void initStrategies(ApplicationContext context) {
       Map mappingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
               context, HandlerMapping.class, true, false);
       ArrayList mappings = new ArrayList<>(mappingBeans.values());
       AnnotationAwareOrderComparator.sort(mappings);
       this.handlerMappings = Collections.unmodifiableList(mappings);
       //
       Map adapterBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
               context, HandlerAdapter.class, true, false);
       //
       this.handlerAdapters = new ArrayList<>(adapterBeans.values());
       AnnotationAwareOrderComparator.sort(this.handlerAdapters);
       //
       Map beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
               context, HandlerResultHandler.class, true, false);
       this.resultHandlers = new ArrayList<>(beans.values());
       AnnotationAwareOrderComparator.sort(this.resultHandlers);
   }
   

3. RequestMappingHandlerMapping-> afterPropertiesSet -> AbstractHandlerMethodMapping.initHandlerMethods

   protected void initHandlerMethods() {
        String[] beanNames = obtainApplicationContext().getBeanNamesForType(Object.class);
        for (String beanName : beanNames) {
            if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
                Class beanType = obtainApplicationContext().getType(beanName);
                // 当类被Controller或则RequestMapping标注时查找HandlerMethod
                if (beanType != null && isHandler(beanType)) {
                    detectHandlerMethods(beanName);
                }
            }
        }
    }
   

4. AbstractHandlerMethodMapping#detectHandlerMethods(beanName)

    protected void detectHandlerMethods(final Object handler) {
        Class handlerType = (handler instanceof String ?
                obtainApplicationContext().getType((String) handler) : handler.getClass());
        if (handlerType != null) {
            final Class userType = ClassUtils.getUserClass(handlerType);
            Map methods = MethodIntrospector.selectMethods(userType,
                    (MethodIntrospector.MetadataLookup) method -> getMappingForMethod(method, userType));
            methods.forEach((method, mapping) -> {
                Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
                // invocableMethod保存到MappingRegistry注册表中
                registerHandlerMethod(handler, invocableMethod, mapping);
            });
        }
    }
   

5. RequestMappingHandlerMapping#getMappingForMethod(method, handlerType)

   protected RequestMappingInfo getMappingForMethod(Method method, Class handlerType) {
        RequestMappingInfo info = createRequestMappingInfo(method);
        if (info != null) {
            RequestMappingInfo typeInfo = createRequestMappingInfo(handlerType);
            if (typeInfo != null) {
                info = typeInfo.combine(info);
            }
            for (Map.Entry>> entry : this.pathPrefixes.entrySet()) {
                if (entry.getValue().test(handlerType)) {
                    String prefix = entry.getKey();
                    if (this.embeddedValueResolver != null) {
                        prefix = this.embeddedValueResolver.resolveStringValue(prefix);
                    }
                    info = RequestMappingInfo.paths(prefix).options(this.config).build().combine(info);
                    break;
                }
            }
        }
        return info;
   }
   

6. RequestMappingHandlerMapping#createRequestMappingInfo(method)

   private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
        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
    			.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();
    }
   

DispatcherHandler的执行(以RequestMappingHandlerMapping为例)

查找handler

1. DispatcherHandler#handle(exchange)

   public Mono handle(ServerWebExchange exchange) {
       if (CorsUtils.isPreFlightRequest(exchange.getRequest())) {
           return handlePreFlight(exchange);
       }
       return Flux.fromIterable(this.handlerMappings)
               .concatMap(mapping -> mapping.getHandler(exchange))
               .next()
               .switchIfEmpty(createNotFoundError())
               .flatMap(handler -> invokeHandler(exchange, handler))
               .flatMap(result -> handleResult(exchange, result));
   }
   

2. AbstractHandlerMapping#getHandler(exchange)

   public Mono