Spring @Controller, @GetMapping and @PostMapping 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

How to enable and use @Controller

Spring @Controller Annotation Usage

Spring MVC provides annotation based approach where you don’t need to extend any base class to express request mappings, request input, 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.

Enable @Controller 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

@GetMapping Annotation

It 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";
}

@PostMapping Annotation

It 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
}

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/json type.

Summary

Spring MVC has made writing request handlers controller classes and methods very easy. Just add few annotations 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 !!