@Controller vs @RestController in Spring Boot

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (176K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

Hey everyone — welcome back.

In this article, we’re going to clearly understand the difference between @Controller and @RestController in Spring Boot.

These two annotations might seem similar at first glance, but they serve different purposes, especially in how they handle web responses.

We’ll walk through the differences side by side — so if you’re preparing a Spring Boot backend or building APIs, this breakdown will help you decide when to use which.

Let’s dive in.

---

Purpose

Let’s start with the main purpose of each annotation.

@Controller is used in Spring MVC applications where the goal is to return a view — usually an HTML page. It’s part of the traditional Model-View-Controller architecture, where the controller returns a view name, and Spring resolves it to a template like a JSP or Thymeleaf file.

On the other hand, @RestController is used when you’re building RESTful APIs. It returns data — like JSON or XML — directly to the client instead of a view. It’s commonly used in backend services, mobile APIs, or web apps built with JavaScript frameworks.

So, @Controller is for web pages. @RestController is for web services.

---

Response Type

The biggest practical difference is in the response.

With @Controller, if you return a string, Spring Boot assumes it’s a view name. It tries to render a page using that name — for example, returning "home" will make Spring look for a home.html or home.jsp.

But with @RestController, returning a string sends that string as the actual HTTP response body. If you return "Hello", the user will literally see the word "Hello" in the browser or as part of the API response.

So, @RestController tells Spring: "Don't look for a view — just write this to the response body."

---

Composition

Now, let’s talk about what @RestController actually is.

It’s a shortcut annotation. Behind the scenes, @RestController is simply a combination of @Controller and @ResponseBody.

The @ResponseBody part tells Spring to automatically serialize the return value into JSON or XML and write it to the HTTP response.

So instead of writing @Controller on top and @ResponseBody on every method, you can just use @RestController once at the class level. It saves you code and keeps things cleaner.

Here's a clear example that illustrates your explanation:

---

Using @Controller with @ResponseBody on every method:

@Controller
public class MyController {

    @ResponseBody
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, World!";
    }

    @ResponseBody
    @GetMapping("/greet")
    public String greet() {
        return "Greetings!";
    }
}

---

Simplified with @RestController:

@RestController
public class MyRestController {

    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, World!";
    }

    @GetMapping("/greet")
    public String greet() {
        return "Greetings!";
    }
}

---

With @RestController, you don’t need to annotate each method with @ResponseBody—it’s implied. This keeps your code cleaner and more readable.

---

Use Case

So when should you use each one?

Use @Controller when you’re returning HTML views. This is great for server-side rendered pages, admin panels, dashboards, or when you’re building with Thymeleaf, JSP, or Freemarker.

Use @RestController when you’re exposing data. Think of REST APIs for frontend apps, mobile apps, or microservices that send and receive JSON or XML.

So, if your frontend is React or Angular, or if you're building API endpoints, you’ll almost always use @RestController.

---

Example Behavior

Let’s compare how they behave with the same return value.

If you use @Controller and return "dashboard", Spring tries to find a view template named dashboard.html.

But if you use @RestController and return "dashboard", the response is just plain text — it literally returns the word "dashboard" as raw output.

This small change completely shifts how the app responds to the client.

---

Flexibility

You can mix the two annotations in the same application.

For example, your API endpoints can use @RestController, and your admin pages can use @Controller. They work together in the same Spring Boot project — it all depends on your specific needs.

Just remember: if you’re working with views and templates, stick with @Controller. If you’re returning structured data like JSON, go with @RestController.

---

Wrap Up

To wrap it all up:

@Controller is for serving web views like HTML pages. It follows the traditional MVC pattern, and Spring resolves the view using a template engine.

@RestController is for serving data — mostly in JSON format. It’s a shortcut that combines @Controller with @ResponseBody, and it’s perfect for APIs and modern web applications.

Understanding the difference helps you build cleaner, more efficient Spring Boot applications — whether you’re building user interfaces or REST APIs.