Uncategorized

Mastering Spring MVC: Architecture, Use Cases & Getting Started Guide

vijay k

What is Spring MVC?

Spring MVC (Model-View-Controller) is a Java-based web application framework within the broader Spring Framework. It follows the MVC architectural pattern, which divides an application into three interconnected components:

  • Model: Represents application data and business rules.
  • View: Defines how data is presented to the user.
  • Controller: Handles input, processes user requests, and updates the model and view.

Spring MVC makes it easier to build flexible, loosely-coupled, and maintainable web applications by enforcing a clean separation of concerns. It’s built on servlet-based architecture and operates via the DispatcherServlet, which centralizes request handling.

Spring MVC is widely used for both monolithic applications and microservices (especially with Spring Boot), and supports rendering dynamic HTML pages, building REST APIs, and serving static resources.

Major Use Cases of Spring MVC

Spring MVC is the backbone of many enterprise-level and consumer-facing applications. Here are its most impactful use cases:

1. Web Portal Applications

Used to develop form-based applications such as admin dashboards, CMS platforms, employee portals, and business management systems.

2. RESTful API Development

Spring MVC provides seamless support for building RESTful web services using annotations like @RestController, @GetMapping, etc., making it a go-to choice for backend API development.

3. Enterprise Business Applications

Organizations often use Spring MVC to build large-scale applications with complex business logic due to its powerful dependency injection and modular architecture.

4. E-commerce Platforms

Ideal for e-commerce due to its scalability, security integration (via Spring Security), and support for MVC architecture, allowing clear separation of concerns between data, logic, and UI.

5. Microservices and Cloud-Native Applications

Spring MVC forms the foundation for Spring Boot microservices, which can be containerized and deployed to platforms like Kubernetes or AWS.

6. Educational and Government Portals

Spring MVC is often used for applications requiring robust user management, data handling, and form submissions in secure environments.

How Spring MVC Works: Internal Architecture

Spring MVC is centered around the DispatcherServlet, a front controller that manages all HTTP requests and coordinates the processing workflow.

🔧 Core Components of Spring MVC Architecture

  1. DispatcherServlet
    • Acts as the central request handler.
    • Intercepts all incoming requests and routes them to appropriate components.
  2. HandlerMapping
    • Determines which Controller method to invoke based on the URL, HTTP method, and annotations.
  3. Controller
    • Handles business logic and interacts with the Model.
    • Annotated with @Controller or @RestController.
  4. Model
    • Holds data passed between the controller and the view.
    • Often encapsulated using domain classes or DTOs.
  5. ViewResolver
    • Translates the logical view name returned by the controller into a physical view (like a JSP or Thymeleaf template).
  6. View
    • Renders the HTML or sends JSON/XML response.

🌐 Request Processing Workflow (Detailed Flow)

  1. Client sends an HTTP request.
  2. DispatcherServlet receives the request.
  3. HandlerMapping identifies the correct controller and method.
  4. The controller processes the request and creates a ModelAndView.
  5. ViewResolver determines the actual view to render.
  6. The View is rendered and returned as a response to the client.

📌 Example: REST Endpoint Flow

@RestController
public class ProductController {
    @GetMapping("/api/products")
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }
}
  • URL: GET /api/products
  • Returns: JSON list of products

Basic Workflow of Spring MVC

Spring MVC’s workflow follows a structured pattern for handling requests and responses:

  1. Request Received
    A client (browser or mobile app) makes an HTTP request to a specified URL.
  2. Request Routed to DispatcherServlet
    This servlet acts as the traffic controller and sends the request to a matching controller.
  3. Controller Invoked
    Executes the appropriate method, accesses services, processes logic, and prepares the model.
  4. Model and View Returned
    The controller returns the data and logical view name (e.g., “home”).
  5. View Resolver Processes View
    Maps the view name to a template like home.html or home.jsp.
  6. Response Sent to Client
    The rendered result is returned to the browser as HTML, or as JSON for REST APIs.

Step-by-Step Getting Started Guide for Spring MVC

Here’s a complete starter guide using Spring Boot to simplify configuration.

🔹 Step 1: Initialize the Project

Use Spring Initializr with these settings:

  • Project: Maven or Gradle
  • Dependencies:
    • Spring Web
    • Thymeleaf (for UI rendering)
    • Spring Boot DevTools (for auto-restart during development)

🔹 Step 2: Project Structure

src/
├── main/
│   ├── java/com/example/demo/
│   │   ├── DemoApplication.java
│   │   └── controller/HomeController.java
│   └── resources/
│       ├── templates/home.html
│       └── application.properties

🔹 Step 3: Create Controller

package com.example.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HomeController {
    @GetMapping("/")
    public String home(Model model) {
        model.addAttribute("message", "Welcome to Spring MVC!");
        return "home"; // maps to templates/home.html
    }
}

🔹 Step 4: Create View Template (Thymeleaf)

<!-- templates/home.html -->
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Spring MVC</title>
</head>
<body>
    <h1 th:text="${message}">Fallback Message</h1>
</body>
</html>

🔹 Step 5: Run the Application

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

Open http://localhost:8080/ to see the rendered page.

🔹 Bonus: Add a REST Endpoint

@RestController
public class ApiController {
    @GetMapping("/api/greet")
    public Map<String, String> greet() {
        return Map.of("message", "Hello from Spring REST API!");
    }
}

Visit: http://localhost:8080/api/greet

Advanced Features You Can Add Later

  • Form handling (@PostMapping)
  • Validation (@Valid, BindingResult)
  • Exception handling (@ControllerAdvice)
  • Spring Security
  • Integration with JPA or JDBC
  • API versioning and Swagger/OpenAPI documentation

Related Posts