Spring 初始化

基于spring 4.1.6

1、FileSystemXmlApplicationContext

/**

* Create a new FileSystemXmlApplicationContext, loading the definitions

* from the given XML files.

* @param configLocations array of file paths

* @param refresh whether to automatically refresh the context,

* loading all bean definitions and creating all singletons.

* Alternatively, call refresh manually after further configuring the context.

* @throws BeansException if context creation failed

* @see #refresh()

*/

public FileSystemXmlApplicationContext(String configLocation) throws BeansException {

  this(new String[] {configLocation}, true, null);

}

/**

* Create a new FileSystemXmlApplicationContext with the given parent,

* loading the definitions from the given XML files.

* @param configLocations array of file paths

* @param refresh whether to automatically refresh the context,

* loading all bean definitions and creating all singletons.

* Alternatively, call refresh manually after further configuring the context.

* @param parent the parent context

* @throws BeansException if context creation failed

* @see #refresh()

*/

public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)

      throws BeansException {

  super(parent);

  setConfigLocations(configLocations);

  if (refresh) {

      refresh();

  }

}

第29行 super(parent); 实例化父类，AbstractXmlApplicationContext、AbstractRefreshableConfigApplicationContext、AbstractRefreshableApplicationContext、AbstractApplicationContext

第32行 refresh();

2、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) {

        logger.warn("Exception encountered during context initialization - cancelling refresh attempt", ex);

        // Destroy already created singletons to avoid dangling resources.

        destroyBeans();

        // Reset 'active' flag.

        cancelRefresh(ex);

        // Propagate exception to caller.

        throw ex;

      }

  }

}

第4行

prepareRefresh();

// Tell the subclass to refresh the internal bean factory.

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

第38行

finishRefresh();

第7行 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {

  refreshBeanFactory();

  ConfigurableListableBeanFactory beanFactory = getBeanFactory();

  if (logger.isDebugEnabled()) {

      logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);

  }

  return beanFactory;

}

第2行 refreshBeanFactory(); 该方法两个子类均有实现

AbstractRefreshableApplicationContext 和 GenericApplicationContext，前面 FileSystemXmlApplicationContext 有 AbstractRefreshableApplicationContext 实例化。

3、AbstractRefreshableApplicationContext

/**

* This implementation performs an actual refresh of this context's underlying

* bean factory, shutting down the previous bean factory (if any) and

* initializing a fresh bean factory for the next phase of the context's lifecycle.

*/

@Override

protected final void refreshBeanFactory() throws BeansException {

  if (hasBeanFactory()) {

      destroyBeans();

      closeBeanFactory();

  }

  try {

      DefaultListableBeanFactory beanFactory = createBeanFactory();

      beanFactory.setSerializationId(getId());

      customizeBeanFactory(beanFactory);

      loadBeanDefinitions(beanFactory);

      synchronized (this.beanFactoryMonitor) {

        this.beanFactory = beanFactory;

      }

  }

  catch (IOException ex) {

      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);

  }

}

第13行

DefaultListableBeanFactory beanFactory = createBeanFactory();

4、进入 loadBeanDefinitions(beanFactory); 方法，AbstractXmlApplicationContext

/**

* Loads the bean definitions via an XmlBeanDefinitionReader.

* @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader

* @see #initBeanDefinitionReader

* @see #loadBeanDefinitions

*/

@Override

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {

  // Create a new XmlBeanDefinitionReader for the given BeanFactory.

  XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

  // Configure the bean definition reader with this context's

  // resource loading environment.

  beanDefinitionReader.setEnvironment(this.getEnvironment());

  beanDefinitionReader.setResourceLoader(this);

  beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

  // Allow a subclass to provide custom initialization of the reader,

  // then proceed with actually loading the bean definitions.

  initBeanDefinitionReader(beanDefinitionReader);

  loadBeanDefinitions(beanDefinitionReader);

}

第10行

XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

/**

* Load the bean definitions with the given XmlBeanDefinitionReader.

* 
The lifecycle of the bean factory is handled by the {@link #refreshBeanFactory}

* method; hence this method is just supposed to load and/or register bean definitions.

* @param reader the XmlBeanDefinitionReader to use

* @throws BeansException in case of bean registration errors

* @throws IOException if the required XML document isn't found

* @see #refreshBeanFactory

* @see #getConfigLocations

* @see #getResources

* @see #getResourcePatternResolver

*/

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {

  Resource[] configResources = getConfigResources();

  if (configResources != null) {

      reader.loadBeanDefinitions(configResources);

  }

  String[] configLocations = getConfigLocations();

  if (configLocations != null) {

      reader.loadBeanDefinitions(configLocations);

  }

}

5、AbstractBeanDefinitionReader

public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {

  Assert.notNull(locations, "Location array must not be null");

  int counter = 0;

  for (String location : locations) {

      counter += loadBeanDefinitions(location);

  }

  return counter;

}

public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {

  return loadBeanDefinitions(location, null);

}

public int loadBeanDefinitions(String location, Set actualResources) throws BeanDefinitionStoreException {

  ResourceLoader resourceLoader = getResourceLoader();

  if (resourceLoader == null) {

      throw new BeanDefinitionStoreException(

            "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");

  }

  if (resourceLoader instanceof ResourcePatternResolver) {

      // Resource pattern matching available.

      try {

        Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);

        int loadCount = loadBeanDefinitions(resources);

        if (actualResources != null) {

            for (Resource resource : resources) {

              actualResources.add(resource);

            }

        }

        if (logger.isDebugEnabled()) {

            logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");

        }

        return loadCount;

      }

      catch (IOException ex) {

        throw new BeanDefinitionStoreException(

              "Could not resolve bean definition resource pattern [" + location + "]", ex);

      }

  }

  else {

      // Can only load single resources by absolute URL.

      Resource resource = resourceLoader.getResource(location);

      int loadCount = loadBeanDefinitions(resource);

      if (actualResources != null) {

        actualResources.add(resource);

      }

      if (logger.isDebugEnabled()) {

        logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");

      }

      return loadCount;

  }

}

第31行，loadBeanDefinitions(resources); 为什么是 XmlBeanDefinitionReader 这个类？
因为，BeanDefinitionReader接口好多实现类，XmlBeanDefinitionReader只是其中一个子类，因为步骤4有定义啦。

6、XmlBeanDefinitionReader

/**

* Load bean definitions from the specified XML file.

* @param resource the resource descriptor for the XML file

* @return the number of bean definitions found

* @throws BeanDefinitionStoreException in case of loading or parsing errors

*/

@Override

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {

  return loadBeanDefinitions(new EncodedResource(resource));

}

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {

  Assert.notNull(encodedResource, "EncodedResource must not be null");

  if (logger.isInfoEnabled()) {

      logger.info("Loading XML bean definitions from " + encodedResource.getResource());

  }

  Set currentResources = this.resourcesCurrentlyBeingLoaded.get();

  if (currentResources == null) {

      currentResources = new HashSet(4);

      this.resourcesCurrentlyBeingLoaded.set(currentResources);

  }

  if (!currentResources.add(encodedResource)) {

      throw new BeanDefinitionStoreException(

            "Detected cyclic loading of " + encodedResource + " - check your import definitions!");

  }

  try {

      InputStream inputStream = encodedResource.getResource().getInputStream();

      try {

        InputSource inputSource = new InputSource(inputStream);

        if (encodedResource.getEncoding() != null) {

            inputSource.setEncoding(encodedResource.getEncoding());

        }

        return doLoadBeanDefinitions(inputSource, encodedResource.getResource());

      }

      finally {

        inputStream.close();

      }

  }

  catch (IOException ex) {

      throw new BeanDefinitionStoreException(

            "IOException parsing XML document from " + encodedResource.getResource(), ex);

  }

  finally {

      currentResources.remove(encodedResource);

      if (currentResources.isEmpty()) {

        this.resourcesCurrentlyBeingLoaded.remove();

      }

  }

}

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)

      throws BeanDefinitionStoreException {

  try {

      Document doc = doLoadDocument(inputSource, resource);

      return registerBeanDefinitions(doc, resource);

  }

  catch (BeanDefinitionStoreException ex) {

      throw ex;

  }

  catch (SAXParseException ex) {

      throw new XmlBeanDefinitionStoreException(resource.getDescription(),

            "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);

  }

  catch (SAXException ex) {

      throw new XmlBeanDefinitionStoreException(resource.getDescription(),

            "XML document from " + resource + " is invalid", ex);

  }

  catch (ParserConfigurationException ex) {

      throw new BeanDefinitionStoreException(resource.getDescription(),

            "Parser configuration exception parsing XML from " + resource, ex);

  }

  catch (IOException ex) {

      throw new BeanDefinitionStoreException(resource.getDescription(),

            "IOException parsing XML document from " + resource, ex);

  }

  catch (Throwable ex) {

      throw new BeanDefinitionStoreException(resource.getDescription(),

            "Unexpected exception parsing XML document from " + resource, ex);

  }

}

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {

  BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();

  documentReader.setEnvironment(getEnvironment());

  int countBefore = getRegistry().getBeanDefinitionCount();

  documentReader.registerBeanDefinitions(doc, createReaderContext(resource));

  return getRegistry().getBeanDefinitionCount() - countBefore;

}

第5行，documentReader.registerBeanDefinitions(doc, createReaderContext(resource));

7、DefaultBeanDefinitionDocumentReader

/**

* This implementation parses bean definitions according to the "spring-beans" XSD

* (or DTD, historically).

* 
Opens a DOM Document; then initializes the default settings

* specified at the {@code } level; then parses the contained bean definitions.

*/

@Override

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {

  this.readerContext = readerContext;

  logger.debug("Loading bean definitions");

  Element root = doc.getDocumentElement();

  doRegisterBeanDefinitions(root);

}

protected void doRegisterBeanDefinitions(Element root) {

  // Any nested  elements will cause recursion in this method. In

  // order to propagate and preserve  default-* attributes correctly,

  // keep track of the current (parent) delegate, which may be null. Create

  // the new (child) delegate with a reference to the parent for fallback purposes,

  // then ultimately reset this.delegate back to its original (parent) reference.

  // this behavior emulates a stack of delegates without actually necessitating one.

  BeanDefinitionParserDelegate parent = this.delegate;

  this.delegate = createDelegate(getReaderContext(), root, parent);

  if (this.delegate.isDefaultNamespace(root)) {

      String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);

      if (StringUtils.hasText(profileSpec)) {

        String[] specifiedProfiles = StringUtils.tokenizeToStringArray(

              profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);

        if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {

            return;

        }

      }

  }

  preProcessXml(root);

  parseBeanDefinitions(root, this.delegate);

  postProcessXml(root);

  this.delegate = parent;

}

第23行，parseBeanDefinitions(root, this.delegate);

/**

* Parse the elements at the root level in the document:

* "import", "alias", "bean".

* @param root the DOM root element of the document

*/

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {

  if (delegate.isDefaultNamespace(root)) {

      NodeList nl = root.getChildNodes();

      for (int i = 0; i < nl.getLength(); i++) {

        Node node = nl.item(i);

        if (node instanceof Element) {

            Element ele = (Element) node;

            if (delegate.isDefaultNamespace(ele)) {

              parseDefaultElement(ele, delegate);

            }

            else {

              delegate.parseCustomElement(ele);

            }

        }

      }

  }

  else {

      delegate.parseCustomElement(root);

  }

}

第13行，如果是spring的基础命名元素解析（import、bean、beans、alias）解析：

parseDefaultElement(ele, delegate);

拓展元素解析：delegate.parseCustomElement(ele); 拓展元素涉及到aop相关，后面的内容讨论。

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {

  if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {

      importBeanDefinitionResource(ele);

  }

  else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {

      processAliasRegistration(ele);

  }

  else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {

      processBeanDefinition(ele, delegate);

  }

  else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {

      // recurse

      doRegisterBeanDefinitions(ele);

  }

}

下面以解析bean为例

/**

* Process the given bean element, parsing the bean definition

* and registering it with the registry.

*/

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {

  BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

  if (bdHolder != null) {

      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

      try {

        // Register the final decorated instance.

        BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

      }

      catch (BeanDefinitionStoreException ex) {

        getReaderContext().error("Failed to register bean definition with name '" +

              bdHolder.getBeanName() + "'", ele, ex);

      }

      // Send registration event.

      getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));

  }

}

8、BeanDefinitionReaderUtils

/**

* Register the given bean definition with the given bean factory.

* @param definitionHolder the bean definition including name and aliases

* @param registry the bean factory to register with

* @throws BeanDefinitionStoreException if registration failed

*/

public static void registerBeanDefinition(

      BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)

      throws BeanDefinitionStoreException {

  // Register bean definition under primary name.

  String beanName = definitionHolder.getBeanName();

  registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

  // Register aliases for bean name, if any.

  String[] aliases = definitionHolder.getAliases();

  if (aliases != null) {

      for (String alias : aliases) {

        registry.registerAlias(beanName, alias);

      }

  }

}

9、DefaultListableBeanFactory

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)

      throws BeanDefinitionStoreException {

  Assert.hasText(beanName, "Bean name must not be empty");

  Assert.notNull(beanDefinition, "BeanDefinition must not be null");

  if (beanDefinition instanceof AbstractBeanDefinition) {

      try {

        ((AbstractBeanDefinition) beanDefinition).validate();

      }

      catch (BeanDefinitionValidationException ex) {

        throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,

              "Validation of bean definition failed", ex);

      }

  }

  BeanDefinition oldBeanDefinition;

  oldBeanDefinition = this.beanDefinitionMap.get(beanName);

  if (oldBeanDefinition != null) {

      if (!isAllowBeanDefinitionOverriding()) {

        throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,

              "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +

              "': There is already [" + oldBeanDefinition + "] bound.");

      }

      else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {

        // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE

        if (this.logger.isWarnEnabled()) {

            this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +

                  "' with a framework-generated bean definition: replacing [" +

                  oldBeanDefinition + "] with [" + beanDefinition + "]");

        }

      }

      else {

        if (this.logger.isInfoEnabled()) {

            this.logger.info("Overriding bean definition for bean '" + beanName +

                  "': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");

        }

      }

  }

  else {

      this.beanDefinitionNames.add(beanName);

      this.manualSingletonNames.remove(beanName);

      this.frozenBeanDefinitionNames = null;

  }

  this.beanDefinitionMap.put(beanName, beanDefinition);

  if (oldBeanDefinition != null || containsSingleton(beanName)) {

      resetBeanDefinition(beanName);

  }

}

以上完成读取、解析、注册，然后到 2、AbstractApplicationContext 的 finishBeanFactoryInitialization(beanFactory);

补充然后，

实例化 DefaultListableBeanFactory 的时候，调用 preInstantiateSingletons 完成bean实例化，不是抽象的bean，是单例的bean，非懒加载。

10、AbstractApplicationContext

refresh() 方法中调用 finishBeanFactoryInitialization(beanFactory);

/**

* Finish the initialization of this context's bean factory,

* initializing all remaining singleton beans.

*/

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

  }

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

}

第10行，getBean方法，到21还是22，应该是到21、DefaultListableBeanFactory，因为前面有实例化该类。

11、DefaultListableBeanFactory

public void preInstantiateSingletons() throws BeansException {

  if (this.logger.isDebugEnabled()) {

      this.logger.debug("Pre-instantiating singletons in " + this);

  }

  // Iterate over a copy to allow for init methods which in turn register new bean definitions.

  // While this may not be part of the regular factory bootstrap, it does otherwise work fine.

  List beanNames = new ArrayList(this.beanDefinitionNames);

  // Trigger initialization of all non-lazy singleton beans...

  for (String beanName : beanNames) {

      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {

        if (isFactoryBean(beanName)) {

            final FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);

            boolean isEagerInit;

            if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {

              isEagerInit = AccessController.doPrivileged(new PrivilegedAction() {

                  @Override

                  public Boolean run() {

                    return ((SmartFactoryBean) factory).isEagerInit();

                  }

              }, getAccessControlContext());

            }

            else {

              isEagerInit = (factory instanceof SmartFactoryBean &&

                    ((SmartFactoryBean) factory).isEagerInit());

            }

            if (isEagerInit) {

              getBean(beanName);

            }

        }

        else {

            getBean(beanName);

        }

      }

  }

  // Trigger post-initialization callback for all applicable beans...

  for (String beanName : beanNames) {

      Object singletonInstance = getSingleton(beanName);

      if (singletonInstance instanceof SmartInitializingSingleton) {

        final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;

        if (System.getSecurityManager() != null) {

            AccessController.doPrivileged(new PrivilegedAction