Spring MVC Architecture

Spring MVC is a powerful framework for building web applications in Java. It follows the Model-View-Controller (MVC) design pattern, which separates an application into three main components: Model, View, and Controller. This separation makes your application scalable, maintainable, and easier to test.

What is MVC?

MVC stands for Model-View-Controller, a software design pattern used to organize code into three interconnected layers:

Model

• Represents the data and business logic of the application.
• Responsible for retrieving, processing, and saving data, often interacting with the database.
• Examples: User entity, Order entity, Service classes.

View

• Represents the user interface (UI).
• Displays data to the user and handles presentation.
• Can be HTML pages, JSON responses, XML, or templates.
• Examples: JSP, Thymeleaf, Angular/React frontend consuming REST API.

Controller

• Acts as a bridge between the Model and View.
• Handles user requests, calls the Model, and returns a response (View).
• Examples: Spring @Controller or @RestController classes.

Simplified Flow:

User → Controller → Model → Controller → View → User

Think of it like a restaurant:

• Model → Kitchen (prepares data/food)
• View → Dining table (shows food to the customer)
• Controller → Waiter (takes order and serves food)

Core Components of Spring MVC

Spring MVC is built around several key components that work together to handle web requests, process data, and render responses. Understanding these components is essential for building maintainable and efficient web applications.

1. DispatcherServlet

• Role: The front controller of Spring MVC.
• Function: Intercepts all HTTP requests and forwards them to the appropriate handler (controller).
• Analogy: Think of it as the main traffic controller of your application.
• Spring Boot Note: Automatically configured; no XML setup needed.

Example:

Userhits → <http://localhost:8080/users/1>

The request first goes to DispatcherServlet, not directly to the controller.

2. HandlerMapping

• Role: Maps incoming requests (URLs) to the correct controller methods.
• Function: Determines which controller should handle a request based on path, HTTP method, headers, or parameters.

Example:

@GetMapping("/users/{id}")
public UsergetUserById(@PathVariable Long id) { ... }

Request:

GET /users/1

➡️ HandlerMapping maps this request to UserController.getUserById()

3. HandlerAdapter

• Role: Executes the controller method selected by HandlerMapping.
• Function: Converts HTTP request data into method arguments and invokes the controller.
• Benefit: Allows Spring MVC to support different types of controllers.

Example:

@GetMapping("/users/{id}")
public UsergetUserById(@PathVariable Long id) { ... }

HandlerAdapter:

• Reads {id} from URL
• Converts it to Long
• Calls getUserById(1L)

4. Controller

• Role: Contains the request-handling logic.
• Function: Interacts with business logic and returns a response (View or JSON).

Annotations:

• @Controller → HTML/JSP views
• @RestController → REST APIs (JSON/XML)

Example (REST API):

@RestController
@RequestMapping("/users")
publicclassUserController {

@GetMapping("/{id}")
public UsergetUser(@PathVariable Long id) {
return userService.findById(id);
    }
}

Response:

{
"id":1,
"name":"Rahul"
}

5. Model

• Role: Holds the data to be displayed in the view.
• Function: Transfers data from Controller to View.
• Types: Model, ModelMap, ModelAndView, DTOs.

Example:

@GetMapping("/profile")
public StringshowProfile(Model model) {
    model.addAttribute("username","Amit");
return"profile";
}

Model contains:

username → Amit

6. ViewResolver

• Role: Maps logical view names to actual UI templates.
• Function: Resolves which template should render the response.

Example:

return"profile";

ViewResolver maps it to:

/WEB-INF/views/profile.jsp

or

profile.html (Thymeleaf)

7. View

• Role: Responsible for rendering the final response.
• Function: Displays Model data as HTML, JSON, XML, etc.

Example (JSP):

<h1>Welcome, ${username}</h1>

Rendered Output:

Welcome, Amit

Example (REST):

{
"id":1,
"name":"Amit"
}

Summary Table

How Spring MVC Works (Step-by-Step)

1. User sends a request to the server (clicks a link, submits a form, or calls an API).
2. DispatcherServlet intercepts the request and acts as the front controller.
3. HandlerMapping identifies the controller method that should handle the request.
4. HandlerAdapter invokes the controller method.
5. Controller interacts with Model (service layer or database) to fetch or update data.
6. Controller returns data and logical view name to DispatcherServlet.
7. ViewResolver selects the correct template or format.
8. View renders the response and sends it back to the user.

Diagram Flow (Simplified):

**Client → DispatcherServlet → HandlerMapping → Controller → Service → Repository →
 Model → ViewResolver → View → Client**

Key Spring MVC Annotations

Spring MVC annotations help in handling requests, passing data, and returning responses in a clean and easy way.

1. @Controller

This annotation marks a class as a Spring MVC controller. It is mainly used in traditional web applications where the response is an HTML or JSP page. The controller method usually returns a view name, which is resolved by a ViewResolver.

@Controller
publicclassHomeController {

@GetMapping("/home")
public Stringhome() {
return"home";
    }
}

2. @RestController

This annotation is used to create RESTful web services. Instead of returning a view, it returns data directly in JSON or XML format. It automatically applies @ResponseBody, so there is no need to add it separately.

@RestController
@RequestMapping("/api/users")
publicclassUserController {

@GetMapping("/{id}")
public UsergetUser(@PathVariable Long id) {
return userService.findById(id);
    }
}

3. @RequestMapping

This annotation is used to map HTTP requests to controller classes or methods. It allows you to define the request URL, HTTP method, headers, and parameters. It can be used at both class level and method level.

@RequestMapping(value = "/users", method = RequestMethod.GET)
public List<User>getAllUsers() {
return userService.findAll();
}

4. @GetMapping, @PostMapping, @PutMapping, @DeleteMapping

These annotations are short and cleaner versions of @RequestMapping. Each one is used for a specific HTTP method like GET, POST, PUT, or DELETE, making the code easier to read and understand.

@PostMapping("/users")
public UsercreateUser(@RequestBody User user) {
return userService.save(user);
}

5. @PathVariable

This annotation is used to extract values directly from the URL path. It is commonly used in REST APIs where the resource ID is part of the URL.

@GetMapping("/users/{id}")
public UsergetUser(@PathVariable Long id) {
return userService.findById(id);
}

6. @RequestParam

This annotation is used to read query parameters from the URL. It is often used for pagination, filtering, or optional request values.

@GetMapping("/users")
public List<User>getUsers(
@RequestParamint page,
@RequestParamint size) {
return userService.findAll(page, size);
}

7. @RequestBody

This annotation is used to convert JSON or XML data from the request body into a Java object. It is mainly used with POST and PUT requests.

@PostMapping("/users")
public UsercreateUser(@RequestBody User user) {
return userService.save(user);
}

8. @ResponseBody

This annotation is used to send the method return value directly as JSON or XML instead of returning a view. It is useful when using @Controller but still want to return data.

@GetMapping("/status")
@ResponseBody
public Stringstatus() {
return"Application is running";
}

Summary Table

Example of Controller with Model and View

@Controller
publicclassUserController {

@GetMapping("/user/{id}")
public StringgetUser(@PathVariable Long id, Model model) {
Useruser= userService.getUserById(id);// Fetch data from service layer
        model.addAttribute("user", user);// Add data to Model
return"userView";// Logical view name (resolved by ViewResolver)
    }
}

Flow:

DispatcherServlet → Controller → Service → Repository → Model → ViewResolver → View → User

Why Spring MVC is Popular

• Separation of concerns – Keeps UI, business logic, and data separate.
• Flexible views – Supports JSP, Thymeleaf, FreeMarker, JSON, XML.
• Powerful request handling – Supports REST APIs, validation, and exception handling.
• Easy integration – Works seamlessly with Spring Boot, Spring Security, and Spring Data JPA.
• Scalable & maintainable – Ideal for both small and enterprise-level applications.

@Controller vs @RestController

Tips for Beginners

1. Start by understanding the MVC flow.
2. Use @RestController for APIs and @Controller for web pages.
3. Learn ViewResolver and template engines for rendering UI.
4. Build small CRUD applications to practice Model-Controller-View interactions.
5. Focus on clean code and separation of concerns for maintainability.

Conclusion:

Spring MVC is more than just a framework—it’s a robust architecture for building modern Java web applications. Its clear separation of responsibilities and flexible design make it ideal for production-level apps. By mastering Spring MVC, you can create scalable, maintainable, and SEO-friendly web applications.