How does Spring Boot route HTTP requests to controllers?

Spring MVC routes requests through DispatcherServlet. It acts as the central front controller for the web layer.

When an HTTP request comes in, DispatcherServlet does not magically know which controller to call. It asks Spring MVC infrastructure components to find and invoke the correct handler.

In a web application, many URLs may map to many controller methods.

@RestController
@RequestMapping("/api/products")
public class ProductController {

    @GetMapping("/{id}")
    public ProductResponse getProduct(@PathVariable Long id) {
        return productService.getProduct(id);
    }
}

The important question is: when a request arrives for GET /api/products/42, how does Spring find this exact method?

DispatcherServlet coordinates that lookup and invocation process.

DispatcherServlet is not usually where your business logic lives. It is the coordinator that routes the request through the Spring MVC machinery.

A request first reaches the embedded server, usually Tomcat in a typical Spring Boot web application.

Tomcat then passes the request into the servlet layer, where DispatcherServlet is registered to handle web requests.

DispatcherServlet is the central entry point for Spring MVC request handling.

It receives the HTTP request and starts asking the MVC infrastructure:

Who should handle this request?
How should that handler be invoked?
How should the result be converted into an HTTP response?

HandlerMapping is responsible for finding the matching handler for a request.

For annotation-based controllers, this usually means matching:

• HTTP method, such as GET or POST
• URL path, such as /api/products/42
• controller-level mappings
• method-level mappings
• path variables and request conditions

Finding the method is not enough. Spring still needs to invoke it correctly.

That is where HandlerAdapter comes in.

The adapter knows how to call the selected handler method, including resolving arguments like:

@PathVariable
@RequestParam
@RequestBody
@RequestHeader

This is why your controller method can declare useful parameters and Spring can populate them automatically.

The controller method runs and returns something.

@GetMapping("/{id}")
public ProductResponse getProduct(@PathVariable Long id) {
    return productService.getProduct(id);
}

In a REST API, the return value is usually converted to JSON and written into the HTTP response.

In a traditional MVC application, the return value may instead refer to a view name that gets resolved by a ViewResolver.

For REST APIs, Spring uses message converters to turn Java objects into response bodies.

ProductResponse object
        ↓
JSON response body
        ↓
HTTP response

That is why returning a plain Java object from a REST controller can produce JSON automatically.

If something goes wrong, DispatcherServlet can delegate exception handling to Spring MVC exception resolvers.

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(ProductNotFoundException.class)
    public ResponseEntity<ApiError> handleNotFound(...) {
        return ResponseEntity.status(404).body(...);
    }
}

This is how exceptions from controllers or services can become clean HTTP responses.