Spring Boot初始化

Spring boot 启动类

@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

上面的例子是一个常见的SpirngBoot 入口类，接触过Spring boot的大佬应该都很熟悉了，屏蔽了WEB创建项的复杂性质屏蔽了Spring boot创建过程的复杂性质。

SpringApplication 实例化

调用方法
SpringApplication.run(App.class, args);

对应实现的源代码

     //  调用的是源代码的 run 方法
    public static ConfigurableApplicationContext run(Object source, String... args) {
        return run(new Object[] { source }, args);
    }

    // 实际调用的是 run 的重载方法
    public static ConfigurableApplicationContext run(Object[] sources, String[] args) {
        return new SpringApplication(sources).run(args);
    }

调用 SpringApplication 的 run方法 实例化一个 SpringApplication 的对象并调用 其run() 方法。

SpringApplication 构造方法源代码

    public SpringApplication(Object... sources) {
        initialize(sources);
    }
    private void initialize(Object[] sources) {
        if (sources != null && sources.length > 0) {
            this.sources.addAll(Arrays.asList(sources));
        }
        this.webEnvironment = deduceWebEnvironment();
        setInitializers((Collection) getSpringFactoriesInstances(
                ApplicationContextInitializer.class));
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = deduceMainApplicationClass();
    }

实例化的过程主要完成以下内容

deduceWebApplicationType 判断是否为web应用

    private boolean deduceWebEnvironment() {
        for (String className : WEB_ENVIRONMENT_CLASSES) {
            if (!ClassUtils.isPresent(className, null)) {
                return false;
            }
        }
        return true;
    }

这里WEB_ENVIRONMENT_CLASSES  是一个常量数组
/** private static final String[] WEB_ENVIRONMENT_CLASSES = { "javax.servlet.Servlet",
            "org.springframework.web.context.ConfigurableWebApplicationContext" };*/

通过 调用 ClassUtils的静态方法 isPresent 来判断环境变量里面是否有常量数组中的类。
   public static boolean isPresent(String className, ClassLoader classLoader) {
        try {
            forName(className, classLoader);
            return true;
        } catch (Throwable var3) {
            return false;
        }
    }

setInitializers 设置初始化

查看代码

    setInitializers((Collection) getSpringFactoriesInstances(
                ApplicationContextInitializer.class));

这里涉及到两个方法

1. setInitializers

//   initializers 实例化，  调用Arraylist.addAll进行列表拷贝
    public void setInitializers(
            Collection> initializers) {
        this.initializers = new ArrayList>();
        this.initializers.addAll(initializers);
    }

2 . getSpringFactoriesInstances

//   方法有重载
    private  Collection getSpringFactoriesInstances(Class type) {
        return getSpringFactoriesInstances(type, new Class[] {});
    }

// 调用的实际方法
    private  Collection getSpringFactoriesInstances(Class type,
            Class[] parameterTypes, Object... args) {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        // type ==ApplicationContextInitializer.class
             // 使用Set进行数据去重  得到所有的 ApplicationContextInitializer 实现类
        Set names = new LinkedHashSet(
                SpringFactoriesLoader.loadFactoryNames(type, classLoader));
             //   类实例化 
        List instances = createSpringFactoriesInstances(type, parameterTypes,
                classLoader, args, names);
            //  源码调用的 集合的排序方法 
        AnnotationAwareOrderComparator.sort(instances);
        return instances;
    }  

再去看下 SpringFactoriesLoader.loadFactoryNames

    public static List loadFactoryNames(Class factoryClass, ClassLoader classLoader) {
        String factoryClassName = factoryClass.getName();

        try {
      // 遍历所有的 META-INF/spring.factories 文件(据此可以去实现模块定义开发)
            Enumeration urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
            ArrayList result = new ArrayList();
   // 遍历枚举
            while(urls.hasMoreElements()) {
                URL url = (URL)urls.nextElement();
                Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
                String factoryClassNames = properties.getProperty(factoryClassName);    
       

   //    将字符串进行逗号分割后  拷贝值 result数组中
                result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
            }

            return result;
        } catch (IOException var8) {
            throw new IllegalArgumentException("Unable to load [" + factoryClass.getName() + "] factories from location [" + "META-INF/spring.factories" + "]", var8);
        }
    }

附属 一个 spring.factories 文件

# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.AutoConfigurationReportLoggingInitializer

createSpringFactoriesInstances

    private  List createSpringFactoriesInstances(Class type,
            Class[] parameterTypes, ClassLoader classLoader, Object[] args,
            Set names) {
        List instances = new ArrayList(names.size());
        for (String name : names) {
            try {
                  //  通过反射进行类的实例化
                Class instanceClass = ClassUtils.forName(name, classLoader);
                Assert.isAssignable(type, instanceClass);
                Constructor constructor = instanceClass
                        .getDeclaredConstructor(parameterTypes);
                T instance = (T) BeanUtils.instantiateClass(constructor, args);
                instances.add(instance);
            }
            catch (Throwable ex) {
                throw new IllegalArgumentException(
                        "Cannot instantiate " + type + " : " + name, ex);
            }
        }
        return instances;
    }

设置 初始化 的过程到此技术， 遍历所有类路径下的 ApplicationContextInitializer 类进行实例化 最终保存到 this.initializers中
ApplicationContextInitializer 源码

//  一个泛型接口，  界限 为 ConfigurableApplicationContext   只有一个方法 initialize
public interface ApplicationContextInitializer {
    void initialize(C var1);
}

setListeners 设置监听器

setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

// getSpringFactoriesInstances 方法   遍历所有的 ApplicationListener


    public void setListeners(Collection> listeners) {
        this.listeners = new ArrayList>();
        this.listeners.addAll(listeners);
    }

初使化classpath下的所有的可用的ApplicationListener ，与设置初始化很类似。

this.mainApplicationClass 程序入口推断

       this.mainApplicationClass = deduceMainApplicationClass();

    private Class deduceMainApplicationClass() {
        try {
            StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
              //  构造一个运行时异常，得到堆栈轨迹元素的数组，代表了这个线程的堆栈情况
            // 然后进行遍历得到main方法，返回对应的类
            for (StackTraceElement stackTraceElement : stackTrace) {
                if ("main".equals(stackTraceElement.getMethodName())) {
                    return Class.forName(stackTraceElement.getClassName());
                }
            }
        }
        catch (ClassNotFoundException ex) {
            // Swallow and continue
        }
        return null;
    }

===
SpringApplication 实例化到此结束

run

    public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        FailureAnalyzers analyzers = null;
        configureHeadlessProperty();
     //    得到所有的  RunListeners  然后调用listeners 的started方法
        SpringApplicationRunListeners listeners = getRunListeners(args);
        listeners.starting();
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                    args);
// 根据listeners 以及  args  准备 环境变量
            ConfigurableEnvironment environment = prepareEnvironment(listeners,
                    applicationArguments);
            Banner printedBanner = printBanner(environment);
// 创建上下文
            context = createApplicationContext();
            analyzers = new FailureAnalyzers(context);
            prepareContext(context, environment, listeners, applicationArguments,
                    printedBanner);
            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);
        }
    }

getRunListeners

    private SpringApplicationRunListeners getRunListeners(String[] args) {
        Class[] types = new Class[] { SpringApplication.class, String[].class };
        return new SpringApplicationRunListeners(logger, getSpringFactoriesInstances(
                SpringApplicationRunListener.class, types, this, args));
    }

/**

SpringApplicationRunListeners 的构造函数，里面维护一个SpringApplicationRunListener 集合。
  调用  SpringApplicationRunListeners的方法时，会对集和里面的所有元素进行同方法的调用
      
    SpringApplicationRunListeners(Log log,
            Collection listeners) {
        this.log = log;
        this.listeners = new ArrayList(listeners);
    }
*/

附

public interface SpringApplicationRunListener {
    void started();
    void environmentPrepared(ConfigurableEnvironment environment);
    void contextPrepared(ConfigurableApplicationContext context);
    void contextLoaded(ConfigurableApplicationContext context);
    void finished(ConfigurableApplicationContext context, Throwable exception);

}

prepareEnvironment

     // 根据listeners以及 applicationArguments 准备环境
    private ConfigurableEnvironment prepareEnvironment(
            SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments) {
        // Create and configure the environment
        ConfigurableEnvironment environment = getOrCreateEnvironment();
//  配置环境
        configureEnvironment(environment, applicationArguments.getSourceArgs());
        // listeners发出广播事件
                listeners.environmentPrepared(environment);
        if (isWebEnvironment(environment) && !this.webEnvironment) {
            environment = convertToStandardEnvironment(environment);
        }
        return environment;
    }

//  判断是环境 返回对应的  Environment
    private ConfigurableEnvironment getOrCreateEnvironment() {
        if (this.environment != null) {
            return this.environment;
        }
        if (this.webEnvironment) {
            return new StandardServletEnvironment();
        }
        return new StandardEnvironment();
    }

     配置环境的代码，后续展开Environment 系列源码刨析
    protected void configureEnvironment(ConfigurableEnvironment environment,
            String[] args) {
        configurePropertySources(environment, args);
        configureProfiles(environment, args);
    }

准备环境的过程中 RunListeners 依据观察者模式，会发出广播，listeners.environmentPrepared(environment);

创建上下文

context = createApplicationContext();
prepareContext(context, environment, listeners, applicationArguments,
                    printedBanner);

    protected ConfigurableApplicationContext createApplicationContext() {
        Class contextClass = this.applicationContextClass;
        if (contextClass == null) {
            try {
 //  根据应用类型创建不同的  上下文

// 对于web应用创建的为 DEFAULT_WEB_CONTEXT_CLASS 
                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);
    }
     */
    public static final String DEFAULT_CONTEXT_CLASS = "org.springframework.context."
            + "annotation.AnnotationConfigApplicationContext";


    public static final String DEFAULT_WEB_CONTEXT_CLASS = "org.springframework."
            + "boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext";
    /*

DEFAULT_WEB_CONTEXT_CLASS 类图

prepareContext 上下文前置处理

    private void prepareContext(ConfigurableApplicationContext context,
            ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments, Banner printedBanner) {
//  设置环境变量
        context.setEnvironment(environment);

// 配置bean name 生成器,Classload,以及Resourceload
        postProcessApplicationContext(context);
        applyInitializers(context);
        listeners.contextPrepared(context);
        if (this.logStartupInfo) {
            logStartupInfo(context.getParent() == null);
            logStartupProfileInfo(context);
        }

        // Add boot specific singleton beans
        context.getBeanFactory().registerSingleton("springApplicationArguments",
                applicationArguments);
        if (printedBanner != null) {
            context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
        }

        // Load the sources
        Set