Xml格式的应用启动

Xml和注解是我们进行使用Spring进行开发时用到的两种主要配置方式。本文简单介绍Xml格式的应用的启动流程。

从启动应用的代码开始入手：

public class Launcher {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring/spring.xml");
        CountDownLatch latch = new CountDownLatch(1);
        try {
            latch.await();
        } catch (InterruptedException ignored) {
        }
    }
}

这里，只是创建了一个ClassPathXmlApplicationContext的实例，并传入了一个字符串“classpath:spring/spring.xml”，来看它的构造器：

//上面使用的构造器
public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
        this(new String[] {configLocation}, true, null);
}
//最终使用的构造器
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
    super(parent);
    setConfigLocations(configLocations);
    if (refresh) {
        refresh();
    }
}

因为parent为null，所以这里先忽略super(parent)；主要做了两件事：setConfigLocations(configLocations)和refresh();

setConfigLocations(configLocations)是在其父类AbstractRefreshableConfigApplicationContext中：

public void setConfigLocations(@Nullable String... locations) {
    if (locations != null) {
        this.configLocations = new String[locations.length];
        for (int i = 0; i < locations.length; i++) {
        this.configLocations[i] = resolvePath(locations[i]).trim();
        }
    }else {
        this.configLocations = null;
    }
}
//resolvePath方法：如果给的路径中含有占位符${...}，则使用环境变量来替换掉
protected String resolvePath(String path) {
    return getEnvironment().resolveRequiredPlaceholders(path);
}

其实this.configLocations最终就是我们传入的那个字符串，即：

this.configLocations=["classpath:spring/spring.xml"]

到这里，setConfigLocations(configLocations)就结束了，该方法就是将我们传入的一个表示路径的字符串设置给ClassPathXmlApplicationContext。

再来看refesh()，该方法是接口ConfigurableApplicationContext中定义的方法，是应用真正启动的方法，所以这个方法非常重要。

具体到ClassPathXmlApplicationContext，这个refesh()的实现是在其父类AbstractApplicationContext中：

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
    // Prepare this context for refreshing.
    prepareRefresh();

    // Tell the subclass to refresh the internal bean factory.
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

    // Prepare the bean factory for use in this context.
    prepareBeanFactory(beanFactory);

    try {
        // Allows post-processing of the bean factory in context subclasses.
        postProcessBeanFactory(beanFactory);

        // Invoke factory processors registered as beans in the context.
        invokeBeanFactoryPostProcessors(beanFactory);

        // Register bean processors that intercept bean creation.
        registerBeanPostProcessors(beanFactory);

        // Initialize message source for this context.
        initMessageSource();

        // Initialize event multicaster for this context.
        initApplicationEventMulticaster();

        // Initialize other special beans in specific context subclasses.
        onRefresh();

        // Check for listener beans and register them.
        registerListeners();

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

        // Last step: publish corresponding event.
        finishRefresh();
    }

    catch (BeansException ex) {
        // Destroy already created singletons to avoid dangling resources.
        destroyBeans();
        // Reset 'active' flag.
        cancelRefresh(ex);
        // Propagate exception to caller.
        throw ex;
    }

    finally {
        // Reset common introspection caches in Spring's core, since we
        // might not ever need metadata for singleton beans anymore...
        resetCommonCaches();
    }
    }
}

忽略同步措施，只看具体逻辑。Spring对refresh()方法注释的非常详细，鉴于翻译可能表达的不太准备，保留了原文注释。我们将该方法内的每个方法看做一个步骤进行追踪。

第一步：prepareRefresh()，刷新该context的准备工作。

protected void prepareRefresh() {
    this.startupDate = System.currentTimeMillis();
    this.closed.set(false);
    this.active.set(true);

    if (logger.isInfoEnabled()) {
        logger.info("Refreshing " + this);
    }

    // Initialize any placeholder property sources in the context environment
    initPropertySources();

    // Validate that all properties marked as required are resolvable
    // see ConfigurablePropertyResolver#setRequiredProperties
    getEnvironment().validateRequiredProperties();

    // Allow for the collection of early ApplicationEvents,
    // to be published once the multicaster is available...
    this.earlyApplicationEvents = new LinkedHashSet<>();
}

AbstractApplicationContext中定义了几个变量表示当前Context的状态：

/** 当前context启动的时间，毫秒 */
private long startupDate;

/** 当前context是否被激活 */
private final AtomicBoolean active = new AtomicBoolean();

/** 当前context是否已经被关闭 */
private final AtomicBoolean closed = new AtomicBoolean();

所以，prepareRefresh()中首先记下当前context启动的时间，并设置该context已激活，且没有被关闭。

initPropertySources翻译过来就是初始化配置资源（这里的property是表示配置项而非属性），是交给子类选择性实现，具体到ClassPathXmlApplicationContext，它没有实现该方法。这其实是Spring留给用户进行个性化的配置来源的，比如应用中有一些特殊配置项或者要求，可以在这里将这些特殊的配置项设置到该Context的Environment中，比如：

public class MyClassPathXmlApplicationContext extends ClassPathXmlApplicationContext {
    @Override
    protected void initPropertySources() {
        //要求必须含有该var这个配置
        getEnvironment().setRequiredProperties("var");
    }
}

getEnvironment().validateRequiredProperties()：先看getEnvironment()

//getEnvironment()的时候，先看该context中有没有environment，没有的话就新建
public ConfigurableEnvironment getEnvironment() {
    if (this.environment == null) {
        this.environment = createEnvironment();
    }
    return this.environment;
}
//创建一个StandardEnvironment
protected ConfigurableEnvironment createEnvironment() {
    return new StandardEnvironment();
}

到这里，该context已经有环境environment了。校验的逻辑是在StandardEnvironment的父类AbstractEnvironment中，且又委托给了配置解析器PropertyResolver：

private final MutablePropertySources propertySources = new MutablePropertySources(this.logger);

private final ConfigurablePropertyResolver propertyResolver = new PropertySourcesPropertyResolver(this.propertySources);

... ... 
public void validateRequiredProperties() throws MissingRequiredPropertiesException {
    this.propertyResolver.validateRequiredProperties();
}

由于这里并没有设置配置项为必须（setRequiredProperties("property")），所以validateRequiredProperties相当于没有什么必须的配置项进行校验。

所以，第一步的准备工作prepareRefresh()主要是：设置Context的启动时间/状态，创建Context的Environment，校验必须配置项是否能解析到值。