springboot启动过程

使用了很长时间的springboot了，一直都知道它简单易用，简化了框架的搭建过程，但是还是不知道它是如何启动的，今天就跟着springboot的源码，去探探这其中的奥妙

    以下是spring应用的启动：

@SpringBootApplication

public class Application extends WebMvcConfigurerAdapter {

	public static void main(String[] args) {

		//加载配置文件

		System.setProperty("spring.config.location","classpath:db_config.properties,classpath:mq.properties");

		SpringApplication.run(Application.class, args);

	}

}

然后我们跟着Run方法进去

public ConfigurableApplicationContext run(String... args) {

    //一开始就是一个StopWatch 类，这个类的主要作用是记录容器启动用时

    StopWatch stopWatch = new StopWatch();

    stopWatch.start();

    ConfigurableApplicationContext context = null;

    FailureAnalyzers analyzers = null;

    this.configureHeadlessProperty();

    SpringApplicationRunListeners listeners = this.getRunListeners(args);

    listeners.starting();

    try {

        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

        ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);

        Banner printedBanner = this.printBanner(environment);

        context = this.createApplicationContext();

        new FailureAnalyzers(context);

        this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);

        this.refreshContext(context);

        this.afterRefresh(context, applicationArguments);

        listeners.finished(context, (Throwable)null);

        stopWatch.stop();

        if(this.logStartupInfo) {

            (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);

        }

        return context;

    } catch (Throwable var9) {

        this.handleRunFailure(context, listeners, (FailureAnalyzers)analyzers, var9);

        throw new IllegalStateException(var9);

    }

}

第一步：可以看到，一开始是一个StopWatch类，该类的作用比较单一，就是记录springboot的启动用时，我们启动springboot完成后会在控制台springboot启动所花的时间，就是由它来完成的

//然后我们看看this.createApplicationContext()方法：

private void configureHeadlessProperty() {

    System.setProperty("java.awt.headless", System.getProperty("java.awt.headless", Boolean.toString(this.headless)));

}

//主要是用来设置系统属性，具体这个属性有何作用，有待探究

第二步：创建SpringApplicationRunListeners

//接下来我们看看springboot是如何去初始化监听器SpringApplicationRunListeners的。this.getRunListeners(args)方法如下：

private SpringApplicationRunListeners getRunListeners(String[] args) {

    Class<?>[] types = new Class[]{SpringApplication.class, String[].class};

    return new SpringApplicationRunListeners(logger, this.getSpringFactoriesInstances(SpringApplicationRunListener.class, types, new Object[]{this, args}));

}

//利用传入的参数args去创建一个SpringApplicationRunListeners实例，此处会去获取一个SpringFactory的实例，下面我们重点看看是如何来获取该SpringFactory实例的

private <T> Collection<? extends T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {

    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

    Set<String> names = new LinkedHashSet(SpringFactoriesLoader.loadFactoryNames(type, classLoader));

    List<T> instances = this.createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);

    AnnotationAwareOrderComparator.sort(instances);

    return instances;

}

//首先获取当前线程的类加载器，然后通过SpringFactoriesLoader去加载SpringApplicationRunListener这个类，接下来看看在加载SpringApplicationRunListener这个spring应用的运行监听器时做了什么事情

public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {

    String factoryClassName = factoryClass.getName();

    try {

        Enumeration ex = classLoader != null?classLoader.getResources("META-INF/spring.factories"):ClassLoader.getSystemResources("META-INF/spring.factories");

        ArrayList result = new ArrayList();

        while(ex.hasMoreElements()) {

            URL url = (URL)ex.nextElement();

            Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));

            String factoryClassNames = properties.getProperty(factoryClassName);

            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);

    }

}

//首先通过当前线程的类加载器获取Springboot项目META-INF下面的spring.factories文件，找到该文件，我们可以看到该文件中配置了PropertySource Loaders(属性来源加载)、运行监听器EventPublishingRunListener、运用上下文初始化工具、应用监听器等等一系列的自动化配置，都是从这里加载到应用中来的。加载完成之后，SpringFactory通过反射来获取这些类的实例，然后放入到SpringApplicationRunListeners中，至此，SpringApplicationRunListeners初始化完成。这里，我们看看SpringApplicationRunListeners中有些什么，源码如下：

class SpringApplicationRunListeners {

	private final Log log;

	private final List<SpringApplicationRunListener> listeners;

	SpringApplicationRunListeners(Log log, Collection<? extends SpringApplicationRunListener> listeners) {

		this.log = log;

		this.listeners = new ArrayList(listeners);

	}

}

//有一个log，用于记录日志，然后就是一个final的list，里面就是之前初始化时从配置中获取的各种listener

再次回顾一下SpringApplicationRunListeners的创建过程：首先获取当前线程的ClassLoader，然后通过SpringFactoriesLoader去加载Springboot项目中META-INF文件夹下的spring.factories配置文件，之后通过反射获取相关listener实例，存储到SpringApplicationRunListeners的list属性中，由此完成SpringApplicationRunListeners的初始化过程

巴特西

springboot启动过程

使用了很长时间的springboot了，一直都知道它简单易用，简化了框架的搭建过程，但是还是不知道它是如何启动的，今天就跟着springboot的源码，去探探这其中的奥妙

然后我们跟着Run方法进去

第一步：可以看到，一开始是一个StopWatch类，该类的作用比较单一，就是记录springboot的启动用时，我们启动springboot完成后会在控制台springboot启动所花的时间，就是由它来完成的

第二步：创建SpringApplicationRunListeners

第三步：启动SpringApplicationRunListeners中所有的监听器

第四步：环境准备

第五步：打印Banner

第六步：创建上下文

最新文章

热门文章