Spring MVC Fundamentals

Spring MVC is Spring's web framework for building request-driven web applications and REST APIs, built around the classic Model-View-Controller pattern. A central component called the DispatcherServlet receives every incoming HTTP request and delegates it to the appropriate handler method, based on URL mappings you declare with annotations.

Rather than writing raw servlets, you write plain Java classes annotated with @Controller (or @RestController for APIs that return data directly rather than rendering a view), and annotate individual methods with request-mapping annotations that describe which HTTP method and URL pattern they handle. Spring MVC then takes care of binding request parameters, invoking the method, and converting the return value into an HTTP response.

The Request Flow Through DispatcherServlet

Every request first hits the DispatcherServlet, which acts as the "front controller." It consults a HandlerMapping to find which controller method matches the request's URL and HTTP method, invokes that method (resolving its arguments — path variables, request parameters, request bodies — along the way), and then hands the return value to a HandlerAdapter and, for @Controller classes returning view names, a ViewResolver to render the final response. For @RestController classes, the return value is instead serialized directly (typically to JSON) via an HttpMessageConverter.

@Controller vs @RestController

@Controller marks a class as a traditional MVC controller whose methods typically return a view name (a template to render, such as a Thymeleaf page) unless a method is separately annotated with @ResponseBody. @RestController is a convenience annotation equal to @Controller + @ResponseBody applied to every method — its methods return data (objects, strings) that Spring serializes directly into the HTTP response body, making it the standard choice for REST APIs.

Mapping Requests

@RequestMapping is the general-purpose annotation for mapping a URL (and optionally an HTTP method) to a handler method or class. Shortcut annotations built on top of it are preferred for readability in modern code.

• @GetMapping("/orders/{id}") — handles HTTP GET requests, commonly paired with @PathVariable to extract "{id}" from the URL.
• @PostMapping("/orders") — handles HTTP POST requests, typically paired with @RequestBody to deserialize the JSON request body into a Java object.
• @PutMapping / @DeleteMapping / @PatchMapping — handle the corresponding HTTP verbs with the same pattern.
• @RequestParam — binds an individual query string parameter to a method argument.

Example

import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@RestController
@RequestMapping("/api/orders")
class OrderController {

    private final Map<String, String> orders = new ConcurrentHashMap<>();

    @GetMapping("/{id}")
    public String getOrder(@PathVariable String id) {
        return orders.getOrDefault(id, "Order not found: " + id);
    }

    @PostMapping
    public String createOrder(@RequestBody Map<String, String> payload) {
        String id = payload.get("id");
        orders.put(id, "Order " + id + " created for " + payload.get("customer"));
        return "Created order " + id;
    }
}
// A GET to /api/orders/ORD-5 before creation returns: "Order not found: ORD-5"
// A POST to /api/orders with body {"id":"ORD-5","customer":"Asha"} returns: "Created order ORD-5"

GET /api/orders/ORD-5  -> "Order not found: ORD-5"
POST /api/orders {"id":"ORD-5","customer":"Asha"} -> "Created order ORD-5"
GET /api/orders/ORD-5 (after POST) -> "Order ORD-5 created for Asha"

Exercise

A teammate is about to make this mistake: Using @Controller when @RestController was intended, then being confused why the returned String is treated as a view name to resolve instead of raw response text (a "view not found" error appears instead of the expected JSON/text body). Use The Request Flow Through DispatcherServlet to review the decision. Write a corrected implementation or design sketch that follows DispatcherServlet is the front controller that routes every incoming request to the matching handler method., then name one edge case you would check.

Quick quiz

Interview questions