Servlet 3.0 Container Initialization

Servlet 3.0 introduced the capability to initialize the ServletContext without using web.xml. The specification provides the ServletContainerInitializer interface, which containers automatically discover and invoke during startup.

Spring 3.1+ provides SpringServletContainerInitializer implementing this interface. It searches for classes implementing WebApplicationInitializer and invokes them to configure the Servlet context.

The AbstractAnnotationConfigDispatcherServletInitializer class is the primary implementation developers extend to configure Spring MVC without XML.

Creating the Web Application Initializer

The following class replaces the traditional web.xml deployment descriptor:

package com.example.mvc.config;

import jakarta.servlet.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.filter.HiddenHttpMethodFilter;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

@Configuration
public class AppWebInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{RootConfig.class};
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter encodingFilter = new CharacterEncodingFilter();
        encodingFilter.setEncoding("UTF-8");
        encodingFilter.setForceRequestEncoding(true);
        encodingFilter.setForceResponseEncoding(true);

        HiddenHttpMethodFilter methodFilter = new HiddenHttpMethodFilter();
        return new Filter[]{encodingFilter, methodFilter};
    }
}

Spring MVC Configuration Class

Create a configuration class to replace spring-mvc.xml:

@Configuration
@ComponentScan(basePackages = "com.example.mvc.web")
@EnableWebMvc
public class WebConfig {
}

Configuration Options in WebConfig

The annotasion-based configuration can replace all traditional XML settings:

• Component scanning
• View resolvers
• Static resource handling
• View controllers
• Annotation-driven processing
• Exception handlers
• Interceptors

Enabling Annotation-Driven Features

Use @EnableWebMvc to activate annotation-driven Spring MVC features:

@Configuration
@ComponentScan(basePackages = "com.example.mvc.web")
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
}

Configuring View Resolver with Thymeleaf

@Configuration
@ComponentScan(basePackages = "com.example.mvc.web")
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Bean
    public ITemplateResolver templateResolver(ApplicationContext context) {
        SpringResourceTemplateResolver resolver = new SpringResourceTemplateResolver();
        resolver.setApplicationContext(context);
        resolver.setPrefix("/WEB-INF/views/");
        resolver.setSuffix(".html");
        resolver.setTemplateMode(TemplateMode.HTML);
        resolver.setCharacterEncoding("UTF-8");
        resolver.setCacheable(false);
        return resolver;
    }

    @Bean
    public SpringTemplateEngine templateEngine(ITemplateResolver resolver) {
        SpringTemplateEngine engine = new SpringTemplateEngine();
        engine.setTemplateResolver(resolver);
        return engine;
    }

    @Bean
    public ThymeleafViewResolver viewResolver(SpringTemplateEngine engine) {
        ThymeleafViewResolver resolver = new ThymeleafViewResolver();
        resolver.setTemplateEngine(engine);
        resolver.setCharacterEncoding("UTF-8");
        resolver.setOrder(1);
        return resolver;
    }
}

Enabling Default Servlet Handling

Configure default servlet handling for static resources:

@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
    configurer.enable();
}

Configuring View Controllers

For simple pages that don't require controller logic:

@Override
public void addViewControllers(ViewControllerRegistry registry) {
    registry.addViewController("/home").setViewName("home");
    registry.addViewController("/about").setViewName("about");
}

Configuring Exception Handlers

@Override
public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
    SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
    
    Properties mappings = new Properties();
    mappings.setProperty("java.lang.Exception", "error");
    exceptionResolver.setExceptionMappings(mappings);
    exceptionResolver.setExceptionAttribute("exception");
    
    resolvers.add(exceptionResolver);
}

Configuring Interceptors

@Override
public void addInterceptors(InterceptorRegistry registry) {
    AuthenticationInterceptor authInterceptor = new AuthenticationInterceptor();
    
    registry.addInterceptor(authInterceptor)
            .addPathPatterns("/api/**")
            .excludePathPatterns("/api/login", "/api/public/**");
}

Complete Configuration Example

package com.example.mvc.config;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.handler.SimpleMappingExceptionResolver;
import org.thymeleaf.spring6.SpringTemplateEngine;
import org.thymeleaf.spring6.templateresolver.SpringResourceTemplateResolver;
import org.thymeleaf.spring6.view.ThymeleafViewResolver;
import org.thymeleaf.templatemode.TemplateMode;
import org.thymeleaf.templateresolver.ITemplateResolver;

import java.util.List;
import java.util.Properties;

@Configuration
@ComponentScan(basePackages = "com.example.mvc.web")
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Bean
    public ITemplateResolver templateResolver(ApplicationContext context) {
        SpringResourceTemplateResolver resolver = new SpringResourceTemplateResolver();
        resolver.setApplicationContext(context);
        resolver.setPrefix("/WEB-INF/views/");
        resolver.setSuffix(".html");
        resolver.setTemplateMode(TemplateMode.HTML);
        resolver.setCharacterEncoding("UTF-8");
        resolver.setCacheable(false);
        return resolver;
    }

    @Bean
    public SpringTemplateEngine templateEngine(ITemplateResolver resolver) {
        SpringTemplateEngine engine = new SpringTemplateEngine();
        engine.setTemplateResolver(resolver);
        return engine;
    }

    @Bean
    public ThymeleafViewResolver viewResolver(SpringTemplateEngine engine) {
        ThymeleafViewResolver resolver = new ThymeleafViewResolver();
        resolver.setTemplateEngine(engine);
        resolver.setCharacterEncoding("UTF-8");
        resolver.setOrder(1);
        return resolver;
    }

    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/home").setViewName("home");
    }

    @Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
        SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
        
        Properties mappings = new Properties();
        mappings.setProperty("java.lang.Exception", "error");
        exceptionResolver.setExceptionMappings(mappings);
        exceptionResolver.setExceptionAttribute("exception");
        
        resolvers.add(exceptionResolver);
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        LoggingInterceptor loggingInterceptor = new LoggingInterceptor();
        registry.addInterceptor(loggingInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/static/**", "/home");
    }
}

Configuration Summary

XML Element	Annotation-Based Alternative
<context:component-scan>	@ComponentScan
<mvc:annotation-driven>	@EnableWebMvc
<bean class="InternalResourceViewResolver">	@Bean methods for ViewResolver
<mvc:default-servlet-handler>	configureDefaultServletHandling()
<mvc:view-controller>	addViewControllers()
<mvc:interceptor>	addInterceptors()
Exception handler bean	configureHandlerExceptionResolvers()

Notes

When exception handlers are configured, interceptor execution may be affected depending on when exceptions occur in request processing chain.