Spring @PostMapping Example – @GetMapping Example

Learn to create Spring MVC controllers with @Controller and map requests with request mapping annotations e.g. @RequestMapping, @GetMapping, @PostMapping, @PutMapping, @DeleteMapping and @PatchMapping.

Table of Contents

How to enable and use @Controller
@GetMapping Annotation
@PostMapping Annotation
Summary

1. Spring Controller

1.1. @Controller Annotation

Spring MVC provides annotation based approach where you don’t need to extend any base class to express request mappings, request input parameters, exception handling, and more. @Controller is similar annotation which mark a class as request handler.

package com.howtodoinjava.web;

@Controller
public class HomeController 
{
	@GetMapping("/")
	public String homeInit(Model model) {
		return "home";
	}
}

In above code, HomeController class acts as request controller. It’s homeInit() method will handle all incoming requests to URI "/". It accepts a Model and returns a view name home. This view name is resolved with configured view resolvers.

1.2. Enable component scanning

To let Spring scan and configure @Controller annotated classes, you need to configure component scanning on packages where controllers are stored.

@Configuration
@ComponentScan("com.howtodoinjava.web")
public class WebConfig {
	//Other configurations
}

//or

<context:component-scan base-package="com.howtodoinjava.web"/>

Read More: Spring MVC Example

2. Spring @GetMapping Example

@GetMapping is specialized version of @RequestMapping annotation that acts as a shortcut for @RequestMapping(method = RequestMethod.GET). @GetMapping annotated methods handle the HTTP GET requests matched with given URI expression. e.g.

@GetMapping("/home")
public String homeInit(Model model) {
	return "home";
}

@GetMapping("/members/{id}")
public String getMembers(Model model) {
	return "member";
}

3. Spring @PostMapping Example

@PostMapping is specialized version of @RequestMapping annotation that acts as a shortcut for @RequestMapping(method = RequestMethod.POST). @PostMapping annotated methods handle the HTTP POST requests matched with given URI expression. e.g.

@PostMapping(path = "/members", consumes = "application/json", produces = "application/json")
public void addMember(@RequestBody Member member) {
	//code
}

4. Shared class level attributes

You can declare a shared produces attribute at the class level. When used at the class level, a method-level produces attribute will override the class level declaration.

package com.howtodoinjava.web;

@Controller
@RequestMapping(path = "/", produces = MediaType.APPLICATION_JSON_VALUE)
public class HomeController 
{
	@PostMapping(path = "/members")
	public void addMemberV1(@RequestBody Member member) {
		//code
	}

	@PostMapping(path = "/members", produces = MediaType.APPLICATION_XML_VALUE)
	public void addMemberV2(@RequestBody Member member) {
		//code
	}
}

In above example, addMemberV1() method produces content in default media type i.e. application/json. Second method addMemberV2() overrides produces attribute and will generate content in application/xml type.

5. @PostMapping vs @RequestMapping

1. As noted above @PostMapping annotation is one specialized version of @RequestMapping annotation which handle HTTP POST requests.
2. @PostMapping acts as a shortcut for @RequestMapping(method = RequestMethod.POST).

   @Target({ java.lang.annotation.ElementType.METHOD })
   @Retention(RetentionPolicy.RUNTIME)
   @Documented
   @RequestMapping(method = { RequestMethod.POST })
   public @interface PostMapping 
   {
       //code
   }
   

3. Passing URL information is same in both annotations.

Let’s see the difference between PostMapping and @RequestMapping annotations with simple code.

@RequestMapping(value = "/employees", method = RequestMethod.POST)	//1

@PostMapping("/employees")	//2

6. Summary

Spring MVC has made writing request handlers controller classes and methods very easy. Just add few annotations like @GetMapping and @PostMapping and put the class where component scanning can find them and configure them in web application context.

It is also very easy to create attributes at class level so that all handler methods inherit them by default, and can override them when needed.

Same way, you can use other request mapping annotations e.g. @PutMapping, @DeleteMapping and @PatchMapping.

Happy Learning !!