Key Concepts of Spring MVC and Spring Boot

Spring MVC and Spring Boot are part of the larger Spring Framework, which provides comprehensive infrastructure support for developing Java applications. Here's a detailed overview of both, including their key concepts and how they fit into the broader Spring ecosystem.

Spring MVC (Model-View-Controller) – Key Concepts

Spring MVC is a web framework built on the Servlet API that helps developers create web applications using the Model-View-Controller (MVC) design pattern. It provides a structured way to build web applications by separating concerns into three main components:

1. Model

Represents the application's data and business logic. The Model holds the data that the View will display. It is typically a POJO (Plain Old Java Object) that is manipulated by the business logic layer (usually services).

Example:

java
public class Employee {
    private Long id;
    private String name;
    private String role;
    
    // Getters and Setters
}

2. View

The View is responsible for rendering the model data to the user. It typically corresponds to a JSP, Thymeleaf, Freemarker, or other templating technologies.
In Spring MVC, views are typically returned by Controllers as part of the response.

Example:

html
<!-- employee.jsp -->
<h1>Employee Information</h1>
<p>Name: ${employee.name}</p>
<p>Role: ${employee.role}</p>

3. Controller

Controllers handle user requests and return responses. They process user inputs, update the model, and return the appropriate view.
@Controller and @RestController are key annotations in Spring MVC.
- @Controller is used for traditional MVC applications, returning views.
- @RestController is used for REST APIs, returning JSON or XML.

Example of a Controller:

java
@Controller
@RequestMapping("/employee")
public class EmployeeController {
    @GetMapping("/details")
    public String showEmployeeDetails(Model model) {
        Employee employee = new Employee("John Doe", "Manager");
        model.addAttribute("employee", employee);
        return "employee";
    }
}

4. DispatcherServlet

The DispatcherServlet is the front controller in Spring MVC. It intercepts all incoming requests, delegates them to the appropriate controllers, and then dispatches the response back to the client.
It manages the entire request flow in a Spring MVC application and is configured in the web.xml or Spring Boot application configuration.

5. RequestMapping

The @RequestMapping annotation is used to map HTTP requests to handler methods of controllers. You can use different variants like @GetMapping, @PostMapping, @PutMapping, etc., to map HTTP methods.

Example:

java
@GetMapping("/employees")
public String getEmployees(Model model) {
    List<Employee> employees = employeeService.getAllEmployees();
    model.addAttribute("employees", employees);
    return "employeeList";
}

6. View Resolvers

View resolvers are responsible for resolving the logical view name (a string returned from a controller) into an actual view (e.g., a JSP, HTML page, or a template).

InternalResourceViewResolver is a common view resolver used in Spring MVC:

java
@Bean
public InternalResourceViewResolver viewResolver() {
    InternalResourceViewResolver resolver = new InternalResourceViewResolver();
    resolver.setPrefix("/WEB-INF/views/");
    resolver.setSuffix(".jsp");
    return resolver;
}

7. Form Handling

Spring MVC allows handling forms with simple annotations like @ModelAttribute, which automatically binds request parameters to Java objects.

Example of a form-backed controller:

java
@PostMapping("/submitEmployee")
public String submitEmployee(@ModelAttribute Employee employee) {
    employeeService.save(employee);
    return "employeeSaved";
}

8. Exception Handling

Spring MVC provides centralized exception handling using @ControllerAdvice and @ExceptionHandler. This allows you to handle exceptions at the global or method level.

Example:

java
@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(EmployeeNotFoundException.class)
    public String handleEmployeeNotFound(EmployeeNotFoundException ex) {
        return "errorPage";
    }
}

Spring Boot – Key Concepts

Spring Boot is a framework built on top of Spring that simplifies the setup and configuration of Spring applications. It is designed to streamline the development process by eliminating most of the boilerplate code required to configure a Spring application.

1. Auto-Configuration

Auto-configuration automatically configures Spring beans based on the project dependencies. Spring Boot eliminates the need for manual configuration of beans, such as database connections, view resolvers, and more.
Example: If you include spring-boot-starter-web in your dependencies, Spring Boot will automatically configure Tomcat as the embedded web server.

2. Spring Boot Starter POMs

Starters are predefined dependency sets that simplify the configuration of your application. For example, spring-boot-starter-web includes all necessary dependencies for creating a web application (e.g., Spring MVC, Tomcat).
Common starters include:
- spring-boot-starter-web (for web applications)
- spring-boot-starter-data-jpa (for JPA and Hibernate)
- spring-boot-starter-thymeleaf (for Thymeleaf templating engine)

3. Embedded Servers

Spring Boot provides embedded web servers, meaning you don’t need to configure an external server like Tomcat or Jetty. The web server is packaged inside the application, making it easier to deploy as a standalone executable JAR or WAR.
The default embedded web server is Tomcat, but Spring Boot can also work with Jetty or Undertow by simply changing dependencies.

4. Spring Boot Application Class

The entry point of a Spring Boot application is the main class, which is typically annotated with @SpringBootApplication. This annotation is a combination of several annotations like @Configuration, @EnableAutoConfiguration, and @ComponentScan.

Example:

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

5. Spring Boot Actuator

Spring Boot Actuator provides a set of production-ready features, such as application health checks, metrics, and monitoring.
You can enable endpoints like /actuator/health to monitor your application’s status.

Example configuration:

management.endpoints.web.exposure.include=health,info

6. Externalized Configuration

Spring Boot supports externalized configuration, which means configuration properties can be specified in application.properties or application.yml files.

Example:

properties
server.port=8081
spring.datasource.url=jdbc:mysql://localhost:3306/mydb

7. Spring Boot CLI (Command-Line Interface)

The Spring Boot CLI allows you to run Spring Boot applications from the command line using Groovy scripts or Java classes.
It helps developers quickly prototype and test applications.

8. Spring Boot DevTools

Spring Boot DevTools provides support for automatic restarts, live reload, and enhanced debugging during development. This makes the development process faster and more efficient.

9. Spring Boot Initializr

Spring Boot Initializr is a web-based tool that allows you to generate a Spring Boot project by selecting the necessary dependencies, Java version, packaging, and more.
You can access it at: https://start.spring.io/

Key Differences Between Spring MVC and Spring Boot

Feature	Spring MVC	Spring Boot
Purpose	A framework for building web applications with Spring	Simplifies application setup and configuration
Configuration	Requires manual configuration and XML setup	Provides automatic configuration and embedded servers
Deployment	Deployed as WAR to an external servlet container	Deployed as a self-contained executable JAR or WAR
Main Class	Not required (typically a separate `DispatcherServlet`)	Requires a main class with `@SpringBootApplication`
Web Server	External web server (e.g., Tomcat, Jetty)	Embedded web server (e.g., Tomcat, Jetty)
Dependency Management	Manual management of dependencies	Uses starters to automatically manage dependencies
Auto-Configuration	Not supported	Automatically configures application based on dependencies

RIET - Java developer

Search This Blog