SpringBoot2.3.1嵌入式Servlet容器自動配置原理

 

 

Servlet容器的自動配置是通過ServletWebServerFactoryAutoConfiguration 自動配置類來實現的，先不看里面方法，從類注解看起。

@Configuration(
    proxyBeanMethods = false
) //表示這個一個配置類
@AutoConfigureOrder(-2147483648)
@ConditionalOnClass({ServletRequest.class}) //只有包含ServletRequest這個類的時候此配置類才會生效
@ConditionalOnWebApplication(
    type = Type.SERVLET
)//當前是web環境
@EnableConfigurationProperties({ServerProperties.class})//啟動指定類的ConfigurationProperties功能；將配置文件中對應的值和ServerProperties綁定起來；並把ServerProperties加入到ioc容器中
@Import({ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class, EmbeddedTomcat.class, EmbeddedJetty.class, EmbeddedUndertow.class})//導入這四個Bean到容器中，下面詳細講解
public class ServletWebServerFactoryAutoConfiguration {
}

 首先略過BeanPostProcessorsRegistrar,來看EmbeddeTomcat.class

@ConditionalOnClass({Servlet.class, Tomcat.class, UpgradeProtocol.class})//只有包含Tomcat類時才會生效，不同的Servlet容器引入jar包不同，Jetty與UnderTow的配置也是通過這個區分
    @ConditionalOnMissingBean(
        value = {ServletWebServerFactory.class},
        search = SearchStrategy.CURRENT
    )//當系統中沒有ServletWebServerFactory時，才會使用下面創建的、//ServletWebServerFactory，通過這其實可以看出，我們可以自定義ServletWebServerFactory來實現自己的配置

  static class EmbeddedTomcat {
    EmbeddedTomcat() {
    }

    @Bean
    TomcatServletWebServerFactory tomcatServletWebServerFactory(ObjectProvider<TomcatConnectorCustomizer> connectorCustomizers, ObjectProvider<TomcatContextCustomizer> contextCustomizers, ObjectProvider<TomcatProtocolHandlerCustomizer<?>> protocolHandlerCustomizers) {
        TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
 factory.getTomcatConnectorCustomizers().addAll((Collection)connectorCustomizers.orderedStream().collect(Collectors.toList()));
 factory.getTomcatContextCustomizers().addAll((Collection)contextCustomizers.orderedStream().collect(Collectors.toList()));
 factory.getTomcatProtocolHandlerCustomizers().addAll((Collection)protocolHandlerCustomizers.orderedStream().collect(Collectors.toList()));
 return factory;
 }
}

其實只干了一件事，就是將TomcatServletWebServerFactory 注冊到容器當中，點開TomcatServletWebServerFactory 看一下。

里面關鍵是這個方法

public WebServer getWebServer(ServletContextInitializer... initializers) {
        if (this.disableMBeanRegistry) {
            Registry.disableRegistry();
        }

        Tomcat tomcat = new Tomcat();
        File baseDir = this.baseDirectory != null ? this.baseDirectory : this.createTempDir("tomcat");
        tomcat.setBaseDir(baseDir.getAbsolutePath());
        Connector connector = new Connector(this.protocol);
        connector.setThrowOnFailure(true);
        tomcat.getService().addConnector(connector);
        this.customizeConnector(connector);
        tomcat.setConnector(connector);
        tomcat.getHost().setAutoDeploy(false);
        this.configureEngine(tomcat.getEngine());
        Iterator var5 = this.additionalTomcatConnectors.iterator();

        while(var5.hasNext()) {
            Connector additionalConnector = (Connector)var5.next();
            tomcat.getService().addConnector(additionalConnector);
        }

        this.prepareContext(tomcat.getHost(), initializers);
        return this.getTomcatWebServer(tomcat);
    }

其實用用java生成了一個tomcat，然后繼續點擊getTomcatWebServer，TomcatServletWebServerFactory 會新創建類一個TomcatWebServer

protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) {
        return new TomcatWebServer(tomcat, this.getPort() >= 0, this.getShutdown());
    }

在不修改端口號的情況下TomcatServletWebServerFactory 默認配置端口為8080

 public int getPort() {
        return this.port;
 }
 private int port = 8080;

    public TomcatWebServer(Tomcat tomcat, boolean autoStart, Shutdown shutdown) {
        this.monitor = new Object();
        this.serviceConnectors = new HashMap();
        Assert.notNull(tomcat, "Tomcat Server must not be null");
        this.tomcat = tomcat;
        this.autoStart = autoStart;
        this.gracefulShutdown = shutdown == Shutdown.GRACEFUL ? new GracefulShutdown(tomcat) : null;
        this.initialize(); //執行初始化
    }

    private void initialize() throws WebServerException {
        logger.info("Tomcat initialized with port(s): " + this.getPortsDescription(false));
        synchronized(this.monitor) {
            try {
                this.addInstanceIdToEngineName();
                Context context = this.findContext();
                context.addLifecycleListener((event) -> {
                    if (context.equals(event.getSource()) && "start".equals(event.getType())) {
                        this.removeServiceConnectors();
                    }

                });
                this.tomcat.start();//tomcat被啟動
                this.rethrowDeferredStartupExceptions();

                try {
                    ContextBindings.bindClassLoader(context, context.getNamingToken(), this.getClass().getClassLoader());
                } catch (NamingException var5) {
                }

                this.startDaemonAwaitThread();
            } catch (Exception var6) {
                this.stopSilently();
                this.destroySilently();
                throw new WebServerException("Unable to start embedded Tomcat", var6);
            }

        }
    }

同理EmbeddedJetty與EmbeddedUndertow也是如此。

那么我們如何自定義相關配置，又如何生效呢？

有兩種方式：

1、通過application.yml里面配置。如何生效？

 

 

 回到最上面，引入ServerProperties。打開看一下

@ConfigurationProperties(
    prefix = "server",
    ignoreUnknownFields = true
)//是與配置文件中的server下的內容綁定，我們能配置的內容也就是下面下面這些
public class ServerProperties {
    private Integer port;
    private InetAddress address;
    @NestedConfigurationProperty
    private final ErrorProperties error = new ErrorProperties();
    private ServerProperties.ForwardHeadersStrategy forwardHeadersStrategy;
    private String serverHeader;
    private DataSize maxHttpHeaderSize = DataSize.ofKilobytes(8L);
    private Shutdown shutdown;
    @NestedConfigurationProperty
    private Ssl ssl;
    @NestedConfigurationProperty
    private final Compression compression;
    @NestedConfigurationProperty
    private final Http2 http2;
    private final ServerProperties.Servlet servlet;
    private final ServerProperties.Tomcat tomcat;
    private final ServerProperties.Jetty jetty;
    private final ServerProperties.Netty netty;
    private final ServerProperties.Undertow undertow;
｝

配置內容與bean綁定以后如何生效的呢？下面就用到了自動配置類里面的代碼

  @Bean
    public ServletWebServerFactoryCustomizer servletWebServerFactoryCustomizer(ServerProperties serverProperties) {
        return new ServletWebServerFactoryCustomizer(serverProperties);
    }

    @Bean
    @ConditionalOnClass(
        name = {"org.apache.catalina.startup.Tomcat"}
    )
    public TomcatServletWebServerFactoryCustomizer tomcatServletWebServerFactoryCustomizer(ServerProperties serverProperties) {
        return new TomcatServletWebServerFactoryCustomizer(serverProperties);
    }

注冊ServletWebServerFactoryCustomizer與TomcatServletWebServerFactoryCustomizer兩個對象到Spring容器中時傳入。

 

public class ServletWebServerFactoryCustomizer implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory>, Ordered {
    private final ServerProperties serverProperties;

    public ServletWebServerFactoryCustomizer(ServerProperties serverProperties) {
        this.serverProperties = serverProperties;
    }

    public int getOrder() {
        return 0;
    }

    public void customize(ConfigurableServletWebServerFactory factory) {
        PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
        ServerProperties var10001 = this.serverProperties;
        var10001.getClass();
        map.from(var10001::getPort).to(factory::setPort);
        var10001 = this.serverProperties;
        var10001.getClass();
        map.from(var10001::getAddress).to(factory::setAddress);
        Servlet var3 = this.serverProperties.getServlet();
        var3.getClass();
        map.from(var3::getContextPath).to(factory::setContextPath);
        var3 = this.serverProperties.getServlet();
        var3.getClass();
        map.from(var3::getApplicationDisplayName).to(factory::setDisplayName);
        var3 = this.serverProperties.getServlet();
        var3.getClass();
        map.from(var3::isRegisterDefaultServlet).to(factory::setRegisterDefaultServlet);
        var3 = this.serverProperties.getServlet();
        var3.getClass();
        map.from(var3::getSession).to(factory::setSession);
        var10001 = this.serverProperties;
        var10001.getClass();
        map.from(var10001::getSsl).to(factory::setSsl);
        var3 = this.serverProperties.getServlet();
        var3.getClass();
        map.from(var3::getJsp).to(factory::setJsp);
        var10001 = this.serverProperties;
        var10001.getClass();
        map.from(var10001::getCompression).to(factory::setCompression);
        var10001 = this.serverProperties;
        var10001.getClass();
        map.from(var10001::getHttp2).to(factory::setHttp2);
        var10001 = this.serverProperties;
        var10001.getClass();
        map.from(var10001::getServerHeader).to(factory::setServerHeader);
        var3 = this.serverProperties.getServlet();
        var3.getClass();
        map.from(var3::getContextParameters).to(factory::setInitParameters);
        map.from(this.serverProperties.getShutdown()).to(factory::setShutdown);
    }
}

 

public class TomcatServletWebServerFactoryCustomizer implements WebServerFactoryCustomizer<TomcatServletWebServerFactory>, Ordered {
    private final ServerProperties serverProperties;

    public TomcatServletWebServerFactoryCustomizer(ServerProperties serverProperties) {
        this.serverProperties = serverProperties;
    }

    public int getOrder() {
        return 0;
    }

    public void customize(TomcatServletWebServerFactory factory) {
        Tomcat tomcatProperties = this.serverProperties.getTomcat();
        if (!ObjectUtils.isEmpty(tomcatProperties.getAdditionalTldSkipPatterns())) {
            factory.getTldSkipPatterns().addAll(tomcatProperties.getAdditionalTldSkipPatterns());
        }

        if (tomcatProperties.getRedirectContextRoot() != null) {
            this.customizeRedirectContextRoot(factory, tomcatProperties.getRedirectContextRoot());
        }

        this.customizeUseRelativeRedirects(factory, tomcatProperties.isUseRelativeRedirects());
        factory.setDisableMBeanRegistry(!tomcatProperties.getMbeanregistry().isEnabled());
    }

    private void customizeRedirectContextRoot(ConfigurableTomcatWebServerFactory factory, boolean redirectContextRoot) {
        factory.addContextCustomizers(new TomcatContextCustomizer[]{(context) -> {
            context.setMapperContextRootRedirectEnabled(redirectContextRoot);
        }});
    }

    private void customizeUseRelativeRedirects(ConfigurableTomcatWebServerFactory factory, boolean useRelativeRedirects) {
        factory.addContextCustomizers(new TomcatContextCustomizer[]{(context) -> {
            context.setUseRelativeRedirects(useRelativeRedirects);
        }});
    }
}

 

 

 

打開兩個類可以看到在customize方法里面會被應用，去配置對應的容器工廠類。聯系上面，工廠類是用來注冊容器實例的，那么這個customize這個配置一定會在此之前被調用，什么時候呢？這時候來看開頭忽略的Import

BeanPostProcessorsRegistrar

 

public static class BeanPostProcessorsRegistrar implements ImportBeanDefinitionRegistrar, BeanFactoryAware {
        private ConfigurableListableBeanFactory beanFactory;

        public BeanPostProcessorsRegistrar() {
        }

        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
            if (beanFactory instanceof ConfigurableListableBeanFactory) {
                this.beanFactory = (ConfigurableListableBeanFactory)beanFactory;
            }

        }

        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
            if (this.beanFactory != null) {
                this.registerSyntheticBeanIfMissing(registry, "webServerFactoryCustomizerBeanPostProcessor", WebServerFactoryCustomizerBeanPostProcessor.class);
                this.registerSyntheticBeanIfMissing(registry, "errorPageRegistrarBeanPostProcessor", ErrorPageRegistrarBeanPostProcessor.class);
            }
        }

        private void registerSyntheticBeanIfMissing(BeanDefinitionRegistry registry, String name, Class<?> beanClass) {
            if (ObjectUtils.isEmpty(this.beanFactory.getBeanNamesForType(beanClass, true, false))) {
                RootBeanDefinition beanDefinition = new RootBeanDefinition(beanClass);
                beanDefinition.setSynthetic(true);
                registry.registerBeanDefinition(name, beanDefinition);
            }

        }
    }

this.registerSyntheticBeanIfMissing(registry, "webServerFactoryCustomizerBeanPostProcessor", WebServerFactoryCustomizerBeanPostProcessor.class);

   這一行是關鍵，打開

public class WebServerFactoryCustomizerBeanPostProcessor implements BeanPostProcessor, BeanFactoryAware {
    private ListableBeanFactory beanFactory;
    private List<WebServerFactoryCustomizer<?>> customizers;

    public WebServerFactoryCustomizerBeanPostProcessor() {
    }

    public void setBeanFactory(BeanFactory beanFactory) {
        Assert.isInstanceOf(ListableBeanFactory.class, beanFactory, "WebServerCustomizerBeanPostProcessor can only be used with a ListableBeanFactory");
        this.beanFactory = (ListableBeanFactory)beanFactory;
    }

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof WebServerFactory) {
            this.postProcessBeforeInitialization((WebServerFactory)bean);
        }

        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
   //在Servlet初始化之前執行
    private void postProcessBeforeInitialization(WebServerFactory webServerFactory) {
        ((Callbacks)LambdaSafe.callbacks(WebServerFactoryCustomizer.class, 
//取出所有Customizers
this.getCustomizers(), 
webServerFactory, new Object[0]).withLogger(WebServerFactoryCustomizerBeanPostProcessor.class)).invoke((customizer) -> {
 //對Spring容器中的WebServerFactory執行customize方法。
            customizer.customize(webServerFactory);
        });
    }

    private Collection<WebServerFactoryCustomizer<?>> getCustomizers() {
        if (this.customizers == null) {
            this.customizers = new ArrayList(this.getWebServerFactoryCustomizerBeans());
            this.customizers.sort(AnnotationAwareOrderComparator.INSTANCE);
            this.customizers = Collections.unmodifiableList(this.customizers);
        }

        return this.customizers;
    }

    private Collection<WebServerFactoryCustomizer<?>> getWebServerFactoryCustomizerBeans() {
        return this.beanFactory.getBeansOfType(WebServerFactoryCustomizer.class, false, false).values(); //取出Spring容器中Customizer的類型是繼承自WebServerFactoryCustomizer
    }
}

  通過

  customizer.customize(webServerFactory);

我們在application里面配置的內容就應用到了其中。

另一種是就是自定義的WebServerFactory，可以

 

@Configuration
public class WebConfigurer {


    @Bean
    public ConfigurableServletWebServerFactory configurableServletWebServerFactory(){
        TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
        factory.setPort(8585);
        return factory;
    }
}

 

 將我們自定義的ConfigurableServletWebServerFactory注入到了Spring容器中

 

@ConditionalOnMissingBean(
        value = {ServletWebServerFactory.class},

 

這樣自定義的Factory就不會生效了，而自定義的Factory注入到Spring容器中以后會被

  customizer.customize(webServerFactory);

 應用，這么看執行過程，如果同時配置了Factory Bean與yml，應該Factory Bean里面配置的會被yml里面的同等配置替代，所以yml配置優先。

有一個疑問，我只找到了

   @Bean
    public ServletWebServerFactoryCustomizer servletWebServerFactoryCustomizer(ServerProperties serverProperties) {
        return new ServletWebServerFactoryCustomizer(serverProperties);
    }

    @Bean
    @ConditionalOnClass(
        name = {"org.apache.catalina.startup.Tomcat"}
    )
    public TomcatServletWebServerFactoryCustomizer tomcatServletWebServerFactoryCustomizer(ServerProperties serverProperties) {
        return new TomcatServletWebServerFactoryCustomizer(serverProperties);
    }

並沒有找到像

 

 Jetty和Undertow的Customizer的注冊Bean