@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication(type = Type.SERVLET)
@EnableConfigurationProperties(ServerProperties.class)
@Import(BeanPostProcessorsRegistrar.class)
public class EmbeddedServletContainerAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public DefaultServletContainerCustomizer serverPropertiesServletContainerCustomizer(
            ServerProperties serverProperties) {
        return new DefaultServletContainerCustomizer(serverProperties);
    }

else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
                        // Candidate class is an ImportBeanDefinitionRegistrar ->
                        // delegate to it to register additional bean definitions
                        Class<?> candidateClass = candidate.loadClass();
                        ImportBeanDefinitionRegistrar registrar =
                                BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
                        ParserStrategyUtils.invokeAwareMethods(
                                registrar, this.environment, this.resourceLoader, this.registry);
                        configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
                    }

    loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());

    private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars) {
        for (Map.Entry<ImportBeanDefinitionRegistrar, AnnotationMetadata> entry : registrars.entrySet()) {
            entry.getKey().registerBeanDefinitions(entry.getValue(), this.registry);
        }
    }

    public static class BeanPostProcessorsRegistrar
            implements ImportBeanDefinitionRegistrar, BeanFactoryAware {

        private ConfigurableListableBeanFactory beanFactory;

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

        @Override
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
                BeanDefinitionRegistry registry) {
            if (this.beanFactory == null) {
                return;
            }
            registerSyntheticBeanIfMissing(registry,
                    "embeddedServletContainerCustomizerBeanPostProcessor",
                    EmbeddedServletContainerCustomizerBeanPostProcessor.class);
            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);
            }
        }

    }

public class EmbeddedServletContainerCustomizerBeanPostProcessor
        implements BeanPostProcessor, BeanFactoryAware {

    private ListableBeanFactory beanFactory;

    private List<EmbeddedServletContainerCustomizer> customizers;

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

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        if (bean instanceof ConfigurableEmbeddedServletContainer) {
            postProcessBeforeInitialization((ConfigurableEmbeddedServletContainer) bean);
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        return bean;
    }

    private void postProcessBeforeInitialization(
            ConfigurableEmbeddedServletContainer bean) {
        for (EmbeddedServletContainerCustomizer customizer : getCustomizers()) {
            customizer.customize(bean);
        }
    }

    private Collection<EmbeddedServletContainerCustomizer> getCustomizers() {
        if (this.customizers == null) {
            // Look up does not include the parent context
            this.customizers = new ArrayList<>(this.beanFactory.getBeansOfType(
                    EmbeddedServletContainerCustomizer.class, false, false).values());
            Collections.sort(this.customizers, AnnotationAwareOrderComparator.INSTANCE);
            this.customizers = Collections.unmodifiableList(this.customizers);
        }
        return this.customizers;
    }

}

    @Override
    public void customize(ConfigurableEmbeddedServletContainer container) {
        if (this.serverProperties.getPort() != null) {
            container.setPort(this.serverProperties.getPort());
        }
        if (this.serverProperties.getAddress() != null) {
            container.setAddress(this.serverProperties.getAddress());
        }
        if (this.serverProperties.getServlet().getContextPath() != null) {
            container.setContextPath(this.serverProperties.getServlet().getContextPath());
        }
        if (this.serverProperties.getDisplayName() != null) {
            container.setDisplayName(this.serverProperties.getDisplayName());
        }
        if (this.serverProperties.getSession().getTimeout() != null) {
            container.setSessionTimeout(this.serverProperties.getSession().getTimeout());
        }
        container.setPersistSession(this.serverProperties.getSession().isPersistent());
        container.setSessionStoreDir(this.serverProperties.getSession().getStoreDir());
        if (this.serverProperties.getSsl() != null) {
            container.setSsl(this.serverProperties.getSsl());
        }
        if (this.serverProperties.getServlet() != null) {
            container.setJsp(this.serverProperties.getServlet().getJsp());
        }
        if (this.serverProperties.getCompression() != null) {
            container.setCompression(this.serverProperties.getCompression());
        }
        container.setServerHeader(this.serverProperties.getServerHeader());
        if (container instanceof TomcatEmbeddedServletContainerFactory) {
            TomcatCustomizer.customizeTomcat(this.serverProperties, this.environment,
                    (TomcatEmbeddedServletContainerFactory) container);
        }
        if (container instanceof JettyEmbeddedServletContainerFactory) {
            JettyCustomizer.customizeJetty(this.serverProperties, this.environment,
                    (JettyEmbeddedServletContainerFactory) container);
        }

        if (container instanceof UndertowEmbeddedServletContainerFactory) {
            UndertowCustomizer.customizeUndertow(this.serverProperties, this.environment,
                    (UndertowEmbeddedServletContainerFactory) container);
        }
        container.addInitializers(
                new SessionConfiguringInitializer(this.serverProperties.getSession()));
        container.addInitializers(new InitParameterConfiguringServletContextInitializer(
                this.serverProperties.getServlet().getContextParameters()));
    }