1
import org.springframework.boot.SpringApplication;//启动类
2
import org.springframework.boot.autoconfigure.SpringBootApplication;
3

4
@SpringBootApplication //启动必要注解
5
public class YourApplication {
6
  //运行main方法启动springboot
7
  public static void main(String[] args) {
8
    SpringApplication.run(YourApplication.class, args);//启动类静态run方法
9
  }
10

11
}

1
// 静态方法 org.springframework.boot.SpringApplication.run(Class<?>[], String[])
2
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
3
    return new SpringApplication(primarySources).run(args);
4
}
5

6
// 构造方法
7
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
8
    //..........
9
    //// 1.(loadFactories)读取classpath下所有的spring.factories配置文件 ////
10
    // 配置应用程序启动前的初始化对象
11
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
12
    // 配置应用程序启动前的监听器
13
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
14
    this.mainApplicationClass = deduceMainApplicationClass();
15
}
16

17
// 对象run方法 开始启动程序
18
public ConfigurableApplicationContext run(String... args) {
19
    //......
20
    // 通知监听者启动开始
21
    listeners.starting();
22
    try {
23
        // 创建应用程序环境 配置文件在此处读取(application.properties application.yml)
24
        ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
25
        //// 2.创建应用程序上下文...此处创建了beanfactory ////
26
        context = createApplicationContext();
27
        //// 3.刷新上下文（spring启动核心） ////
28
        refreshContext(context);
29

30
        //// 4.启动完成通知...... ////
31
        listeners.started(context);
32
    }
33
    catch (Throwable ex) {
34
        handleRunFailure(context, ex, exceptionReporters, listeners);
35
        throw new IllegalStateException(ex);
36
    }
37
    try {
38
        listeners.running(context);
39
    }
40
    catch (Throwable ex) {
41
        handleRunFailure(context, ex, exceptionReporters, null);
42
        throw new IllegalStateException(ex);
43
    }
44
    return context;
45
}

1
//构造方法中的初始化对象创建
2
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
3
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
4

5
//看一下getSpringFactoriesInstances方法
6
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
7
    return getSpringFactoriesInstances(type, new Class<?>[] {});
8
}
9

10
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
11
    ClassLoader classLoader = getClassLoader();
12
    // 获取初始化类的类名
13
    Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
14
    // 通过这些类名实例化对象
15
    List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
16
    AnnotationAwareOrderComparator.sort(instances);
17
    return instances;
18
}
19

20
// 读取配置方法
21
// 更详深层的代码在org.springframework.core.io.support.SpringFactoriesLoader.loadSpringFactories(ClassLoader)
22
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
23
    String factoryTypeName = factoryType.getName();
24
    return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
25
}
26
// loadSpringFactories(classLoader)读取运行环境中所有META-INF/spring.factories配置

1
# Application Context Initializers
2
org.springframework.context.ApplicationContextInitializer=\
3
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
4
org.springframework.boot.context.ContextIdApplicationContextInitializer,\
5
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
6
org.springframework.boot.rsocket.context.RSocketPortInfoApplicationContextInitializer,\
7
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer

1
[org.springframework.context.ApplicationContextInitializer,
2
 org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,
3
 org.springframework.boot.context.ContextIdApplicationContextInitializer,
4
 org.springframework.boot.context.config.DelegatingApplicationContextInitializer,
5
 org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer]

1
listeners.starting();  // 这里也是一些调用操作

1
ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments); //此处application.properties配置文件会被读取

1
// 创建应用程序上下文
2
context = createApplicationContext();
3

4
protected ConfigurableApplicationContext createApplicationContext() {
5
    // 上下文创建的判断逻辑
6
    Class<?> contextClass = this.applicationContextClass;
7
    if (contextClass == null) {
8
        try {
9
            switch (this.webApplicationType) {
10
                case SERVLET:
11
                    contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
12
                    break;
13
                case REACTIVE:
14
                    contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
15
                    break;
16
                default:
17
                    contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
18
            }
19
        }
20
        catch (ClassNotFoundException ex) {
21
            throw new IllegalStateException(
22
                "Unable create a default ApplicationContext, please specify an ApplicationContextClass", ex);
23
        }
24
    }
25
    return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
26
}
27

28
public static final String DEFAULT_SERVLET_WEB_CONTEXT_CLASS = "org.springframework.boot."
29
      + "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";
30
// 默认是创建这个类

1
public class AnnotationConfigServletWebServerApplicationContext extends ServletWebServerApplicationContext
2
    implements AnnotationConfigRegistry {
3
    // 构造方法
4
  public AnnotationConfigServletWebServerApplicationContext() {
5
    this.reader = new AnnotatedBeanDefinitionReader(this);
6
    this.scanner = new ClassPathBeanDefinitionScanner(this);
7
  }
8
}

1
// 超级父类 GenericApplicationContext的构造方法
2
public GenericApplicationContext() {
3
    this.beanFactory = new DefaultListableBeanFactory();//创建工厂对象
4
}

1
refreshContext(context); //刷新上下文

1
@Override
2
public void refresh() throws BeansException, IllegalStateException {
3
    synchronized (this.startupShutdownMonitor) {
4
        //......
5
        // 3.1配置工厂对象
6
        prepareBeanFactory(beanFactory);
7
        try {
8
            postProcessBeanFactory(beanFactory);
9

10
            // 3.2注册并实例化bean工厂处理器,并调用他们
11
            invokeBeanFactoryPostProcessors(beanFactory);
12

13
            // 3.3注册并实例化bean处理器
14
            registerBeanPostProcessors(beanFactory);
15

16
            // 3.4 初始化一些与上下文有特别关系的bean对象（创建tomcat）
17
            onRefresh();
18

19
            // 3.5 实例化所有bean工厂缓存的bean对象（剩下的）.
20
            finishBeanFactoryInitialization(beanFactory);
21

22
            // 3.6 发布通知-通知上下文刷新完成（包括启动tomcat）
23
            finishRefresh();
24
        }
25
        catch (BeansException ex) {// ......Propagate exception to caller.
26
            throw ex;
27
        }
28
        finally {// ......
29
            resetCommonCaches();
30
        }
31
    }
32
}

1
listeners.started(context);
2
listeners.running(context);
3

4
void started(ConfigurableApplicationContext context) {
5
    for (SpringApplicationRunListener listener : this.listeners) {
6
        listener.started(context);
7
    }
8
}
9

10
void running(ConfigurableApplicationContext context) {
11
    for (SpringApplicationRunListener listener : this.listeners) {
12
        listener.running(context);
13
    }
14
}
15

16
@Override
17
public void started(ConfigurableApplicationContext context) {
18
    context.publishEvent(new ApplicationStartedEvent(this.application, this.args, context));
19
}
20

21
@Override
22
public void running(ConfigurableApplicationContext context) {
23
    context.publishEvent(new ApplicationReadyEvent(this.application, this.args, context));
24
}