What is WebMvcConfigurer and how do you use it to customize Spring MVC?
answer
- interface with empty default methods
- implement on @Configuration, override only needed hooks
- addInterceptors/addFormatters/addViewControllers/configureMessageConverters
- additive in Boot when no @EnableWebMvc
- all configurer beans collected via composite
basics
~10 sWebMvcConfigurer is an interface with default (empty) callback methods. You create a @Configuration class implementing it and override only the callbacks you need, like addInterceptors or addViewControllers, to tweak MVC without replacing everything.
solid answer
~40 sWebMvcConfigurer is a callback interface for customizing Spring MVC's Java configuration. Because all its methods are Java 8 default methods (empty bodies), you implement it on a @Configuration class and override only the hooks you care about. Common callbacks: addInterceptors (register HandlerInterceptors), addFormatters (register Converter/Formatter for type conversion), addViewControllers (map a URL straight to a view, no controller), configureMessageConverters/extendMessageConverters (JSON/XML body conversion), addCorsMappings, addResourceHandlers. In Spring Boot you register a WebMvcConfigurer bean WITHOUT @EnableWebMvc, so Boot's auto-configuration stays active and your callbacks simply add to it. Multiple WebMvcConfigurer beans are allowed — Spring collects them all via a DelegatingWebMvcConfiguration delegate and invokes every one.
code
java · 20 lines@Configuration
public class WebConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new RequestTimingInterceptor())
.addPathPatterns("/api/**")
.excludePathPatterns("/api/health");
}
@Override
public void addFormatters(FormatterRegistry registry) {
registry.addConverter(new StringToIsoDateConverter());
}
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/login").setViewName("login");
}
}go deeper
Should know it's an interface you implement on a @Configuration class and override selected callbacks.
Should name the main callbacks and know it's additive in Boot; know multiple configurers compose.
Should explain the DelegatingWebMvcConfiguration/composite delegation and the configure-vs-extend message-converter distinction.
Should reason about ordering across module-provided configurers and interaction with auto-config in a modular codebase.
## What it is `WebMvcConfigurer` is an interface in `org.springframework.web.servlet.config.annotation`. It is the programmatic (Java-config) way to customize Spring MVC's infrastructure — the beans that dispatch HTTP requests to your `@Controller` handler methods (the `DispatcherServlet`, `RequestMappingHandlerAdapter`, `HttpMessageConverter`s, `HandlerInterceptor`s, view resolvers, etc.). Every method on `WebMvcConfigurer` is a Java 8 **default method with an empty body**. That is the whole design point: you `implements WebMvcConfigurer` on a class and override **only** the callbacks relevant to your need — you don't have to implement dozens of methods. ## How you wire it ```java @Configuration public class WebConfig implements WebMvcConfigurer { @Override public void addViewControllers(ViewControllerRegistry r) { r.addViewController("/login").setViewName("login"); } } ``` Spring's MVC config (`DelegatingWebMvcConfiguration`, activated either by Boot's auto-config or by `@EnableWebMvc`) autowires **all** `WebMvcConfigurer` beans found in the context into a `WebMvcConfigurerComposite` and calls each callback on every one. So you can split customizations across many configurers, and in Boot your configurer is **additive** on top of the framework defaults. ## The key callbacks (this leaf's scope) - **`addInterceptors(InterceptorRegistry)`** — register `HandlerInterceptor`s (pre/post handler hooks: auth checks, logging, timing). You can scope with `.addPathPatterns(...)` / `.excludePathPatterns(...)` and set order via registration sequence. - **`addFormatters(FormatterRegistry)`** — register `Converter<S,T>` and `Formatter<T>` used for binding request params/path variables to typed method arguments (e.g. String → LocalDate, String → an enum or entity). - **`configureMessageConverters(List<HttpMessageConverter<?>>)`** — control the `HttpMessageConverter`s that serialize/deserialize `@RequestBody`/`@ResponseBody` (JSON via Jackson, etc.). **Gotcha:** if you add any converter here, the framework's default converters are NOT registered — you take full ownership of the list. Use **`extendMessageConverters(List<...>)`** instead to keep defaults and just add/reorder. - **`addViewControllers(ViewControllerRegistry)`** — map a URL directly to a view name (or a redirect/status) with no `@Controller` method — handy for static landing/login pages. Other callbacks include `addCorsMappings`, `addResourceHandlers`, `configureContentNegotiation`, `configureAsyncSupport`, `addArgumentResolvers`, `configureViewResolvers`. ## When to use Use `WebMvcConfigurer` for cross-cutting MVC infrastructure config. Do **not** confuse it with per-request beans — it configures the machinery once at startup. In Boot, prefer it over `@EnableWebMvc` unless you deliberately want to take over MVC config entirely. ## Historical note Before Spring 5 you extended the abstract adapter class `WebMvcConfigurerAdapter`; since the interface got default methods that adapter is deprecated — implement the interface directly.
- Why are all WebMvcConfigurer methods default methods?So you can implement the interface and override only the callbacks you need, instead of being forced to provide empty bodies for every method — the pre-Java-8 role of the deprecated WebMvcConfigurerAdapter.
- Can you have more than one WebMvcConfigurer?Yes. Spring injects all of them into a WebMvcConfigurerComposite/DelegatingWebMvcConfiguration and invokes each callback on every configurer, so customizations can be split across classes/modules.
saying these in an interview costs you the question
- Thinking you must override every method
- Believing WebMvcConfigurer replaces all MVC config (it's additive in Boot)
- Confusing it with the deprecated WebMvcConfigurerAdapter as the current approach
- Thinking only one configurer can exist