在运行时更改 Spring RequestMapping 注释值

Question

I am trying to change the value of the RequestMapping annotation at runtime for a HTTP GET method - hello (which returns a simple string) inside a rest service class - SpringRestController .

The value of the uri defined in the @RequestMapping annotation on the hello method is "/hello/{name}" . I am able to change the value of the annotation at runtime to "hi/{name}" using reflection in the constructor of the SpringRestController class.

I am able to verify the modified value by printing the value of the annotation inside an init method annotated with @PostConstruct annotation and also inside another controller. However, when I am trying to access the GET method in a browser:

with the modified value - http://localhost:9090/spring-boot-rest/rest/hi/Pradeep ( does not work )

with the original value - http://localhost:9090/spring-boot-rest/rest/hello/Pradeep ( works fine )

I expect the HTTP GET method hello to be accessible using the modified path value at runtime - "/hi/{name}" instead of the original path value - "/hello/{name}" . PS - This is a requirement for us and needs to be done this way so that value of @RequestMapping can be configured externally without changes to the source code.
Here is the code - SpringRestController.java

package com.example.spring.rest.controller;
import javax.annotation.PostConstruct;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.example.spring.rest.custom.annotations.ConfigurableRequestMapping;
import com.example.spring.rest.reflection.ReflectionUtils;
@RestController
@RequestMapping("/rest")
public class SpringRestController {

    public SpringRestController() {
            RequestMapping rm = SpringRestController.class.getAnnotation(RequestMapping.class);
            System.out.println("Old annotation : " + rm.value()[0]);
            RequestMapping rmNew = new ConfigurableRequestMapping("/rest");
            ReflectionUtils.alterAnnotationValueJDK8_v2(SpringRestController.class, RequestMapping.class, rmNew);
            RequestMapping rmModified = SpringRestController.class.getAnnotation(RequestMapping.class);
            System.out.println("Constructor -> New annotation : " + rmModified.value()[0]);
    }

    @RequestMapping(value = "/hello/{name}")
    public String hello(@PathVariable String name) {
        System.out.println("Name : " + name);
        return "Hello " + name;
    }

    @PostConstruct
    private void init(){
        System.out.println("Annotations initialization post construct.");
        RequestMapping rmModified = SpringRestController.class.getAnnotation(RequestMapping.class);
        System.out.println("Init method -> New annotation : " + rmModified.value()[0]);
    }
}

Code for changing annotation value -

ReflectionUtils.java

package com.example.spring.rest.reflection;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.springframework.web.bind.annotation.RequestMapping;
import com.example.spring.rest.controller.SpringRestController;
import com.example.spring.rest.custom.annotations.ConfigurableRequestMapping;
import com.example.spring.rest.utils.PropertyReader;

public class ReflectionUtils {

    @SuppressWarnings("unchecked")
    public static Object changeAnnotationValue(Annotation annotation, String key, Object newValue){
        Object handler = Proxy.getInvocationHandler(annotation);
        Field f;
        try {
            f = handler.getClass().getDeclaredField("memberValues");
        } catch (NoSuchFieldException | SecurityException e) {
            throw new IllegalStateException(e);
        }
        f.setAccessible(true);
        Map<String, Object> memberValues;
        try {
            memberValues = (Map<String, Object>) f.get(handler);
        } catch (IllegalArgumentException | IllegalAccessException e) {
            throw new IllegalStateException(e);
        }
        Object oldValue = memberValues.get(key);
        if (oldValue == null || oldValue.getClass() != newValue.getClass()) {
            throw new IllegalArgumentException();
        }
        memberValues.put(key,newValue);
        return oldValue;
    }
}

Answer 1

This is not possible to change the annotation value in runtime since Spring already registered that value. Aside from being curious about what do you really try to achieve, feel free to use multiple @PathVariable parameters, and handle the evaluation yourself.

// Either hardcoded values or loaded from elsewhere
private static List<String> GREETINGS = Arrays.asList("Hello", "Hi");

...

@GetMapping(value = "/{greeting}/{name}")
public String greeting(@PathVariable String greeting, @PathVariable String name) {
    System.out.println("Name : " + name);
    if (GREETINGS.stream().anyMatch(greeting::equalsIgnoreCase)) {
        return greeting + " " + name;
    }
    throw new ResponseStatusException(HttpStatus.BAD_REQUEST, 
        "Unknown greeting " + greeting, e);
}

Moreover, the point of the REST API endpoints is to be predictable . What you try to achieve seems like a contradiction to it. You can have multiple endpoints such as /hi/{name} and /hello/{name} , however, in this particular case either the usage of multiple parameters is correct, or this following endpoint that respects the resource and uses @RequestParam . I'd design it rather with this way since greeting is the resource.

• A sample endpoint: /greeting?greeting={greeting}&name={name}
• A sample call: /greeting?greeting=Hello&name=Pradeep%20Prabhakaran