Parameter names of the handler method are null in HandlerInterceptor::preHandle during first invocation of an endpoint

[Walti91]

The parameter names from the handler method that is passed to the preHandle method of a HandlerInterceptor are null when the endpoint is called for the first time after the application has been started.

Steps to reproduce:

1. Create a project with the Spring Initializr using Spring Boot version 4.0.0 and the Spring Web Dependency.
2. Add the following code in the DemoApplication

package com.example.demo;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@RestController
@SpringBootApplication
public class DemoApplication {

	public static void main(String[] args) {
		SpringApplication.run(DemoApplication.class, args);
	}

    @GetMapping("test")
    public void test(@RequestParam String test) {

    }

    @Bean
    WebMvcConfigurer webMvcConfigurer() {
        return new WebMvcConfigurer() {

            @Override
            public void addInterceptors(InterceptorRegistry registry) {
                registry.addInterceptor(new TestHandlerInterceptor());
            }
        };
    }

    static class TestHandlerInterceptor implements HandlerInterceptor {

        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
                Object handler) {
            if (handler instanceof HandlerMethod handlerMethod) {
                System.out.println(handlerMethod);

                for (var methodParameter : handlerMethod.getMethodParameters()) {
                    System.out.println("Parameter Index: " + methodParameter.getParameterIndex());
                    System.out.println("Parameter Type: " + methodParameter.getParameterType());
                    System.out.println("Parameter Name: " + methodParameter.getParameterName());
                }
            }

            return true;
        }
    }
}

3. Start the application
4. Call the endpoint: curl localhost:8080/test?test=test
5. The console output shows null for the parameter name

com.example.demo.DemoApplication#test(String)
Parameter Index: 0
Parameter Type: class java.lang.String
Parameter Name: null

6. Call the endpoint again the same way.
7. Now the console output has the parameter name set as expected.

com.example.demo.DemoApplication#test(String)
Parameter Index: 0
Parameter Type: class java.lang.String
Parameter Name: test

As far as i can tell the parameter names are only null during the first call per endpoint in the application and the problem also seems to be isolated to the preHandle method in the Interceptor. The values are correct in the postHandle even during the first call for a endpoint.

[snicoll]

Thanks for the report and the sample, although it is simpler for us if you just share the project rather than us having to apply a set of steps you have on your end already.

It looks like a race condition in MethodParameter and InvocableHandlerMethod that sets ParameterNameDiscoverer. It isn't set on the first request, which explains the null returned on first request.

@jhoeller does that ring a bell?

[dmitrysulman]

I investigated this a bit and @snicoll is right. The ParameterNameDiscoverer is set for the first time inside InvocableHandlerMethod#invokeForRequest, which happens after the interceptors preHandle methods are executed.

A possible solution is to set the ParameterNameDiscoverer in the InvocableHandlerMethod constructors.

Here is a branch with this fix: main...dmitrysulman:spring-framework:36024

If this makes sense, I can create a PR.

[jhoeller]

This effect ultimately originates in InvocableHandlerMethod which is being created late in RequestMappingHandlerAdapter, whereas the preHandle method is being invoked after RequestMappingHandlerMapping initialized a plain HandlerMethod instance for the initial mapping determination. On actual invocation, the InvocableHandlerMethod instance gets constructed from that original plain HandlerMethod instance, reusing its nested MethodParameter instances - and then InvocableHandlerMethod initializes parameter name discovery on those MethodParameter instances, indirectly exposing them through the original HandlerMethod as well.

So in a sense, those parameter names are accidentally exposed on the original HandlerMethod instance due to that internal reuse of MethodParameter instances. The real intended behavior was to consistently expose a raw uninitialized MethodParameter there from the original HandlerMethod instance in preHandle, and then to only use a fully initialized MethodParameter in InvocableHandlerMethod without any leaking back to the original HandlerMethod instance in the mapping.

Anyway, given the existing behavior we should probably rather align toward always exposing parameter names, even for plain HandlerMethod instances in the mapping registry. Unfortunately, this is rather involved and spreads quite a bit beyond InvocableHandlerMethod itself. I'll see what I can do there for 7.0.3.

Thanks for the analysis and the attempt to fix it, in any case!