@Bean
 @ConditionalOnBean(View.class)
 @ConditionalOnMissingBean
 public BeanNameViewResolver beanNameViewResolver() {
     BeanNameViewResolver resolver = new BeanNameViewResolver();
     resolver.setOrder(Ordered.LOWEST_PRECEDENCE - 10);
     return resolver;
 }

 @Override
 public View resolveViewName(String viewName, Locale locale) throws BeansException {
     ApplicationContext context = getApplicationContext();
     if (!context.containsBean(viewName)) {
         if (logger.isDebugEnabled()) {
             logger.debug("No matching bean found for view name '" + viewName + "'");
         }
         // Allow for ViewResolver chaining...
         return null;
     }
     if (!context.isTypeMatch(viewName, View.class)) {
         if (logger.isDebugEnabled()) {
             logger.debug("Found matching bean for view name '" + viewName +
                     "' - to be ignored since it does not implement View");
         }
         // Since we're looking into the general ApplicationContext here,
         // let's accept this as a non-match and allow for chaining as well...
         return null;
     }
     return context.getBean(viewName, View.class);
 }

@Bean
@ConditionalOnBean(ViewResolver.class)
@ConditionalOnMissingBean(name = "viewResolver", value = ContentNegotiatingViewResolver.class)
public ContentNegotiatingViewResolver viewResolver(BeanFactory beanFactory) {
    ContentNegotiatingViewResolver resolver = new ContentNegotiatingViewResolver();
    resolver.setContentNegotiationManager(
            beanFactory.getBean(ContentNegotiationManager.class));
    resolver.setOrder(Ordered.HIGHEST_PRECEDENCE);
    return resolver;
}

 @Override
 public View resolveViewName(String viewName, Locale locale) throws Exception {
     RequestAttributes attrs = RequestContextHolder.getRequestAttributes();
     Assert.isInstanceOf(ServletRequestAttributes.class, attrs);
     List<MediaType> requestedMediaTypes = getMediaTypes(((ServletRequestAttributes) attrs).getRequest());
     if (requestedMediaTypes != null) {
         List<View> candidateViews = getCandidateViews(viewName, locale, requestedMediaTypes);
         View bestView = getBestView(candidateViews, requestedMediaTypes, attrs);
         if (bestView != null) {
             return bestView;
         }
     }
     if (this.useNotAcceptableStatusCode) {
         if (logger.isDebugEnabled()) {
             logger.debug("No acceptable view found; returning 406 (Not Acceptable) status code");
         }
         return NOT_ACCEPTABLE_VIEW;
     }
     else {
         logger.debug("No acceptable view found; returning null");
         return null;
     }
 }

 private List<View> getCandidateViews(String viewName, Locale locale, List<MediaType> requestedMediaTypes)
         throws Exception {

     List<View> candidateViews = new ArrayList<View>();
     for (ViewResolver viewResolver : this.viewResolvers) {
         View view = viewResolver.resolveViewName(viewName, locale);
         if (view != null) {
             candidateViews.add(view);
         }
         for (MediaType requestedMediaType : requestedMediaTypes) {
             List<String> extensions = this.contentNegotiationManager.resolveFileExtensions(requestedMediaType);
             for (String extension : extensions) {
                 String viewNameWithExtension = viewName + "." + extension;
                 view = viewResolver.resolveViewName(viewNameWithExtension, locale);
                 if (view != null) {
                     candidateViews.add(view);
                 }
             }
         }
     }
     if (!CollectionUtils.isEmpty(this.defaultViews)) {
         candidateViews.addAll(this.defaultViews);
     }
     return candidateViews;
 }

 @Override
 protected void initServletContext(ServletContext servletContext) {
     Collection<ViewResolver> matchingBeans =
             BeanFactoryUtils.beansOfTypeIncludingAncestors(getApplicationContext(), ViewResolver.class).values();
     if (this.viewResolvers == null) {
         this.viewResolvers = new ArrayList<ViewResolver>(matchingBeans.size());
         for (ViewResolver viewResolver : matchingBeans) {
             if (this != viewResolver) {
                 this.viewResolvers.add(viewResolver);
             }
         }
     }
     else {
         for (int i = 0; i < viewResolvers.size(); i++) {
             if (matchingBeans.contains(viewResolvers.get(i))) {
                 continue;
             }
             String name = viewResolvers.get(i).getClass().getName() + i;
             getApplicationContext().getAutowireCapableBeanFactory().initializeBean(viewResolvers.get(i), name);
         }

     }
     if (this.viewResolvers.isEmpty()) {
         logger.warn("Did not find any ViewResolvers to delegate to; please configure them using the " +
                 "'viewResolvers' property on the ContentNegotiatingViewResolver");
     }
     AnnotationAwareOrderComparator.sort(this.viewResolvers);
     this.cnmFactoryBean.setServletContext(servletContext);
 }

 @Bean
 @ConditionalOnProperty(prefix = "spring.mvc", name = "date-format")
 public Formatter<Date> dateFormatter() {
     return new DateFormatter(this.mvcProperties.getDateFormat());
 }

 @Override
 public void addFormatters(FormatterRegistry registry) {
     for (Converter<?, ?> converter : getBeansOfType(Converter.class)) {
         registry.addConverter(converter);
     }
     for (GenericConverter converter : getBeansOfType(GenericConverter.class)) {
         registry.addConverter(converter);
     }
     for (Formatter<?> formatter : getBeansOfType(Formatter.class)) {
         registry.addFormatter(formatter);
     }
 }

 private <T> Collection<T> getBeansOfType(Class<T> type) {
     return this.beanFactory.getBeansOfType(type).values();
 }

 @Configuration
 @Import(EnableWebMvcConfiguration.class)
 @EnableConfigurationProperties({ WebMvcProperties.class, ResourceProperties.class })
 public static class WebMvcAutoConfigurationAdapter extends WebMvcConfigurerAdapter {

     private static final Log logger = LogFactory
             .getLog(WebMvcConfigurerAdapter.class);

     private final ResourceProperties resourceProperties;

     private final WebMvcProperties mvcProperties;

     private final ListableBeanFactory beanFactory;

     private final HttpMessageConverters messageConverters;

     final ResourceHandlerRegistrationCustomizer resourceHandlerRegistrationCustomizer;

     public WebMvcAutoConfigurationAdapter(ResourceProperties resourceProperties,
             WebMvcProperties mvcProperties, ListableBeanFactory beanFactory,
             @Lazy HttpMessageConverters messageConverters,
             ObjectProvider<ResourceHandlerRegistrationCustomizer> resourceHandlerRegistrationCustomizerProvider) {
         this.resourceProperties = resourceProperties;
         this.mvcProperties = mvcProperties;
         this.beanFactory = beanFactory;
         this.messageConverters = messageConverters;
         this.resourceHandlerRegistrationCustomizer = resourceHandlerRegistrationCustomizerProvider
                 .getIfAvailable();
     }

     @Override
     public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
         converters.addAll(this.messageConverters.getConverters());
     }

 public class HttpMessageConverters implements Iterable<HttpMessageConverter<?>> {

     private static final List<Class<?>> NON_REPLACING_CONVERTERS;

     static {
         List<Class<?>> nonReplacingConverters = new ArrayList<Class<?>>();
         addClassIfExists(nonReplacingConverters, "org.springframework.hateoas.mvc."
                 + "TypeConstrainedMappingJackson2HttpMessageConverter");
         NON_REPLACING_CONVERTERS = Collections.unmodifiableList(nonReplacingConverters);
     }

     private final List<HttpMessageConverter<?>> converters;

     /**
      * Create a new {@link HttpMessageConverters} instance with the specified additional
      * converters.
      * @param additionalConverters additional converters to be added. New converters will
      * be added to the front of the list, overrides will replace existing items without
      * changing the order. The {@link #getConverters()} methods can be used for further
      * converter manipulation.
      */
     public HttpMessageConverters(HttpMessageConverter<?>... additionalConverters) {
         this(Arrays.asList(additionalConverters));
     }

     /**
      * Create a new {@link HttpMessageConverters} instance with the specified additional
      * converters.
      * @param additionalConverters additional converters to be added. Items are added just
      * before any default converter of the same type (or at the front of the list if no
      * default converter is found) The {@link #postProcessConverters(List)} method can be
      * used for further converter manipulation.
      */
     public HttpMessageConverters(
             Collection<HttpMessageConverter<?>> additionalConverters) {
         this(true, additionalConverters);
     }

     /**
      * Create a new {@link HttpMessageConverters} instance with the specified converters.
      * @param addDefaultConverters if default converters should be added
      * @param converters converters to be added. Items are added just before any default
      * converter of the same type (or at the front of the list if no default converter is
      * found) The {@link #postProcessConverters(List)} method can be used for further
      * converter manipulation.
      */
     public HttpMessageConverters(boolean addDefaultConverters,
             Collection<HttpMessageConverter<?>> converters) {
         List<HttpMessageConverter<?>> combined = getCombinedConverters(converters,
                 addDefaultConverters ? getDefaultConverters()
                         : Collections.<HttpMessageConverter<?>>emptyList());
         combined = postProcessConverters(combined);
         this.converters = Collections.unmodifiableList(combined);
     }

 @Override
 public MessageCodesResolver getMessageCodesResolver() {
     if (this.mvcProperties.getMessageCodesResolverFormat() != null) {
         DefaultMessageCodesResolver resolver = new DefaultMessageCodesResolver();
         resolver.setMessageCodeFormatter(
                 this.mvcProperties.getMessageCodesResolverFormat());
         return resolver;
     }
     return null;
 }

 @Override
 protected ConfigurableWebBindingInitializer getConfigurableWebBindingInitializer() {
     try {
         return this.beanFactory.getBean(ConfigurableWebBindingInitializer.class);
     }
     catch (NoSuchBeanDefinitionException ex) {
         return super.getConfigurableWebBindingInitializer();
     }
 }

package com.springboot.webdev1.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

/**
 *  要扩展什么功能直接重写对应方法即可
 *  既保留了所有自动配置，也使用了我们扩展的配置
 */
@Configuration
public class MyMvcConfig extends WebMvcConfigurerAdapter {

    /**
     * 添加视图映射
     * @param registry
     */
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        // 请求路径 /test 将会转发到名为 test 的视图
        registry.addViewController("/test").setViewName("test");
    }
}

@Configuration
@Import(EnableWebMvcConfiguration.class)
@EnableConfigurationProperties({ WebMvcProperties.class, ResourceProperties.class })
public static class WebMvcAutoConfigurationAdapter extends WebMvcConfigurerAdapter {

org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration.WebMvcAutoConfigurationAdapter

@Configuration
public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration {   

org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration.EnableWebMvcConfiguration

 package org.springframework.web.servlet.config.annotation;

 import java.util.List;

 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.format.FormatterRegistry;
 import org.springframework.http.converter.HttpMessageConverter;
 import org.springframework.validation.MessageCodesResolver;
 import org.springframework.validation.Validator;
 import org.springframework.web.method.support.HandlerMethodArgumentResolver;
 import org.springframework.web.method.support.HandlerMethodReturnValueHandler;
 import org.springframework.web.servlet.HandlerExceptionResolver;

 @Configuration
 public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {

     private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();

     @Autowired(required = false)
     public void setConfigurers(List<WebMvcConfigurer> configurers) {
         if (configurers == null || configurers.isEmpty()) {
             return;
         }
         this.configurers.addWebMvcConfigurers(configurers);
     }

     @Override
     protected void addInterceptors(InterceptorRegistry registry) {
         this.configurers.addInterceptors(registry);
     }

     @Override
     protected void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
         this.configurers.configureContentNegotiation(configurer);
     }

     @Override
     public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
         this.configurers.configureAsyncSupport(configurer);
     }

     @Override
     public void configurePathMatch(PathMatchConfigurer configurer) {
         this.configurers.configurePathMatch(configurer);
     }

     @Override
     protected void addViewControllers(ViewControllerRegistry registry) {
         this.configurers.addViewControllers(registry);
     }

     @Override
     protected void configureViewResolvers(ViewResolverRegistry registry) {
         this.configurers.configureViewResolvers(registry);
     }

     @Override
     protected void addResourceHandlers(ResourceHandlerRegistry registry) {
         this.configurers.addResourceHandlers(registry);
     }

     @Override
     protected void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
         this.configurers.configureDefaultServletHandling(configurer);
     }

     @Override
     protected void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
         this.configurers.addArgumentResolvers(argumentResolvers);
     }

     @Override
     protected void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> returnValueHandlers) {
         this.configurers.addReturnValueHandlers(returnValueHandlers);
     }

     @Override
     protected void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
         this.configurers.configureMessageConverters(converters);
     }

     @Override
     protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
         this.configurers.extendMessageConverters(converters);
     }

     @Override
     protected void addFormatters(FormatterRegistry registry) {
         this.configurers.addFormatters(registry);
     }

     @Override
     protected Validator getValidator() {
         return this.configurers.getValidator();
     }

     @Override
     protected MessageCodesResolver getMessageCodesResolver() {
         return this.configurers.getMessageCodesResolver();
     }

     @Override
     protected void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {
         this.configurers.configureHandlerExceptionResolvers(exceptionResolvers);
     }

     @Override
     protected void addCorsMappings(CorsRegistry registry) {
         this.configurers.addCorsMappings(registry);
     }

 }

org.springframework.web.servlet.config.annotation.DelegatingWebMvcConfiguration

package com.springboot.webdev1.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

/**
 *  全面接管 SpringMVC 配置，Spring 的自动配置已失效
 */
@EnableWebMvc
@Configuration
public class MyMvcConfig extends WebMvcConfigurerAdapter {

    /**
     * 添加视图映射
     * @param registry
     */
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        // 请求路径 /test 将会转发到名为 test 的视图
        registry.addViewController("/test").setViewName("test");
    }
}

 @Configuration
 @ConditionalOnWebApplication
 @ConditionalOnClass({ Servlet.class, DispatcherServlet.class,
         WebMvcConfigurerAdapter.class })
 @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
 @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
 @AutoConfigureAfter({ DispatcherServletAutoConfiguration.class,
         ValidationAutoConfiguration.class })
 public class WebMvcAutoConfiguration {

org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration

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

org.springframework.web.servlet.config.annotation.EnableWebMvc