The Model-View-Controller (MVC) pattern is a design pattern that separates an application into three components:

  • Model → Represents the data and business logic.
  • View → Handles the UI/Presentation layer.
  • Controller → Handles user requests, processes them, and sends data to the view.

Spring MVC follows this pattern to build web applications in a structured and maintainable way. Let’s understand this with a blog application example where users can create, view, and manage blog posts.

1. Components of MVC in a Spring MVC Blog

1.1 Model (Data + Business Logic)

The Model represents the blog post data and handles business logic. In Spring MVC, it is typically implemented using Java classes (POJOs), JPA/Hibernate entities, and Service Layer.

Example: BlogPost Model 

@Entity
public class BlogPost {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String content;
    private LocalDateTime createdAt;

    // Constructors, Getters, Setters
}

1.2 View (User Interface)

The View is responsible for rendering the response. In Spring MVC, the view is typically implemented using Thymeleaf, JSP, or other frontend technologies like React/Angular.

Example: Thymeleaf View (blog.html) 

</span>
 xmlns:th="http://www.thymeleaf.org">

    Blog Posts


    All Blog Posts
    
         th:each="post : ${posts}">
             th:text="${post.title}">
             th:text="${post.content}">
            Published on:  th:text="${post.createdAt}">
        
    





    Enter fullscreen mode
    


    Exit fullscreen mode
    





  
  
  1.3 Controller (Handles Requests)
The Controller manages incoming HTTP requests, processes data using the Model, and returns the appropriate View. In Spring MVC, controllers are implemented using @Controller or @RestController annotations.
  
  
  Example: BlogController

@Controller
@RequestMapping("/blog")
public class BlogController {

    @Autowired
    private BlogService blogService;

    // Show all blog posts
    @GetMapping
    public String listPosts(Model model) {
        List<BlogPost> posts = blogService.getAllPosts();
        model.addAttribute("posts", posts);
        return "blog"; // Refers to blog.html
    }

    // Show the form to create a new post
    @GetMapping("/new")
    public String newPostForm(Model model) {
        model.addAttribute("blogPost", new BlogPost());
        return "newPost"; // Refers to newPost.html
    }

    // Handle form submission for new post
    @PostMapping
    public String savePost(@ModelAttribute BlogPost blogPost) {
        blogService.savePost(blogPost);
        return "redirect:/blog"; // Redirect to list all posts
    }
}



    Enter fullscreen mode
    


    Exit fullscreen mode
    





  
  
  2. How MVC Works in Spring MVC (Request Flow)

  
  
  Example Scenario: A User Requests a Blog Post List

User sends a request to /blog
→ GET /blog request is sent to BlogController.  
Controller Processes Request
→ listPosts(Model model) method fetches blog posts from BlogService.  
Model Passes Data to View
→ model.addAttribute("posts", posts); sends blog data to the view.  
View Displays Data
→ blog.html renders the list of blog posts with Thymeleaf.  

  
  
  3. Advantages of Using MVC in Spring MVC
✅ Separation of Concerns – Keeps business logic (Model), request handling (Controller), and UI (View) separate.
✅ Scalability – New features can be added easily.
✅ Maintainability – Easier to debug and update code.
✅ Reusable Components – Models and Views can be reused across multiple controllers.  
  
  
  Final Thoughts
Spring MVC provides a structured way to develop web applications using the MVC pattern. In a blog application, the Model (BlogPost) handles data, the View (Thymeleaf/JSP) renders UI, and the Controller (BlogController) processes requests. This architecture makes the application clean, maintainable, and scalable. 🚀