Spring MVC Architecture

What is Spring MVC, and Why Does the Front Controller Pattern Exist?

Spring MVC is the web layer of Spring Framework, built on top of the Servlet API (jakarta.servlet.* since Spring Framework 6 / Spring Boot 3 — it was javax.servlet.* before). It implements the Front Controller design pattern: every single HTTP request, regardless of URL, is received by one object — DispatcherServlet — which then delegates to the right handler.

The alternative — one raw Servlet per URL, the pre-Spring approach — means every cross-cutting concern (authentication, logging, exception formatting, content negotiation) has to be duplicated or hand-wired into every single servlet. A front controller centralises all of that in one place: the request always enters through DispatcherServlet, which applies interceptors, resolves the correct controller method, converts the response, and hands back a result — identically, for every endpoint in the application.

The Request Lifecycle

/*
 *  Browser ──▶ DispatcherServlet ──▶ HandlerMapping ──▶ Controller method
 *                    │                                        │
 *                    │                          returns "view name" + Model
 *                    │                          OR a @ResponseBody / ResponseEntity
 *                    │                                        │
 *          ┌─────────┴─────────┐                  ┌───────────┴───────────┐
 *          ▼                   ▼                  ▼                       ▼
 *   HandlerAdapter      ViewResolver        HttpMessageConverter    (nothing to convert:
 *  (invokes the method   (view name →          (object → JSON,       void / already sent)
 *   with the right         View instance)        via Jackson)
 *   arguments resolved)         │                       │
 *                               ▼                       ▼
 *                          View.render()          Response body written
 *                               │                       │
 *                               └───────────┬───────────┘
 *                                           ▼
 *                                   HTTP Response to Browser
 */

1. DispatcherServlet receives the request — the single entry point for the whole application.
2. HandlerMapping finds which controller method matches the URL, HTTP method, headers, and content type.
3. HandlerAdapter actually invokes that method — resolving each parameter (@PathVariable, @RequestBody, Model, etc.) into the right argument.
4. The method returns either a view name + Model (traditional, server-rendered) or data directly (@ResponseBody / ResponseEntity — the REST path).
5. View path: ViewResolver turns the view name into an actual View (e.g. a Thymeleaf template), which renders the Model into HTML.
6. Data path: an HttpMessageConverter (Jackson, by default) serialises the returned object straight into the response body — ViewResolver is never involved.

Declaring Controllers

@Controller  // resolves a VIEW NAME — for server-rendered HTML
public class HomeController {

    @GetMapping("/")
    public String home(Model model) {
        model.addAttribute("message", "Welcome!");
        return "home";  // ViewResolver maps this to a template, e.g. templates/home.html
    }
}

@RestController  // = @Controller + @ResponseBody — writes the return value to the body directly
public class ApiController {

    @GetMapping("/api/data")
    public DataResponse getData() {
        return new DataResponse("Hello");  // serialised to JSON by Jackson via HttpMessageConverter
    }
}

@Controller
@RequestMapping("/products")  // base path — combined with each method's mapping
public class ProductController {

    private final ProductService productService;  // constructor injection — same rule as any other Spring bean

    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    @GetMapping  // GET /products
    public String list(Model model) {
        model.addAttribute("products", productService.findAll());
        return "products/list";
    }

    @GetMapping("/{id}")  // GET /products/123
    public String show(@PathVariable Long id, Model model) {
        model.addAttribute("product", productService.findById(id));
        return "products/show";
    }

    @PostMapping  // POST /products
    public String create(@ModelAttribute Product product) {
        productService.save(product);
        return "redirect:/products";  // redirect after POST — prevents duplicate submission on refresh
    }
}

Binding Request Data

@RestController
public class SearchController {

    // Path variable — /users/123 → id = 123
    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) { ... }

    // Query parameters — /search?q=java&page=2
    @GetMapping("/search")
    public List<Result> search(
            @RequestParam String q,                              // required by default — 400 if missing
            @RequestParam(defaultValue = "1") int page,
            @RequestParam(required = false) String sort) { ... }

    // Header and cookie
    @GetMapping("/data")
    public String getData(@RequestHeader("Authorization") String authHeader,
                            @CookieValue("theme") String theme) { ... }

    // JSON body — converted by an HttpMessageConverter (Jackson), based on Content-Type
    @PostMapping("/users")
    public User createUser(@RequestBody User user) { ... }

    // Form fields (application/x-www-form-urlencoded) — bound to object properties
    @PostMapping("/register")
    public String register(@ModelAttribute RegistrationForm form) { ... }
}

Model, View Resolution, and Returning Data Directly

@Controller
public class DashboardController {

    @GetMapping("/dashboard")
    public String dashboard(Model model) {
        model.addAttribute("stats", statsService.currentStats());
        return "dashboard";  // resolved via spring.thymeleaf.prefix/suffix
    }

    // Runs before EVERY handler method in this controller — shared model data
    @ModelAttribute("categories")
    public List<Category> categories() {
        return categoryService.findAll();
    }
}

By default, a Thymeleaf-backed Boot app resolves the view name "dashboard" to src/main/resources/templates/dashboard.html — the spring.thymeleaf.prefix (classpath:/templates/) and spring.thymeleaf.suffix (.html) properties, which you rarely need to touch. Binding into the template happens through Thymeleaf's th:* attributes reading straight from the Model:

<!-- templates/dashboard.html -->
<h1 th:text="${stats.totalOrders}">0</h1>
<select>
    <option th:each="cat : ${categories}" th:value="${cat.id}" th:text="${cat.name}"></option>
</select>

@GetMapping("/{id}")
public ResponseEntity<Product> show(@PathVariable Long id) {
    return productService.findById(id)
        .map(ResponseEntity::ok)
        .orElseGet(() -> ResponseEntity.notFound().build());
}

Form Handling and Validation

public class ProductForm {
    @NotBlank
    private String name;

    @Positive
    private BigDecimal price;
    // getters/setters
}

@PostMapping("/products")
public String create(@Valid @ModelAttribute("product") ProductForm form,
                     BindingResult result,
                     RedirectAttributes redirectAttrs) {

    if (result.hasErrors()) {
        return "products/form";  // re-show form with field errors bound automatically
    }
    Product product = productService.create(form);
    redirectAttrs.addFlashAttribute("message", "Product created!");  // survives exactly one redirect
    return "redirect:/products/" + product.getId();
}

Exception Handling

// Local — only catches exceptions thrown within THIS controller
@Controller
public class ProductController {
    @ExceptionHandler(ProductNotFoundException.class)
    public String handleNotFound(ProductNotFoundException ex, Model model) {
        model.addAttribute("message", ex.getMessage());
        return "error/404";
    }
}

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(ProductNotFoundException.class)
    public ProblemDetail handleNotFound(ProductNotFoundException ex) {
        ProblemDetail problem = ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, ex.getMessage());
        problem.setTitle("Product Not Found");
        problem.setProperty("timestamp", Instant.now());
        return problem;
    }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ProblemDetail handleValidation(MethodArgumentNotValidException ex) {
        ProblemDetail problem = ProblemDetail.forStatusAndDetail(HttpStatus.BAD_REQUEST, "Validation failed");
        problem.setProperty("errors", ex.getBindingResult().getFieldErrors()
            .stream().map(e -> e.getField() + ": " + e.getDefaultMessage()).toList());
        return problem;
    }
}

Interceptors vs Filters — Not the Same Layer

@Component
public class TimingInterceptor implements HandlerInterceptor {
    // Since Spring 5.3, all three methods have default implementations —
    // override only the ones you actually need.

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        request.setAttribute("startTime", System.nanoTime());
        return true;  // false would short-circuit — controller never runs
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        long nanos = System.nanoTime() - (long) request.getAttribute("startTime");
        log.debug("{} took {}ms", request.getRequestURI(), nanos / 1_000_000);
    }
}

// Single WebConfig — registers both interceptors AND resource handlers.
// Two classes named WebConfig in the same package is a compile error, not a style choice.
@Configuration
public class WebConfig implements WebMvcConfigurer {

    private final TimingInterceptor timingInterceptor;

    public WebConfig(TimingInterceptor timingInterceptor) {
        this.timingInterceptor = timingInterceptor;
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(timingInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/static/**");
    }

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/files/**")
                .addResourceLocations("file:/var/uploads/")
                .setCacheControl(CacheControl.maxAge(Duration.ofHours(1)));
    }
}

Static Resources

By default, Spring Boot serves anything placed under src/main/resources/static/ (also checked, in order: /public/, /resources/, /META-INF/resources/) directly, without a controller.

# application.properties — override the default locations or caching
spring.web.resources.static-locations=classpath:/static/,classpath:/custom/
spring.web.resources.cache.period=31536000  # seconds — 1 year, safe with content-hashed filenames

Testing the Web Layer: @WebMvcTest and MockMvc

@WebMvcTest(ProductController.class)  // loads ONLY the web layer — this controller + relevant MVC infra
class ProductControllerTest {

    @Autowired private MockMvc mockMvc;

    @MockitoBean  // no real ProductService bean exists in this slice — must be mocked
    private ProductService productService;

    @Test
    void show_returnsProductView() throws Exception {
        when(productService.findById(1L)).thenReturn(new Product(1L, "Keyboard"));

        mockMvc.perform(get("/products/1"))
            .andExpect(status().isOk())
            .andExpect(view().name("products/show"))
            .andExpect(model().attributeExists("product"));
    }
}

Interview Questions