30.7. Spring MVC Basics

Spring MVC is a web framework built on the Servlet API and provides Model-View-Controller architecture.

Spring MVC stands for Spring Model-View-Controller. It's built on top of the Java Servlet API, meaning it leverages the existing capabilities of servlets to handle web requests. The MVC architecture divides the application into three interconnected components:

1. Model: Represents the data or business logic of the application.
2. View: The presentation layer, which displays the data (for example, in HTML format).
3. Controller: Acts as an intermediary between the Model and the View, processing incoming requests, manipulating data through the model, and returning views to the user.

Think of a restaurant as an analogy for the MVC design pattern. The controller would be the waiter who takes your order (user request), the model represents the kitchen (where the food is prepared according to the order), and the view is the table where the food is presented. The waiter processes your order and communicates between you (the user) and the kitchen (the model) to deliver what you want.

Core Components: • DispatcherServlet: Central controller • Controller: Handles requests • Model: Data • View: Presentation (JSP, Thymeleaf)

The core components of Spring MVC work together to create a clean separation of responsibilities:

• DispatcherServlet: Acts as the front controller in the Spring MVC framework. It receives all incoming HTTP requests and delegates them to the appropriate controllers for processing.
• Controller: This component contains the logic to handle user requests. It processes user inputs, interacts with models to retrieve data, and ultimately returns the appropriate view.
• Model: Holds the necessary data that the application needs—for example, user information or product details.
• View: The part of the application that displays information to the user, which can be achieved using technologies such as JSP (JavaServer Pages) or Thymeleaf.

Continuing with the restaurant analogy, the DispatcherServlet is like the head waiter, directing customers to different sections of the restaurant. Each Controller is like a specific chef or team in the kitchen that handles a particular type of dish, such as appetizers or desserts. The Model is the kitchen inventory, where ingredients are stored, and the View is the beautifully plated dish that is presented to the customer.

Example:

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

This example demonstrates a simple Spring MVC controller:

• @Controller tells Spring that this class is a controller.
• The home method is mapped to the /home URL using the @GetMapping annotation. This means when a request is made to /home, this method will be called.
• The method accepts a Model object, which allows it to pass data to the view. Here, we're adding an attribute called 'message' with a value of 'Welcome to Spring!'.
• Finally, the method returns the string home, which indicates to Spring that it should render the home.jsp view.

Imagine a bartender crafting a special cocktail based on a customer's preference. The bartender (controller) takes the customer's order (request), prepares the drink (interacts with the model), and presents it beautifully on the bar (returns the view). Just like the bartender customizes the drink for the customer, the home method customizes the response based on the request it receives.

--