Hello folks, if you are preparing for Java and Spring Developer interview then you may have come across "difference between @Controller and @RestController annotation" in Spring Boot and Spring Framework in general. It's one of the popular spring question which I have also mentioned in my list of 25 Spring Framework questions earlier
In Spring MVC, both @Controller
and @RestController
annotations are used to define web controllers as per MVC Design pattern. A controller is responsible for handling HTTP request and returning HTTP response to client.
The main difference between these two annotation is how they handle client's request and when they are used
For example @Controller annotation is there from day 1 and it is used to mark a class as a web controller to process HTTP requests and return a view name, which is then resolved by a view resolver to generate the final HTML view.
On the other hand @RestController
annotation was added in later Spring version like Spring 3.4 to increase support for REST API development. In case of REST API, instead of returning HTML, you will probably like to return JSON or XML as your client is no more human but machine.
If you want to return a JSON or XML from a Spring MVC controller then you need to add @ReseponseBody annotation to each of Controller method and it seems overkill while implementing REST APIs using Spring and Spring Boot.
Designers and developers of Spring Framework recognized this shortcoming and then added a new annotation called @RestController in Spring 3.4 version.
The @RestController
annotation is a combination of the @Controller
and @ResponseBody
annotations and you can use it to implement REST APIs in Java and Spring Boot.
The key difference between
@Controler
and@RestController
annotation is @ResponseBody annotation,@
Controler
does not automatically add the@ResponseBody
annotation to all of the controller's methods, which means that you need to add it to each method individually if you want to return a JSON or XML response.@RestController
automatically adds the@ResponseBody
annotation to all of the controller's methods.
In the past, I have shared many questions for Java developer interviews like these 35 Java Interview Questions, Advanced Java Interview Questions, Spring Framework Interview Questions and System Design Questions and today, I have answered one of the popular spring question, if you are preparing for interviews, you can also check out those articles.
Now let's see examples of both @Controller and @RestController annotation in Spring framework
@Controller and @RestController Example in Spring Boot
Here is a simple example of @Controller
annotation which is used to return a response for simple HTTP request on "/hello"
path:
@Controller
public class MyController {
@Autowired\
private MyService myService;
@RequestMapping("/hello")\
public String sayHello(Model model) {\
model.addAttribute("message", myService.getHelloMessage());\
return "hello";\
}\
}
In this example, the MyController
class is annotated with @Controller
annotation and has a single method, sayHello()
, which is mapped to the /hello
URL.
The method takes a Model
object as a parameter and adds an attribute called "message"
to it. The method then returns a string "hello", which is the name of the view to be rendered.
Now, let's see an example of @RestController
annotation from Spring Framework, which i used to respond REST API
@RestController\
public class MyRestController {
@Autowired\
private MyService myService;
@RequestMapping("/greeting")\
public Greeting getGreeting() {\
return myService.getGreeting();\
}\
}
In this example, the MyRestController
class is annotated with @RestController
and has a single method, getGreeting()
, which is mapped to the /greeting
URL.
The method returns an object of the Greeting
class, which will be automatically converted to a JSON or XML representation and sent as the response to the client.
It is also worth noting that the Greeting
class should have getters
and setters
for the data that you want to be included in the response, otherwise, it will not be serialized properly or converted to JSON.
@Controller and @RestController annotation in Spring Boot
Here are a few things to keep in mind while using the @Controller
and @RestController
annotations:
- When using the @Controller annotation, you will need to use the @ResponseBody annotation to return JSON or XML data, otherwise, the response will be treated as a view name and a view resolver will try to resolve it while @ResponseBody annotation is not necessary as it is already included in the annotation.
- When using the @RestController annotation, you can also use the @ResponseStatus annotation to set the HTTP status code of the response and @RequestBody annotation to bind the request body to a method parameter.
- And while using the @RestController annotation, you can use the @RequestMapping annotation to set the URL path to map the methods to.
- Another thing which is worth noting is that, If you are returning a complex object that contains child objects, make sure all the child object classes have getters and setters, otherwise, they will not be serialized properly.
That's all about the difference between @Controller and @RestController annotation in Spring Boot. Just remember that @Controller is used to create web controllers that return views, which is further resolved by view resolver, while @RestController
is used to create web services that return JSON or XML data. It's also worth noting.
Top comments (0)