Custom SpringBoot default MVC configuration? Several pits. This article must be treasured

Spring Boot provides the default configuration for Spring MVC, including a view parser, static resource handling, type converters and formatters, HTTP message converters, static home page support, etc. It is easy to use. However, in practice, customized Web MVC configuration is inevitable. Spring Boot successively provided WebMvcConfigurerAdapter, WebMvcConfigurationSupport, WebMvcConfigurer, @ EnableWebMvc form to realize the Web MVC custom configurations. Let’s learn one by one.

WebMvcConfigurerAdapter were abandoned, so we still can be done through inheritance WebMvcConfigurationSupport Spring MVC.

public class WebMvcConfigurationSupport implements ApplicationContextAware, ServletContextAware {... }Copy the code

This class is special in that it implements the ApplicationContextAware and ServletContextAware interfaces, provides some default implementations, and provides many @bean methods, but does not provide the @Configureation annotation. Therefore, these @beans do not take effect, so we need to inherit the class and provide the @Configureation annotation on the supplied class to take effect.

WebMvcConfigurationSupport not only defines the Bean, also provide a large amount of the add and config at the beginning of the method. Comparing WebMvcConfigurer method definition, will found almost WebMvcConfigurer some in WebMvcConfigurationSupport has. It is important to note that in some way WebMvcConfigurationSupport did not achieve specific function.

AddInterceptors and addViewControllers are common examples:

/**
* Override this method to add Spring MVC interceptors for
* pre- and post-processing of controller invocation.
* @see InterceptorRegistry
 */
protected void addInterceptors(InterceptorRegistry registry) {
}

/**
 * Override this method to add view controllers.
 * @see ViewControllerRegistry
*/
protected void addViewControllers(ViewControllerRegistry registry) {
}
Copy the code

Inheritance WebMvcConfigurationSupport after, can use the method to add custom interceptors, view the parser functions, such as the sample is as follows:

@Configuration public class WebMvcConfig extends WebMvcConfigurationSupport { @Override protected void addViewControllers(ViewControllerRegistry registry) { registry.addViewController("/").setViewName("login"); registry.addViewController("/login.html").setViewName("login"); }}Copy the code

At this point, you think everything is ok and you can happily write business logic? That’s when the problem starts. When through inheritance WebMvcConfigurationSupport implemented MVC configuration, to Spring the Boot to replace the default configuration of MVC. Once replaced, Spring Boot’s default convention over configuration features may fail, such as static resource access failure, unsuccessful return of data, and, of course, parameter binding failure mentioned earlier.

Why, then, inheritance WebMvcConfigurationSupport will replace the Spring Boot default MVC configuration? Let’s take a look at Spring Boot’s implementation of automatic assembly of WEB MVC related components:

@Configuration(proxyBeanMethods = false) @ConditionalOnWebApplication(type = Type.SERVLET) @ConditionalOnClass({Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class}) @ConditionalOnMissingBean({WebMvcConfigurationSupport.class}) @AutoConfigureOrder(-2147483638) @AutoConfigureAfter({DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class, ValidationAutoConfiguration.class}) public class WebMvcAutoConfiguration {... }Copy the code

Spring Boot uses the WebMvcAutoConfiguration configuration class to set the default parameters (conventions) of MVC, but WebMvcAutoConfiguration takes effect under certain conditions. @ ConditionalOnMissingBean ({WebMvcConfigurationSupport. Class}) specifies, when are not present in the Spring container type for WebMvcConfigurationSupport bean, The default configuration is performed. Must be of a custom WebMvcConfigurationSupport, so will lead to WebMvcAutoConfiguration cannot be instantiated, and internal initialization configuration will all cannot be instantiated.

In this case, the relevant configuration needs to be implemented by itself, unless there is excellent control of the code, or a lot of special customization, this form is considered. Otherwise, a list of conventions will cease to exist, and some puzzling problems may occur.

In many code examples, you will also see that it implements not only the WebMvcConfigurer interface, but also the @enableWebMVC annotation on the implementation class, which you need to pay attention to. The @enableWebMVC annotation causes a new round of default WebMVC configuration invalidation.

Earlier official versions had instructions like the following: If you want to keep the WebMVC features provided by Spring Boot by default and add additional functionality, you can simply inherit the WebMvcConfigurerAdapter or implement the WebMvcConfigurer interface. It can then be instantiated using the @Configuration annotation on the implementation class without using @enableWebMVC. If you want full control of Spring MVC, you can add the @enableWebMVC annotation to the implementation class.

That is, the @enableWebMVC annotation does not have to be configured and is only used if the default configuration is to be completely overridden. It is also specified in the source code comment that only one class can use the @EnableWebMVC annotation throughout the project, unlike the WebMvcConfigurer interface, which can have multiple implementation classes.

So, once the @enableWebMVC annotation is used in the code, it means that the Spring MVC auto-configuration is disabled and everything needs to be auto-configured. The following is an example:

@Configuration @EnableWebMvc public class WebDispatcherServletConfigure implements WebMvcConfigurer { @Bean public ViewResolver viewResolver() { InternalResourceViewResolver resourceViewResolver = new InternalResourceViewResolver(); resourceViewResolver.setViewClass(JstlView.class); resourceViewResolver.setPrefix("/WEB-INF/jsp/"); resourceViewResolver.setSuffix(".jsp"); return resourceViewResolver; }}Copy the code

So why does the @enableWebMVC annotation cause the default to take effect? Let’s take a look at its source code:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(DelegatingWebMvcConfiguration.class)
public @interface EnableWebMvc {
}
Copy the code

On the annotations EnableWebMvc by @ Import Import DelegatingWebMvcConfiguration class. Does this class look familiar? Right, that is, the inherited WebMvcConfigurationSupport class we talked about above. That is to say, once use @ EnableWebMvc comment, will import a WebMvcConfigurationSupport, which produces a Bean. At this point, going back to the previous conclusion, WebMvcAutoConfiguration finds that such a Bean already exists and will not be instantiated.

Summary is WebMvcConfigurationSupport has three kinds of realization forms: first, the realization of the user-defined WebMvcConfigurationSupport class, at this point will cause WebMvcAutoConfiguration not instantiate; Second, using the @ EnableWebMvc annotations, is equal to the expanded the WebMvcConfigurationSupport, but there is no override any way, at this time also causes WebMvcAutoConfiguration not instantiate; Third, using the default configuration, WebMvcAutoConfiguration corresponding WebMvcConfigurationSupport implementation class to instantiate.

Therefore, we usually implement the WebMvcConfigurer interface and leave Spring Boot with the default configuration.

Override addResourceHandlers to configure path access and so on, Spring Boot in mapping the classpath to use ResourceHttpRequestHandler by default/static/public, resources, and/METAINF/resources directory or ServletContext static files in the root directory of the direct mapping For/with / * * * *.

Public void addResourceHandlers(ResourceHandlerRegistry registry) {// Static resource path CSS,js,img, etc registry.addResourceHandler("/statics/**").addResourceLocations("classpath:/statics/"); / / view registry. AddResourceHandler ("/templates / * * "). AddResourceLocations (" classpath: / templates/"); //mapper.xml registry.addResourceHandler("/mapper/**").addResourceLocations("classpath:/mapper/"); super.addResourceHandlers(registry); }Copy the code

Rewrite the addCorsMappings method to implement configuring CORS cross-domain restrictions, etc.

@override public void addCorsMappings(CorsRegistry registry) {registry. AddMapping ("/**")// Configure the connection routes that are allowed across domains AllowedOrigins (" * "), / / configuration is allowed to access the resources of cross-domain request domain. The allowedMethods (" PUT, POST, GET, DELETE, the OPTIONS ") / / configuration allows access to the cross-domain resources server request method, such as: POST, GET, PUT, DELETE, etc. AllowedHeaders ("*"); // Configure to allow header access, such as x-token super.addCorsmappings (Registry); }Copy the code

Rewrite configureMessageConverters method to transform for news. MessageConverter is used to convert the returned RESULT of HTTP request in fastjon, application/ JSON format. Charset =UTF-8 for conversion.

@Override public void configureMessageConverters(List<HttpMessageConverter<? >> converters) { StringHttpMessageConverter converter = new StringHttpMessageConverter(Charset.forName("UTF-8")); converters.add(converter); }Copy the code

Override the configureViewResolvers() method to configure the view resolvers, primarily to configure the prefixes and suffixes of the view.

@Override public void configureViewResolvers(ViewResolverRegistry registry) { InternalResourceViewResolver viewResolver = new InternalResourceViewResolver(); viewResolver.setPrefix(""); viewResolver.setSuffix(".html"); viewResolver.setCache(false); viewResolver.setContentType("text/html; charset=UTF-8"); viewResolver.setOrder(0); registry.viewResolver(viewResolver); super.configureViewResolvers(registry); }Copy the code

Simplified versions are also provided for adoption, such as:

@Override
public void configureViewResolvers(ViewResolverRegistry registry) {
    registry.jsp("/", ".jsp");
}
Copy the code