Difference between the annotations @GetMapping and @RequestMapping(method = RequestMethod.GET)

java

spring-annotations

best-practices

api-design

byAlex Kataev·Feb 5, 2025

@GetMapping is a specialized version of @RequestMapping tailored specifically for HTTP GET requests, leading to cleaner, more readable code. Check this out:

// @GetMapping: Ready for action right out of the box
@GetMapping("/example")
public String getExample() {
  return "GET response; easy, wasn't it?";
}

// @RequestMapping: I promise I also do GET requests
@RequestMapping(value = "/example", method = RequestMethod.GET)
public String verboseGetExample() {
  return "GET response; felt like taking the long road, huh?";
}

Given its simplicity and clarity in handling GET requests, you'd do well to stick to @GetMapping.

A clear advantage: @GetMapping

In modern Spring applications, @GetMapping has emerged as a star player. It offers several advantages:

Easier on the eyes

Compared to its verbose cousin @RequestMapping(value = "/example", method = RequestMethod.GET), the @GetMapping("/example") version is more succinct, leading to improved readability.

Knowing its place

Unlike @RequestMapping which can be applied both at the class and method levels, @GetMapping can only be used at the method level. It's not trying to be everywhere.

Consumes content-type like a champ

Additionally, @GetMapping supports the 'consumes' attribute, allowing you to specify the content types that your method can handle. A nice bowl of type safety, anyone?

The Swiss Army knife: @RequestMapping

While @GetMapping is the popular choice for handling GET requests, @RequestMapping is the Swiss Army knife of annotations - bulkier, but brimming with capabilities.

When change is the only constant

With @RequestMapping at the class level, you keep the door open to handle not just GET, but other HTTP requests, you know, just in case.

Extra bits and pieces

Need more configurations like headers, params, and constraints for acceptable response content types (through produces)? @RequestMapping has got you covered.

Migrating to @GetMapping: A Spring clean-up operation

Moving to Spring Boot and the latest Spring features? Time to show some love to @GetMapping.

Less is more

Refactor to @GetMapping. Not only does it simplify your code, but it also leaves less room for error when specifying the HTTP method.

Consistency is key

Adopt @GetMapping. It sends out a loud and clear message: this method handles a GET request. No more sifting through annotation parameters.

Some tips from the trenches

Don't over-annotate

Annotations are powerful, but with great power comes great responsibility. Use the most specific ones where possible.

Design APIs with clarity

A well-designed API that follows RESTful principles leads to clear and understandable controller methods.

Stay updated with Spring

As Spring evolves, adopt their new features like @GetMapping which bring best practices to your codebase.

explain-codes / Java / Difference between the annotations @GetMapping and @RequestMapping(method = RequestMethod.GET)

Linked

@requestparam vs @PathVariable



Spring MVC - How to get all request params in a map in Spring controller?



Passing multiple variables in @RequestBody to a Spring MVC controller using Ajax



Difference between Spring @Controller and @RestController annotation



How to manage REST API versioning with spring?



What's the difference between @Component, @Repository & @Service annotations in Spring?



How to use multiple @RequestMapping annotations in spring?



A clear advantage: @GetMapping The Swiss Army knife: @RequestMapping Migrating to @GetMapping: A Spring clean-up operation Some tips from the trenches