精通SpringBoot——第一篇：DispatcherServlet和Multipart配置-白红宇

如果大家搭建过SpringMVC应用，那么一定会写个几个xml配置文件，如

application.xml, spring-mvc.xml 等。一般来说，我们搭建项目的初始步骤如下：

初始化Spring MVC 的DispatcherServlet;

添加转码过滤器(HttpMessageConverter)，保证客户端请求都能正确的编码

搭建视图解析器（view resolver)，告诉Spring去哪里查找视图，以及视图方言（如Freemarker, Thymeleaf等）。

配置静态资源（css,js,image等）

配置mulpart解析器，保证文件上传正常。

配置一些错误处理，AOP切面日志等。

当我们开始使用SpringBoot来搭建我们的Web项目的时候，你会发现，这些事情SpringBoot默认都帮你处理了。

SpringBoot原则是约定优于配置，并且默认情况下，会在你的项目中使用这些约定。

接下来，让我们来了解下，幕后发生了什么？

首先让我们新建一个SpringBoot项目，并在src/main/resources/中的application.properties增加一行：debug=true。

OK，现在我们启动下项目看看控制台的输出。

============================CONDITIONS EVALUATION REPORT============================Positive matches:-----------------   CodecsAutoConfiguration matched:      - @ConditionalOnClass found required class 'org.springframework.http.codec.CodecConfigurer'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition)···（中间就省略了）Negative matches:-----------------   ActiveMQAutoConfiguration:      Did not match:         - @ConditionalOnClass did not find required classes 'javax.jms.ConnectionFactory', 'org.apache.activemq.ActiveMQConnectionFactory' (OnClassCondition)

我们可以看到Spring Boot 的自动配置报告。它分为两部分：一部分是匹配上的（positive matches），列出了应用中所有的自动配置。另一部分是没有匹配上的（negative matches），这部分是应用在启动的时候，需求没有满足的Spring Boot自动配置。

接下来重点看下DispatcherServletAutoConfiguration这个类的源码(想想还是贴一下源码吧...)

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)@Configuration@ConditionalOnWebApplication(type = Type.SERVLET)@ConditionalOnClass(DispatcherServlet.class)@AutoConfigureAfter(ServletWebServerFactoryAutoConfiguration.class)@EnableConfigurationProperties(ServerProperties.class)public class DispatcherServletAutoConfiguration {    /*     * The bean name for a DispatcherServlet that will be mapped to the root URL "/"     */    public static final String DEFAULT_DISPATCHER_SERVLET_BEAN_NAME = "dispatcherServlet";    /*     * The bean name for a ServletRegistrationBean for the DispatcherServlet "/"     */    public static final String DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME = "dispatcherServletRegistration";    @Configuration    @Conditional(DefaultDispatcherServletCondition.class)    @ConditionalOnClass(ServletRegistration.class)    @EnableConfigurationProperties(WebMvcProperties.class)    protected static class DispatcherServletConfiguration {        private final WebMvcProperties webMvcProperties;        private final ServerProperties serverProperties;        public DispatcherServletConfiguration(WebMvcProperties webMvcProperties,                ServerProperties serverProperties) {            this.webMvcProperties = webMvcProperties;            this.serverProperties = serverProperties;        }        @Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)        public DispatcherServlet dispatcherServlet() {            DispatcherServlet dispatcherServlet = new DispatcherServlet();            dispatcherServlet.setDispatchOptionsRequest(                    this.webMvcProperties.isDispatchOptionsRequest());            dispatcherServlet.setDispatchTraceRequest(                    this.webMvcProperties.isDispatchTraceRequest());            dispatcherServlet.setThrowExceptionIfNoHandlerFound(                    this.webMvcProperties.isThrowExceptionIfNoHandlerFound());            return dispatcherServlet;        }        @Bean        @ConditionalOnBean(MultipartResolver.class)        @ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME)        public MultipartResolver multipartResolver(MultipartResolver resolver) {            // Detect if the user has created a MultipartResolver but named it incorrectly            return resolver;        }        @Bean        public DispatcherServletPathProvider mainDispatcherServletPathProvider() {            return () -> DispatcherServletConfiguration.this.serverProperties.getServlet()                    .getPath();        }    }    @Configuration    @Conditional(DispatcherServletRegistrationCondition.class)    @ConditionalOnClass(ServletRegistration.class)    @EnableConfigurationProperties(WebMvcProperties.class)    @Import(DispatcherServletConfiguration.class)    protected static class DispatcherServletRegistrationConfiguration {        private final ServerProperties serverProperties;        private final WebMvcProperties webMvcProperties;        private final MultipartConfigElement multipartConfig;        public DispatcherServletRegistrationConfiguration(                ServerProperties serverProperties, WebMvcProperties webMvcProperties,                ObjectProvider
    
      multipartConfigProvider) {            this.serverProperties = serverProperties;            this.webMvcProperties = webMvcProperties;            this.multipartConfig = multipartConfigProvider.getIfAvailable();        }        @Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)        @ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)        public ServletRegistrationBean
     
       dispatcherServletRegistration(                DispatcherServlet dispatcherServlet) {            ServletRegistrationBean
      
        registration = new ServletRegistrationBean<>(                    dispatcherServlet,                    this.serverProperties.getServlet().getServletMapping());            registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);            registration.setLoadOnStartup(                    this.webMvcProperties.getServlet().getLoadOnStartup());            if (this.multipartConfig != null) {                registration.setMultipartConfig(this.multipartConfig);            }            return registration;        }    }    @Order(Ordered.LOWEST_PRECEDENCE - 10)    private static class DefaultDispatcherServletCondition extends SpringBootCondition {        @Override        public ConditionOutcome getMatchOutcome(ConditionContext context,                AnnotatedTypeMetadata metadata) {            ConditionMessage.Builder message = ConditionMessage                    .forCondition("Default DispatcherServlet");            ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();            List
       
         dispatchServletBeans = Arrays.asList(beanFactory                    .getBeanNamesForType(DispatcherServlet.class, false, false));            if (dispatchServletBeans.contains(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)) {                return ConditionOutcome.noMatch(message.found("dispatcher servlet bean")                        .items(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME));            }            if (beanFactory.containsBean(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)) {                return ConditionOutcome                        .noMatch(message.found("non dispatcher servlet bean")                                .items(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME));            }            if (dispatchServletBeans.isEmpty()) {                return ConditionOutcome                        .match(message.didNotFind("dispatcher servlet beans").atAll());            }            return ConditionOutcome.match(message                    .found("dispatcher servlet bean", "dispatcher servlet beans")                    .items(Style.QUOTE, dispatchServletBeans)                    .append("and none is named " + DEFAULT_DISPATCHER_SERVLET_BEAN_NAME));        }    }    @Order(Ordered.LOWEST_PRECEDENCE - 10)    private static class DispatcherServletRegistrationCondition            extends SpringBootCondition {        @Override        public ConditionOutcome getMatchOutcome(ConditionContext context,                AnnotatedTypeMetadata metadata) {            ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();            ConditionOutcome outcome = checkDefaultDispatcherName(beanFactory);            if (!outcome.isMatch()) {                return outcome;            }            return checkServletRegistration(beanFactory);        }        private ConditionOutcome checkDefaultDispatcherName(                ConfigurableListableBeanFactory beanFactory) {            List
        
          servlets = Arrays.asList(beanFactory                    .getBeanNamesForType(DispatcherServlet.class, false, false));            boolean containsDispatcherBean = beanFactory                    .containsBean(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);            if (containsDispatcherBean                    && !servlets.contains(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)) {                return ConditionOutcome                        .noMatch(startMessage().found("non dispatcher servlet")                                .items(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME));            }            return ConditionOutcome.match();        }        private ConditionOutcome checkServletRegistration(                ConfigurableListableBeanFactory beanFactory) {            ConditionMessage.Builder message = startMessage();            List
         
           registrations = Arrays.asList(beanFactory .getBeanNamesForType(ServletRegistrationBean.class, false, false)); boolean containsDispatcherRegistrationBean = beanFactory .containsBean(DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME); if (registrations.isEmpty()) { if (containsDispatcherRegistrationBean) { return ConditionOutcome .noMatch(message.found("non servlet registration bean").items( DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)); } return ConditionOutcome .match(message.didNotFind("servlet registration bean").atAll()); } if (registrations .contains(DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)) { return ConditionOutcome.noMatch(message.found("servlet registration bean") .items(DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)); } if (containsDispatcherRegistrationBean) { return ConditionOutcome .noMatch(message.found("non servlet registration bean").items( DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)); } return ConditionOutcome.match(message.found("servlet registration beans") .items(Style.QUOTE, registrations).append("and none is named " + DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)); } private ConditionMessage.Builder startMessage() { return ConditionMessage.forCondition("DispatcherServlet Registration"); } }}

先看类注解@Configuration，很明显这是一个典型的SpringBoot配置类。

@AutoConfigurerOrder来声明优先级。

@AutoConfigureAfter 或@AutoConfigureBefore，从而进一步细化配置处理的顺序。

@ConditionalOnClass (DispatcherServlet.class)这个特殊的配置，能够确保我们的类路径下包含 DispatcherServlet。

@Conditional(DefaultDispatcherServletCondition.class)条件满足的情况下，ServletRegistrationBean 函数才会启用，这有些复杂，但是能够检查在你的配置中，是否已经注册了分发器 Servlet

@ConditionalOnMissingBean(name=DispatcherServlet.MULTIPART_RESOLVER_ BEAN_NAME)条件的情况下，MultipartResolver 函数才会处于激活状态，例如，当我们自己还没有注册的时候。