Custom Spring annotation for request parameters

Question

I would like to write custom annotations, that would modify Spring request or path parameters according to annotations. For example instead of this code:

@RequestMapping(method = RequestMethod.GET)
public String test(@RequestParam("title") String text) {
   text = text.toUpperCase();
   System.out.println(text);
   return "form";
}

I could make annotation @UpperCase :

@RequestMapping(method = RequestMethod.GET)
   public String test(@RequestParam("title") @UpperCase String text) {
   System.out.println(text);
   return "form";
}

Is it possible and if it is, how could I do it ?

You can also do this with spring AOP; you'd use a method annotated like @Before("@annotation(my.pkg.annotation.UpperCase)"), then transform the parameter in the method. — beerbajay
– beerbajay, Commented Jun 8, 2015 at 17:51

MarCrazyness · Accepted Answer · 2016-06-30 17:14:40Z

52

As the guys said in the comments, you can easily write your annotation driven custom resolver. Four easy steps,

Create an annotation e.g.

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface UpperCase {
    String value();
}

Write a resolver e.g.

public class UpperCaseResolver implements HandlerMethodArgumentResolver {

    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.getParameterAnnotation(UpperCase.class) != null;
    }

    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest,
            WebDataBinderFactory binderFactory) throws Exception {
        UpperCase attr = parameter.getParameterAnnotation(UpperCase.class);
        return webRequest.getParameter(attr.value()).toUpperCase();
    }
}

register a resolver

<mvc:annotation-driven>
        <mvc:argument-resolvers>
            <bean class="your.package.UpperCaseResolver"></bean>
        </mvc:argument-resolvers>
</mvc:annotation-driven>

or the java config

    @Configuration
    @EnableWebMvc
    public class Config extends WebMvcConfigurerAdapter {
    ...
      @Override
      public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
          argumentResolvers.add(new UpperCaseResolver());
      }
    ...
    }

use an annotation in your controller method e.g.

public String test(@UpperCase("foo") String foo)

edited Jun 30, 2016 at 17:14

MarCrazyness

2,1921 gold badge27 silver badges29 bronze badges

answered Jun 8, 2015 at 18:06

Master Slave

28.6k4 gold badges61 silver badges56 bronze badges

Sign up to request clarification or add additional context in comments.

6 Comments

wesker317 Over a year ago

Shouldn't it be : <bean class="your.package.UpperCaseResolver"></bean> ?

hiway Over a year ago

this answer needs a relative high version of springframework. I tried 4.1.4,does not work, 4.2.4 can work.

Tushar Banne Over a year ago

I created a custom annotation of my own. Used it in a sample application. It works fine. But when I tried to Integrate the same code with my project, it doesn't work. Not sure why is it not getting picked up

Martin van Wingerden Over a year ago

Since Spring 5 you should just implement the interface WebMvcConfigurer instead of extending (the now deprecated) WebMvcConfigurerAdapter

tinker_fairy Over a year ago

@master-slave i have used both the mvc:annotation/config but the custom resolver is not getting called in spring mvc project. It works in spring boot application. I dont know spring boot, is it related to spring boot?

|

Kevin Yue · Accepted Answer · 2024-09-19 01:12:48Z

Below is the implementation using Spring AOP. The benefit is that you don't need to specify the request parameter in the annotation and it can be used for any method.

The UpperCase annotation marks the parameter that needs to be converted to uppercase.

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface UpperCase {
}

The UpperCaseAspect class intercepts the method call and converts the parameter to uppercase.

@Aspect
@Component
public class UpperCaseAspect {

    // Match any method that has at least one argument annotated with `@UpperCase`.
    @Around("execution(* *(.., @UpperCase (*), ..))")
    public Object convertToUpperCase(ProceedingJoinPoint joinPoint) throws Throwable {
        Object[] args = joinPoint.getArgs();

        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        Parameter[] parameters = method.getParameters();

        // Find the argument annotated with `@UpperCase`, and replace it with the uppercase value.
        for (int i = 0; i < parameters.length; i++) {
            Parameter parameter = parameters[i];
            if (parameter.isAnnotationPresent(UpperCase.class) && args[i] != null) {
                args[i] = ((String) args[i]).toUpperCase();
            }
        }

        return joinPoint.proceed(args);
    }
}

The @Around expression matches any 1..N annotated parameters regardless of their position in the method signature. (credit to https://stackoverflow.com/a/52889642/2457861)

Use an annotation in your controller method e.g.

@RequestMapping(method = RequestMethod.GET)
public String test(@RequestParam("title") @UpperCase String text) {
   System.out.println(text);
   return "form";
}

public String upperCase(@UpperCase String text) {
    return text;
}

Collectives™ on Stack Overflow

Custom Spring annotation for request parameters

2 Answers 2

6 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

6 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related