spring boot中servlet启动原理详解编程语言

StopWatch stopWatch = new StopWatch(); 
        stopWatch.start(); 
        ConfigurableApplicationContext context = null; 
        FailureAnalyzers analyzers = null; 
        configureHeadlessProperty(); 
        SpringApplicationRunListeners listeners = getRunListeners(args); 
        listeners.starting(); 
        try { 
            ApplicationArguments applicationArguments = new DefaultApplicationArguments( 
                    args); 
            ConfigurableEnvironment environment = prepareEnvironment(listeners, 
                    applicationArguments); 
            Banner printedBanner = printBanner(environment); 
                       //创建一个ApplicationContext容器 
            context = createApplicationContext(); 
            analyzers = new FailureAnalyzers(context); 
            prepareContext(context, environment, listeners, applicationArguments, 
                    printedBanner); 
                      //刷新IOC容器 
            refreshContext(context); 
            afterRefresh(context, applicationArguments); 
            listeners.finished(context, null); 
            stopWatch.stop(); 
            if (this.logStartupInfo) { 
                new StartupInfoLogger(this.mainApplicationClass) 
                        .logStarted(getApplicationLog(), stopWatch); 
            } 
            return context; 
        } 
        catch (Throwable ex) { 
            handleRunFailure(context, listeners, analyzers, ex); 
            throw new IllegalStateException(ex); 
        }     

    public static final String DEFAULT_CONTEXT_CLASS = "org.springframework.context." 
            + "annotation.AnnotationConfigApplicationContext"; 
 
    /** 
     * The class name of application context that will be used by default for web 
     * environments. 
     */ 
    public static final String DEFAULT_WEB_CONTEXT_CLASS = "org.springframework." 
            + "boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext"; 
 
 
protected ConfigurableApplicationContext createApplicationContext() { 
        Class<?> contextClass = this.applicationContextClass; 
        if (contextClass == null) { 
            try {
　　　　　　　　　　//根据应用环境,创建不同的IOC容器 
                contextClass = Class.forName(this.webEnvironment 
                        ? DEFAULT_WEB_CONTEXT_CLASS : DEFAULT_CONTEXT_CLASS); 
            } 
            catch (ClassNotFoundException ex) { 
                throw new IllegalStateException( 
                        "Unable create a default ApplicationContext, " 
                                + "please specify an ApplicationContextClass", 
                        ex); 
            } 
        } 
        return (ConfigurableApplicationContext) BeanUtils.instantiate(contextClass); 
    }

private void refreshContext(ConfigurableApplicationContext context) { 
        refresh(context); 
        if (this.registerShutdownHook) { 
            try { 
                context.registerShutdownHook(); 
            } 
            catch (AccessControlException ex) { 
                // Not allowed in some environments. 
            } 
        } 
    }

protected void refresh(ApplicationContext applicationContext) { 
        Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext); 
        ((AbstractApplicationContext) applicationContext).refresh(); 
    }

public void refresh() throws BeansException, IllegalStateException { 
        Object var1 = this.startupShutdownMonitor; 
        synchronized(this.startupShutdownMonitor) { 
            this.prepareRefresh(); 
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory(); 
            this.prepareBeanFactory(beanFactory); 
 
            try { 
                this.postProcessBeanFactory(beanFactory); 
                this.invokeBeanFactoryPostProcessors(beanFactory); 
                this.registerBeanPostProcessors(beanFactory); 
                this.initMessageSource(); 
                this.initApplicationEventMulticaster(); 
                this.onRefresh(); 
                this.registerListeners(); 
                this.finishBeanFactoryInitialization(beanFactory); 
                this.finishRefresh(); 
            } catch (BeansException var9) { 
                if (this.logger.isWarnEnabled()) { 
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9); 
                } 
 
                this.destroyBeans(); 
                this.cancelRefresh(var9); 
                throw var9; 
            } finally { 
                this.resetCommonCaches(); 
            } 
 
        } 
    }

@Override 
    protected void onRefresh() { 
        super.onRefresh(); 
        try { 
            createEmbeddedServletContainer(); 
        } 
        catch (Throwable ex) { 
            throw new ApplicationContextException("Unable to start embedded container", 
                    ex); 
        } 
    }

private void createEmbeddedServletContainer() { 
        EmbeddedServletContainer localContainer = this.embeddedServletContainer; 
        ServletContext localServletContext = getServletContext(); 
        if (localContainer == null && localServletContext == null) {
　　　　　　　　　　　　　　　　//获取嵌入式Servlet容器工厂 
            EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();
　　　　　　　　　　//根据容器工厂获取对应嵌入式Servlet容器 
            this.embeddedServletContainer = containerFactory 
                    .getEmbeddedServletContainer(getSelfInitializer()); 
        } 
        else if (localServletContext != null) { 
            try { 
                getSelfInitializer().onStartup(localServletContext); 
            } 
            catch (ServletException ex) { 
                throw new ApplicationContextException("Cannot initialize servlet context", 
                        ex); 
            } 
        } 
        initPropertySources(); 
    }

//EmbeddedWebApplicationContext#getEmbeddedServletContainerFactory   
protected EmbeddedServletContainerFactory getEmbeddedServletContainerFactory() {   
    // Use bean names so that we don't consider the hierarchy   
    String[] beanNames = getBeanFactory()   
        .getBeanNamesForType(EmbeddedServletContainerFactory.class);   
    if (beanNames.length == 0) {   
        throw new ApplicationContextException(   
            "Unable to start EmbeddedWebApplicationContext due to missing "   
            + "EmbeddedServletContainerFactory bean.");   
    }   
    if (beanNames.length > 1) {   
        throw new ApplicationContextException(   
            "Unable to start EmbeddedWebApplicationContext due to multiple "   
            + "EmbeddedServletContainerFactory beans : "   
            + StringUtils.arrayToCommaDelimitedString(beanNames));   
    }   
    return getBeanFactory().getBean(beanNames[0],   
                                    EmbeddedServletContainerFactory.class);   
}  

this.embeddedServletContainer = containerFactory   
            .getEmbeddedServletContainer(getSelfInitializer());  

// Instantiate all remaining (non-lazy-init) singletons. 
                finishBeanFactoryInitialization(beanFactory);

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { 
        // Initialize conversion service for this context. 
        if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && 
                beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) { 
            beanFactory.setConversionService( 
                    beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)); 
        } 
 
        // Register a default embedded value resolver if no bean post-processor 
        // (such as a PropertyPlaceholderConfigurer bean) registered any before: 
        // at this point, primarily for resolution in annotation attribute values. 
        if (!beanFactory.hasEmbeddedValueResolver()) { 
            beanFactory.addEmbeddedValueResolver(new StringValueResolver() { 
                @Override 
                public String resolveStringValue(String strVal) { 
                    return getEnvironment().resolvePlaceholders(strVal); 
                } 
            }); 
        } 
 
        // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early. 
        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false); 
        for (String weaverAwareName : weaverAwareNames) { 
            getBean(weaverAwareName); 
        } 
 
        // Stop using the temporary ClassLoader for type matching. 
        beanFactory.setTempClassLoader(null); 
 
        // Allow for caching all bean definition metadata, not expecting further changes. 
        beanFactory.freezeConfiguration(); 
 
        // Instantiate all remaining (non-lazy-init) singletons. 
        beanFactory.preInstantiateSingletons(); 
    }

public void preInstantiateSingletons() throws BeansException { 
        if (this.logger.isDebugEnabled()) { 
            this.logger.debug("Pre-instantiating singletons in " + this); 
        } 
 
        List<String> beanNames = new ArrayList(this.beanDefinitionNames); 
        Iterator var2 = beanNames.iterator(); 
 
        while(true) { 
            while(true) { 
                String beanName; 
                RootBeanDefinition bd; 
                do { 
                    do { 
                        do { 
                            if (!var2.hasNext()) { 
                                var2 = beanNames.iterator(); 
 
                                while(var2.hasNext()) { 
                                    beanName = (String)var2.next(); 
                                    Object singletonInstance = this.getSingleton(beanName); 
                                    if (singletonInstance instanceof SmartInitializingSingleton) { 
                                        final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance; 
                                        if (System.getSecurityManager() != null) { 
                                            AccessController.doPrivileged(new PrivilegedAction<Object>() { 
                                                public Object run() { 
                                                    smartSingleton.afterSingletonsInstantiated(); 
                                                    return null; 
                                                } 
                                            }, this.getAccessControlContext()); 
                                        } else { 
                                            smartSingleton.afterSingletonsInstantiated(); 
                                        } 
                                    } 
                                } 
 
                                return; 
                            } 
 
                            beanName = (String)var2.next(); 
                            bd = this.getMergedLocalBeanDefinition(beanName); 
                        } while(bd.isAbstract()); 
                    } while(!bd.isSingleton()); 
                } while(bd.isLazyInit()); 
 
                if (this.isFactoryBean(beanName)) { 
                    final FactoryBean<?> factory = (FactoryBean)this.getBean("&" + beanName); 
                    boolean isEagerInit; 
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { 
                        isEagerInit = ((Boolean)AccessController.doPrivileged(new PrivilegedAction<Boolean>() { 
                            public Boolean run() { 
                                return ((SmartFactoryBean)factory).isEagerInit(); 
                            } 
                        }, this.getAccessControlContext())).booleanValue(); 
                    } else { 
                        isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit(); 
                    } 
 
                    if (isEagerInit) { 
                        this.getBean(beanName); 
                    } 
                } else {
　　　　　　　　　　　　//注册bean 
                    this.getBean(beanName); 
                } 
            } 
        } 
    }

public class ServletInitializer extends SpringBootServletInitializer {   
   
    @Override   
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {   
        return application.sources(SpringBoot04WebJspApplication.class);   
    }   
} 

@HandlesTypes(WebApplicationInitializer.class) 
public class SpringServletContainerInitializer implements ServletContainerInitializer { 
/** 
* Delegate the [email protected] ServletContext} to any [email protected] WebApplicationInitializer} 
* implementations present on the application classpath. 
* <p>Because this class declares @[email protected] HandlesTypes(WebApplicationInitializer.class)}, 
* Servlet 3.0+ containers will automatically scan the classpath for implementations 
* of Spring's [email protected] WebApplicationInitializer} interface and provide the set of all 
* such types to the [email protected] webAppInitializerClasses} parameter of this method. 
* <p>If no [email protected] WebApplicationInitializer} implementations are found on the classpath, 
* this method is effectively a no-op. An INFO-level log message will be issued notifying 
* the user that the [email protected] ServletContainerInitializer} has indeed been invoked but that 
* no [email protected] WebApplicationInitializer} implementations were found. 
* <p>Assuming that one or more [email protected] WebApplicationInitializer} types are detected, 
* they will be instantiated (and <em>sorted</em> if the @[email protected] 
* org.springframework.core.annotation.Order @Order} annotation is present or 
* the [email protected] org.springframework.core.Ordered Ordered} interface has been 
* implemented). Then the [email protected] WebApplicationInitializer#onStartup(ServletContext)} 
* method will be invoked on each instance, delegating the [email protected] ServletContext} such 
* that each instance may register and configure servlets such as Spring's 
* [email protected] DispatcherServlet}, listeners such as Spring's [email protected] ContextLoaderListener}, 
* or any other Servlet API componentry such as filters. 
* @param webAppInitializerClasses all implementations of 
* [email protected] WebApplicationInitializer} found on the application classpath 
* @param servletContext the servlet context to be initialized 
* @see WebApplicationInitializer#onStartup(ServletContext) 
* @see AnnotationAwareOrderComparator 
*/ 
@Override 
public void onStartup(Set<Class<?>> webAppInitializerClasses, ServletContext servletContext) 
throws ServletException { 
List<WebApplicationInitializer> initializers = new LinkedList<WebApplicationInitializer>(); 
if (webAppInitializerClasses != null) { 
for (Class<?> waiClass : webAppInitializerClasses) { 
// Be defensive: Some servlet containers provide us with invalid classes, 
// no matter what @HandlesTypes says... 
if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) && 
WebApplicationInitializer.class.isAssignableFrom(waiClass)) { 
try {
　　　　　　　　　　　　　　　　//为所有的WebApplicationInitializer类型创建实例,并加入集合中 
initializers.add((WebApplicationInitializer) waiClass.newInstance()); 
} 
catch (Throwable ex) { 
throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex); 
} 
} 
} 
} 
if (initializers.isEmpty()) { 
servletContext.log("No Spring WebApplicationInitializer types detected on classpath"); 
return; 
} 
servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath"); 
AnnotationAwareOrderComparator.sort(initializers);
　　　　　　//调用每一个WebApplicationInitializer实例的onstartup方法 
for (WebApplicationInitializer initializer : initializers) { 
initializer.onStartup(servletContext); 
} 
} 
}

public abstract class SpringBootServletInitializer implements WebApplicationInitializer {   
//other code...   
       
@Override   
public void onStartup(ServletContext servletContext) throws ServletException {   
// Logger initialization is deferred in case a ordered   
// LogServletContextInitializer is being used   
this.logger = LogFactory.getLog(getClass());   
//创建IOC容器   
WebApplicationContext rootAppContext = createRootApplicationContext(   
servletContext);   
if (rootAppContext != null) {   
servletContext.addListener(new ContextLoaderListener(rootAppContext) {   
@Override   
public void contextInitialized(ServletContextEvent event) {   
// no-op because the application context is already initialized   
                }   
});   
}   
else {   
this.logger.debug("No ContextLoaderListener registered, as "   
+ "createRootApplicationContext() did not "   
+ "return an application context");   
}   
}   
protected WebApplicationContext createRootApplicationContext(   
ServletContext servletContext) {   
//创建Spring应用构建器，并进行相关属性设置   
SpringApplicationBuilder builder = createSpringApplicationBuilder();   
StandardServletEnvironment environment = new StandardServletEnvironment();   
environment.initPropertySources(servletContext, null);   
builder.environment(environment);   
builder.main(getClass());   
ApplicationContext parent = getExistingRootWebApplicationContext(servletContext);   
if (parent != null) {   
this.logger.info("Root context already created (using as parent).");   
servletContext.setAttribute(   
WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, null);   
builder.initializers(new ParentContextApplicationContextInitializer(parent));   
}   
builder.initializers(   
new ServletContextApplicationContextInitializer(servletContext));   
builder.contextClass(AnnotationConfigEmbeddedWebApplicationContext.class);   
//调用configure方法，创建war类型的web项目后，由于编写SpringBootServletInitializer的子类重写configure方法，所以此处调用的是我们定义的子类重写的configure方法   
builder = configure(builder);   
//通过构建器构建了一个Spring应用   
SpringApplication application = builder.build();   
if (application.getSources().isEmpty() && AnnotationUtils   
.findAnnotation(getClass(), Configuration.class) != null) {   
application.getSources().add(getClass());   
}   
Assert.state(!application.getSources().isEmpty(),   
"No SpringApplication sources have been defined. Either override the "   
+ "configure method or add an @Configuration annotation");   
// Ensure error pages are registered   
if (this.registerErrorPageFilter) {   
application.getSources().add(ErrorPageFilterConfiguration.class);   
}   
//启动Spring应用   
return run(application);   
}   
//Spring应用启动，创建并返回IOC容器   
protected WebApplicationContext run(SpringApplication application) {   
return (WebApplicationContext) application.run();   
}   
}