Spring MVC and it’s advantages
Spring MVC (Model-View-Controller) is a framework that is part of the Spring Framework and is used to build web applications. It follows the Model-View-Controller design pattern, which helps in separating the different aspects of the application such as input logic, business logic, and UI logic.
Key Components:
- Model: Represents the application data and business logic.
- View: Represents the presentation layer (UI) of the application.
- Controller: Handles user input and interactions, and updates the Model and View accordingly.

Table of Contents
Advantages of Spring MVC
1. Separation of Concerns:
  It clearly separates the roles of the controller, the model, and the view, which makes the code more organized and manageable.
2. Ease of Testing:
  Since the business logic is separated from the controller and the view, it is easier to test each component individually.
3. Flexibility:
  Spring allows the use of multiple view technologies such as JSP, Thymeleaf, and others, giving developers the flexibility to choose.
4. Built-in Features:
  It provides many built-in features such as data binding, form validation, and exception handling, which simplifies the development process.
5. Integration with Spring Ecosystem:
  Spring MVC integrates seamlessly with other Spring components like Spring Security, Spring Data, and Spring Boot, enhancing its capabilities.
6. Annotation-Based Configuration:
  Using annotations such as `@Controller`, `@RequestMapping`, and `@ModelAttribute`, you can define controllers, map URLs to handler methods, and bind request parameters to model attributes
Java Example of Spring MVC
Here is a simple example demonstrating a basic Spring MVC application.
1. Maven Dependencies
Add the required dependencies in your pom.xml
file:
```xml
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.10</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>
</dependencies>
```
2. Spring Configuration
Create a configuration class to set up Spring MVC:
```java
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "com.example")
public class WebConfig implements WebMvcConfigurer {
}
```
3. Controller
Create a controller class to handle web requests:
```java
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", "Hello, Spring MVC!");
return "home"; // returns the view name "home"
}
}
```
4. View
Create a view file home.jsp
in the WEB-INF/views
directory:
```jsp
<!DOCTYPE html>
<html>
<head>
<title>Home</title>
</head>
<body>
<h1>${message}</h1>
</body>
</html>
```
5. Web Application Initializer
Create a class to initialize the Spring application:
```java
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
public class AppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
@Override
protected Class<?>[] getRootConfigClasses() {
return null;
}
@Override
protected Class<?>[] getServletConfigClasses() {
return new Class[] { WebConfig.class };
}
@Override
protected String[] getServletMappings() {
return new String[] { "/" };
}
}
```
This simple example sets up a basic Spring MVC application that displays a message on the home page. You can expand it by adding more controllers, views, and models as needed.