Difference between Spring MVC and Spring Boot

Spring MVC and Spring Boot are key parts of the Spring ecosystem used for developing Java-based web applications. They help developers build structured and efficient applications, but differ in terms of configuration, setup, and ease of development.

• Enables development of web applications using the MVC architecture
• Simplifies application setup and reduces boilerplate code
• Supports faster development and deployment of Java applications

Spring MVC

Spring MVC is a web framework module of the Spring Framework that helps in building web applications following the Model-View-Controller pattern. It provides full control over application architecture and is highly flexible.

• Model-View-Controller (MVC) Pattern: Separates application logic, UI, and request handling.
• Flexible Configuration: Supports XML, annotations, and Java-based configuration.
• Integration: Works with Spring modules like Spring Security, Spring Data, and Hibernate.

Example: Spring MVC Web Application:

@Configuration
@ComponentScan(basePackages = "com.example")
@EnableWebMvc
public class WebConfig {
    // Define beans and view resolvers
}

@Controller
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping
    public String getUsers(Model model) {
        model.addAttribute("users", userService.getAllUsers());
        return "userList"; // JSP or HTML view
    }
}

// Main class deployed as WAR on external server
public class GFG {
    
    public static void main(String[] args){
        
        // Deploy this app manually to an external server like Tomcat
    }
}

Explanation: This is a Spring MVC app with manual configuration using @EnableWebMvc, handling requests via a controller and returning a view, deployed on an external server like Tomcat.

Spring Boot

Spring Boot is a framework built on top of Spring that simplifies application development by providing auto-configuration, embedded servers, and production-ready features. It reduces boilerplate code and allows developers to get applications running quickly.

• Auto-Configuration: Automatically configures Spring applications based on included dependencies.
• Embedded Servers: Comes with embedded Tomcat, Jetty, or Undertow; no external server needed.
• Starter POMs: Ready-made dependency bundles for common functionalities.

Example: Spring Boot REST API:

@SpringBootApplication
public class UserApplication{
    
    public static void main(String[] args){
        
        // Embedded Tomcat runs automatically
        SpringApplication.run(UserApplication.class, args); 
    }
}

@RestController
@RequestMapping("/api/users")
public class UserController{
    
    private List<String> users = List.of("Alice", "Bob", "Charlie");

    @GetMapping
    public List<String> getUsers(){
        
        // Returns JSON response
        return users; 
    }
}

Explanation: This is a Spring Boot application that uses auto-configuration and an embedded server, so it runs directly without manual deployment. It defines a REST controller that handles requests and returns user data in JSON format.

Spring MVC vs Spring Boot