Adding this annotation to a @Configuration class imports the Spring MVC configuration from WebMvcConfigurationSupport which is the main class providing the configuration behind the MVC Java config.
@EnableWebMvc
@Configuration
public class MyWebConfig {
.....
}
If you don't use this annotation (like this example) you might not initially notice any difference but things like content-type and accept header, generally content negotiation won't work.
When you don't use @EnableWebMvc, Spring falls back to its old, outdated system just to make sure really old apps (from 2007-2010) still work. But if you're building anything new, you should always use @EnableWebMvc to get all the modern features.
If you are using XML based configuration then use <mvc:annotation-driven/> as an alternative to @EnableWebMvc
@EnableWebMvc and <mvc:annotation-driven /> have the same purpose, mixing them doesn't work in some cases.
Definition of EnableWebMvcVersion: 7.0.5 package org.springframework.web.servlet.config.annotation;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(DelegatingWebMvcConfiguration.class)
public @interface EnableWebMvc {
}
As seen above EnableWebMvc imports DelegatingWebMvcConfiguration which is a subclass of WebMvcConfigurationSupport. See the list of configuration performed by this support class here.
How to Customize Configurations?
To customize the configuration imported by @EnableWebMvc, we should extend the class WebMvcConfigurer and override the methods we want to do related customization with. Our WebMvcConfigurer methods are automatically called by Spring during the configuration stage
Note: In versions before Spring 5.0 (pre-2017), we had to extend the WebMvcConfigurerAdapter class instead of implementing WebMvcConfigurer directly. The adapter class is now deprecated because Java 8+ allows default methods in interfaces, making the adapter unnecessary.
WebMvcConfigurerAdapter was completely removed in Spring 6.
Definition of WebMvcConfigurerVersion: 7.0.5 package org.springframework.web.servlet.config.annotation;
public interface WebMvcConfigurer {
default void configurePathMatch(PathMatchConfigurer configurer);
default void configureContentNegotiation(ContentNegotiationConfigurer
configurer);
default void configureApiVersioning(ApiVersionConfigurer configurer);
default void configureAsyncSupport(AsyncSupportConfigurer configurer);
default void configureDefaultServletHandling(DefaultServletHandlerConfigurer
configurer);
default void addFormatters(FormatterRegistry registry);
default void addInterceptors(InterceptorRegistry registry);
default void addResourceHandlers(ResourceHandlerRegistry registry);
default void addCorsMappings(CorsRegistry registry);
default void addViewControllers(ViewControllerRegistry registry);
default void configureViewResolvers(ViewResolverRegistry registry);
default void addArgumentResolvers(List<HandlerMethodArgumentResolver>
resolvers);
default void addReturnValueHandlers(List<HandlerMethodReturnValueHandler>
handlers);
default void configureMessageConverters(HttpMessageConverters.ServerBuilder
builder);
default void configureMessageConverters(List<HttpMessageConverter<?>>
converters);
default void extendMessageConverters(List<HttpMessageConverter<?>>
converters);
default void configureHandlerExceptionResolvers(List
<HandlerExceptionResolver> resolvers);
default void extendHandlerExceptionResolvers(List<HandlerExceptionResolver>
resolvers);
default void addErrorResponseInterceptors(List<ErrorResponse.Interceptor>
interceptors);
default Validator getValidator();
default MessageCodesResolver getMessageCodesResolver();
}
As seen above, the WebMvcConfigurer interface provides various customization points for Spring MVC, mostly to customize path matching, content negotiation, interceptors, CORS, view controllers, message converters, and exception handling to tailor Spring MVC exactly to your application's needs.
More advanced customization
If overriding WebMvcConfigurer does not work for us and we want to do some advance configuration then we should not use @EnableWebMvc annotation. In that case we should extend our @Configuration class directly from WebMvcConfigurationSupport or DelegatingWebMvcConfiguration and selectively override the methods including factory methods annotated with @Bean, remembering to add @Configuration to the subclass and @Bean to overridden @Bean methods. This approach gives you complete control to override core infrastructure beans (like RequestMappingHandlerMapping or RequestMappingHandlerAdapter) when you need to modify Spring MVC's internal behavior beyond what WebMvcConfigurer allows
Complete Example
This example show the basic use of @EnableWebMvc and WebMvcConfigurer.
The Controller
package com.logicbig.example;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
@Controller
public class MyMvcController {
@RequestMapping(value = "/", method = RequestMethod.GET)
public String prepareView(Model model) {
model.addAttribute("msg", "Hello from Spring");
return "my-page";
}
}
Configuration
package com.logicbig.example;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ViewResolverRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
@EnableWebMvc
@Configuration
@ComponentScan
public class MyWebConfig implements WebMvcConfigurer {
@Override
public void configureViewResolvers(ViewResolverRegistry registry) {
registry.jsp("/WEB-INF/views/", ".jsp");
}
}
Web Initializer
package com.logicbig.example;
import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRegistration;
import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;
public class MyWebInitializer implements WebApplicationInitializer {
@Override
public void onStartup(ServletContext servletContext) {
AnnotationConfigWebApplicationContext ctx =
new AnnotationConfigWebApplicationContext();
//register our config class
ctx.register(MyWebConfig.class);
ctx.setServletContext(servletContext);
//using servlet 3 api to dynamically create
//spring dispatcher servlet
ServletRegistration.Dynamic servlet =
servletContext.addServlet("springDispatcherServlet",
new DispatcherServlet(ctx));
servlet.setLoadOnStartup(1);
servlet.addMapping("/");
}
}
The View
src/main/webapp/WEB-INF/views/my-page.jsp<%@ page language="java"
contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<html>
<body>
Message : ${msg}
</body>
</html>
Running the app
$ mvn clean jetty:run
$ curl http://localhost:8080/spring-enable-web-mvc
<html>
<body>
Message : Hello from Spring
</body>
</html>
From Browser
Example ProjectDependencies and Technologies Used: - spring-webmvc 7.0.5 (Spring Web MVC)
Version Compatibility: 3.2.9.RELEASE - 7.0.5 Version compatibilities of spring-webmvc with this example: Versions in green have been tested.
- jakarta.servlet-api 6.1.0 (Jakarta Servlet API documentation)
- jakarta.servlet.jsp.jstl 3.0.1 (Jakarta Standard Tag Library Implementation)
- JDK 25
- Maven 3.9.11
|
