publicinterfaceApplicationContextextendsEnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
        MessageSource, ApplicationEventPublisher, ResourcePatternResolver{
    String getId();
    String getApplicationName();
    String getDisplayName();
    longgetStartupDate();
    ApplicationContext getParent();
    AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;

package com.alibaba.spring;

import com.alibaba.spring.beans.Producer;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
* @author Lin ZhenHua
*/
public class Application{
  public static void main(String[] args) {
      ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
      Producer producer = context.getBean(Producer.class);
      System.out.println("running the test case with name = " + producer.getCount());
  }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
  <bean name="producer"class="com.alibaba.spring.beans.Producer">
      <property name="count"value="10" />
  </bean>
</beans>

七月 10, 2018 11:31:16 上午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@5197848c: startup date [Tue Jul 10 11:31:16 CST 2018]; root of context hierarchy
七月 10, 2018 11:31:17 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [applicationContext.xml]
running the test case with name = 10

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

/**
* loading the definitions
* from the given XML file and automatically refreshing the context
*/
publicClassPathXmlApplicationContext(String configLocation) throws BeansException {
  this(new String[] {configLocation}, true, null);
}

publicClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
          throws BeansException {
  super(parent);
  setConfigLocations(configLocations);
if (refresh) {
      refresh(); //核心方法
  }
}

/**
  * Load or refresh the persistent representation of the configuration
  */
  public void refresh() throws BeansException, IllegalStateException {
      //容器重启同步监控锁，防止刷新进行到一半被重复执行
      synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
          //填充配置文件占位符，记录容器启动时间和启动状态
          prepareRefresh();
//完成配置文件定义到注册表登记bean的流程，此时对象还未被创建
          // Tell the subclass to refresh the internal bean factory.
          ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
          //配置类加载器，定制特殊bean，添加BeanPostProcessor可供回调
          prepareBeanFactory(beanFactory);
try {
              // Allows post-processing of the bean factory in context subclasses.
              //工厂加载完配置，初始化之前回调PostProcessBeanFactory，作为工厂扩展功能
              postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
              //调用上文注册的扩展接口PostProcessBeanFactory的实现，为扩展接口为列表类型
              invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
              // bean扩展:postProcessBeforeInitialization和postProcessAfterInitialization
               //分别在Bean初始化之前和初始化之后得到执行
              registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
              //初始化MessageSource对象，国际化
              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.
              //实例化工厂注册表里面的bean（懒加载的除外，用到才实例化）
              finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
              //初始化生命周期，广播事件
              finishRefresh();
          }
          catch (BeansException ex) {
if (logger.isWarnEnabled()) {
                  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;
          }
          finally {
// Reset common introspection caches in Spring's core, since we
              // might not ever need metadata for singleton beans anymore...
              resetCommonCaches();
          }
      }
  }

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<ApplicationEvent>();
  }

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
       //关闭旧工厂，创建新工厂
      refreshBeanFactory();
//返回创建的新工厂
      ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
          logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
      }
return beanFactory;
  }

@Override
  protectedfinalvoidrefreshBeanFactory() throws BeansException {
      //存在BeanFactory()则销毁，即清除工厂里面Map存放的对象
      if (hasBeanFactory()) {
          destroyBeans();
          closeBeanFactory();
      }
try {
           //返回新建的DefaultListableBeanFactory
          DefaultListableBeanFactory beanFactory = createBeanFactory();
//工厂标识id
          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);
      }
  }

protected DefaultListableBeanFactory createBeanFactory() {
      return new DefaultListableBeanFactory(getInternalParentBeanFactory());
  }

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
      // Create a new XmlBeanDefinitionReader for the given BeanFactory.
       //实例化一个工厂类的XML文件阅读器
      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.
       //开启xml文件校验，可在实现的子类关闭
      initBeanDefinitionReader(beanDefinitionReader);
//beanDefinitionReader阅读器加载资源文件
      loadBeanDefinitions(beanDefinitionReader);
  }

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
      Resource[] configResources = getConfigResources();
if (configResources != null) {
          reader.loadBeanDefinitions(configResources);
      }
//configLocations最终解析成资源对象configResources，效果跟上面分支一样
      String[] configLocations = getConfigLocations();
if (configLocations != null) {
          reader.loadBeanDefinitions(configLocations);
      }
  }

public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
      Assert.notNull(resources, "Resource array must not be null");
      int counter = 0;
      for (Resource resource : resources) {
          counter += loadBeanDefinitions(resource);
      }
return counter;
  }

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

//使用ThreadLocal存放配置文件路径
      Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
      if (currentResources == null) {
          currentResources = new HashSet<EncodedResource>(4);
          this.resourcesCurrentlyBeingLoaded.set(currentResources);
      }
if (!currentResources.add(encodedResource)) {
          thrownew 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) {
          thrownew 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 {
          //xml文件生成Document文件数
          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();
//注册表已存在Definition数量（对象的描述）
      int countBefore = getRegistry().getBeanDefinitionCount();
       //将doc树的bean定义注册到工厂类的注册表属性
      documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
return getRegistry().getBeanDefinitionCount() - countBefore;
  }

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 <beans> elements will cause recursion in this method. In
      // order to propagate and preserve <beans> 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;
       //创建解析DOM树对象的工具BeanDefinitionParserDelegate
      this.delegate = createDelegate(getReaderContext(), root, parent);

if (this.delegate.isDefaultNamespace(root)) {
           //如果不包含<profile>标签则略过该操作，非必要方法，略过
          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)) {
                  if (logger.isInfoEnabled()) {
                      logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                              "] not matching: " + getReaderContext().getResource());
                  }
return;
              }
          }
      }

      preProcessXml(root);//预留方法，解析前的扩展操作
      parseBeanDefinitions(root, this.delegate);//核心方法，解析DOM树
      postProcessXml(root);//预留方法，解析后的扩展操作

this.delegate = parent;
  }

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;
//包含http://www.springframework.org/schema/beans的为默认命名空间
                  if (delegate.isDefaultNamespace(ele)) {
                      parseDefaultElement(ele, delegate);
                  }
else {
                        //非默认命名空间的有<mvc/>、<context/>、<aop/>等
                      delegate.parseCustomElement(ele);
                  }
              }
          }
      }
else {
          delegate.parseCustomElement(root);
      }
  }

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
      if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
          importBeanDefinitionResource(ele);
      }
elseif (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
          processAliasRegistration(ele);
      }
elseif (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
          processBeanDefinition(ele, delegate);//解析命名空间为bean的标签
      }
elseif (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
          // recurse
          doRegisterBeanDefinitions(ele);
      }
  }

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
      //将DOM树对象转化为BeanDefinition包装类bdHolder
      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));
      }
  }

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
      return parseBeanDefinitionElement(ele, null);
  }

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
      String id = ele.getAttribute(ID_ATTRIBUTE);
      String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

      List<String> aliases = new ArrayList<String>();
      if (StringUtils.hasLength(nameAttr)) {
          String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
          aliases.addAll(Arrays.asList(nameArr));
      }

      String beanName = id;
if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
          beanName = aliases.remove(0);
          if (logger.isDebugEnabled()) {
              logger.debug("No XML 'id' specified - using '" + beanName +
                      "' as bean name and " + aliases + " as aliases");
          }
      }

if (containingBean == null) {
          checkNameUniqueness(beanName, aliases, ele);
      }
//DOM树标签映射到BeanDefinition对象
      AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
if (beanDefinition != null) {
          if (!StringUtils.hasText(beanName)) {
              try {
                  if (containingBean != null) {
                      beanName = BeanDefinitionReaderUtils.generateBeanName(
                              beanDefinition, this.readerContext.getRegistry(), true);
                  }
else {
                      beanName = this.readerContext.generateBeanName(beanDefinition);
                      // Register an alias for the plain bean class name, if still possible,
                      // if the generator returned the class name plus a suffix.
                      // This is expected for Spring 1.2/2.0 backwards compatibility.
                      String beanClassName = beanDefinition.getBeanClassName();
if (beanClassName != null &&
                              beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
                              !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
                          aliases.add(beanClassName);
                      }
                  }
if (logger.isDebugEnabled()) {
                      logger.debug("Neither XML 'id' nor 'name' specified - " +
                              "using generated bean name [" + beanName + "]");
                  }
              }
catch (Exception ex) {
                  error(ex.getMessage(), ele);
return null;
              }
          }
          String[] aliasesArray = StringUtils.toStringArray(aliases);
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
      }

return null;
  }

public AbstractBeanDefinition parseBeanDefinitionElement(
          Element ele, String beanName, BeanDefinition containingBean) {

this.parseState.push(new BeanEntry(beanName));

      String className = null;
      if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
          className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
      }

try {
          String parent = null;
          if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
              parent = ele.getAttribute(PARENT_ATTRIBUTE);
          }
//创建BeanDefinition对象，设置对应类名
          AbstractBeanDefinition bd = createBeanDefinition(className, parent);
//将xml里面的标签一一解析到BeanDefinition对象
          parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
          bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

          parseMetaElements(ele, bd);
          parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
          parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

          parseConstructorArgElements(ele, bd);
          parsePropertyElements(ele, bd);
          parseQualifierElements(ele, bd);

          bd.setResource(this.readerContext.getResource());
          bd.setSource(extractSource(ele));

return bd;
      }
catch (ClassNotFoundException ex) {
          error("Bean class [" + className + "] not found", ele, ex);
      }
catch (NoClassDefFoundError err) {
          error("Class that bean class [" + className + "] depends on not found", ele, err);
      }
catch (Throwable ex) {
          error("Unexpected failure during bean definition parsing", ele, ex);
      }
finally {
          this.parseState.pop();
      }

return null;
  }

public static void registerBeanDefinition(
          BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
          throws BeanDefinitionStoreException {

// Register bean definition under primary name.
      String beanName = definitionHolder.getBeanName();
//通过beanName注册definitionHolder的BeanDefinition对象到注册表
      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);
          }
      }
  }

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;
//我们奋斗这么久就是为了吧xml转换为Definition然后put到beanDefinitionMap
      oldBeanDefinition = this.beanDefinitionMap.get(beanName);
       //新的xml获取出来的应该为空
      if (oldBeanDefinition != null) {
          if (!isAllowBeanDefinitionOverriding()) {
              throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                      "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
                      "': There is already [" + oldBeanDefinition + "] bound.");
          }
elseif (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 + "]");
              }
          }
elseif (!beanDefinition.equals(oldBeanDefinition)) {
              if (this.logger.isInfoEnabled()) {
                  this.logger.info("Overriding bean definition for bean '" + beanName +
                          "' with a different definition: replacing [" + oldBeanDefinition +
                          "] with [" + beanDefinition + "]");
              }
          }
else {
              if (this.logger.isDebugEnabled()) {
                  this.logger.debug("Overriding bean definition for bean '" + beanName +
                          "' with an equivalent definition: replacing [" + oldBeanDefinition +
                          "] with [" + beanDefinition + "]");
              }
          }
this.beanDefinitionMap.put(beanName, beanDefinition);
      }
else {
           //初始化的过程，应该不允许实例化
          if (hasBeanCreationStarted()) {
              // Cannot modify startup-time collection elements anymore (for stable iteration)
              synchronized (this.beanDefinitionMap) {
                  this.beanDefinitionMap.put(beanName, beanDefinition);
                  List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
                  updatedDefinitions.addAll(this.beanDefinitionNames);
                  updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
                  if (this.manualSingletonNames.contains(beanName)) {
                      Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
                      updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
                  }
              }
          }
else {
               //最核心的一步，就是beanDefinitionMap增加beanDefinition
              // Still in startup registration phase
              this.beanDefinitionMap.put(beanName, beanDefinition);
              this.beanDefinitionNames.add(beanName);
              this.manualSingletonNames.remove(beanName);
          }
this.frozenBeanDefinitionNames = null;
      }

if (oldBeanDefinition != null || containsSingleton(beanName)) {
          resetBeanDefinition(beanName);
      }
  }

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

// Register a default embedded value resolver if no bean post-processor
      // (such as a PropertyPlaceholderConfigurer bean) registered any before:
      // at this point, primarily for resolution in annotation attribute values.
      if (!beanFactory.hasEmbeddedValueResolver()) {
          beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
              @Override
              public String resolveStringValue(String strVal) {
                  return getEnvironment().resolvePlaceholders(strVal);
              }
          });
      }

// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
       //JVM动态织入第三方模块
      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();
  }

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<String> beanNames = new ArrayList<String>(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)) {//通常不是工厂bean
                  final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                  boolean isEagerInit;
                  if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                      isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
                          @Override
                          public Boolean run() {
                              return ((SmartFactoryBean<?>) factory).isEagerInit();
                          }
                      }, getAccessControlContext());
                  }
                  else {
                      isEagerInit = (factory instanceof SmartFactoryBean &&
                              ((SmartFactoryBean<?>) factory).isEagerInit());
                  }
                  if (isEagerInit) {
                      getBean(beanName);
                  }
              }
              else {
                  getBean(beanName);//进入实例化bean
              }
          }
      }

      // 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<Object>() {
                      @Override
                      public Object run() {
                          smartSingleton.afterSingletonsInstantiated();
                          return null;
                      }
                  }, getAccessControlContext());
              }
              else {
                  smartSingleton.afterSingletonsInstantiated();
              }
          }
      }
  }

publicObject getBean(String name) throws BeansException {
      returndoGetBean(name, null, null, false);
  }

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
 if (logger.isDebugEnabled()) {
    logger.debug("Creating instance of bean '" + beanName + "'");
 }
 RootBeanDefinition mbdToUse = mbd;

//确保对象对应的类被加载进内存
 // Make sure bean class is actually resolved at this point, and
 // clone the bean definition in case of a dynamically resolved Class
 // which cannot be stored in the shared merged bean definition.
 Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
    mbdToUse = new RootBeanDefinition(mbd);
    mbdToUse.setBeanClass(resolvedClass);
 }

// Prepare method overrides.
 try {
    mbdToUse.prepareMethodOverrides();
 }
catch (BeanDefinitionValidationException ex) {
    throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
          beanName, "Validation of method overrides failed", ex);
 }

try {
    // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
    //为AOP做的钩子
    Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
       return bean;
    }
 }
catch (Throwable ex) {
    throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
          "BeanPostProcessor before instantiation of bean failed", ex);
 }

//终于到了创建对象了，还有完没完啊。。。
 Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
    logger.debug("Finished creating instance of bean '" + beanName + "'");
 }
return beanInstance;
}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
    throws BeanCreationException {

// Instantiate the bean.
 BeanWrapper instanceWrapper = null;
 if (mbd.isSingleton()) {
    //从工厂bean缓存容器里面移除
    instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
 }
//为空说明不是工厂bean，可以直接创建对象
 if (instanceWrapper == null) {
     //这一步是真正的创建对象，看来还没完没了啊。。。。
    instanceWrapper = createBeanInstance(beanName, mbd, args);
 }
//经过漫长的过程，我们终于得到我们心心念念的bean了，坑爹。。。
 final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
 Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
 mbd.resolvedTargetType = beanType;

// Allow post-processors to modify the merged bean definition.
 //创建完bean后的一些特殊操作
 synchronized (mbd.postProcessingLock) {
    if (!mbd.postProcessed) {
       try {
          applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
       }
catch (Throwable ex) {
          throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                "Post-processing of merged bean definition failed", ex);
       }
       mbd.postProcessed = true;
    }
 }

//解析循环依赖的逻辑，比较复杂，后面有时间再研究
 // Eagerly cache singletons to be able to resolve circular references
 // even when triggered by lifecycle interfaces like BeanFactoryAware.
 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
       isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
    if (logger.isDebugEnabled()) {
       logger.debug("Eagerly caching bean '" + beanName +
             "' to allow for resolving potential circular references");
    }
    addSingletonFactory(beanName, new ObjectFactory<Object>() {
       @Override
       public Object getObject() throws BeansException {
          return getEarlyBeanReference(beanName, mbd, bean);
       }
    });
 }

//该方法两大重头戏，上面createBeanInstance是创建对象，populateBean是初始化属性值
 // Initialize the bean instance.
 Object exposedObject = bean;
try {
    populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
       exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
 }
catch (Throwable ex) {
    if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
       throw (BeanCreationException) ex;
    }
else {
       throw new BeanCreationException(
             mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
    }
 }

if (earlySingletonExposure) {
    Object earlySingletonReference = getSingleton(beanName, false);
    if (earlySingletonReference != null) {
       if (exposedObject == bean) {
          exposedObject = earlySingletonReference;
       }
elseif (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
          String[] dependentBeans = getDependentBeans(beanName);
          Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
          for (String dependentBean : dependentBeans) {
             if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                actualDependentBeans.add(dependentBean);
             }
          }
if (!actualDependentBeans.isEmpty()) {
             throw new BeanCurrentlyInCreationException(beanName,
                   "Bean with name '" + beanName + "' has been injected into other beans [" +
                   StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
                   "wrapped. This means that said other beans do not use the final version of the " +
                   "bean. This is often the result of over-eager type matching - consider using " +
                   "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
          }
       }
    }
 }

// Register bean as disposable.
 try {
    registerDisposableBeanIfNecessary(beanName, bean, mbd);
 }
catch (BeanDefinitionValidationException ex) {
    throw new BeanCreationException(
          mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
 }

return exposedObject;
}

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
 //确保对象对应的类被加载了
 // Make sure bean class is actually resolved at this point.
 Class<?> beanClass = resolveBeanClass(mbd, beanName);

if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
    thrownew BeanCreationException(mbd.getResourceDescription(), beanName,
          "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
 }

//工厂方法实例化
 if (mbd.getFactoryMethodName() != null)  {
    return instantiateUsingFactoryMethod(beanName, mbd, args);
 }

//无参数构造方法实例化
 // Shortcut when re-creating the same bean...
 boolean resolved = false;
 boolean autowireNecessary = false;
 if (args == null) {
    synchronized (mbd.constructorArgumentLock) {
       if (mbd.resolvedConstructorOrFactoryMethod != null) {
          resolved = true;
          autowireNecessary = mbd.constructorArgumentsResolved;
       }
    }
 }
if (resolved) {
    if (autowireNecessary) {
       return autowireConstructor(beanName, mbd, null, null);
    }
else {
       return instantiateBean(beanName, mbd);
    }
 }

//有入参的构造方法实例化
 // Need to determine the constructor...
 Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
       mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
       mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
return autowireConstructor(beanName, mbd, ctors, args);
 }

//我们选简单一点的无参数构造方法实例化
 // No special handling: simply use no-arg constructor.
 return instantiateBean(beanName, mbd);
}

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
 try {
    Object beanInstance;
final BeanFactory parent = this;
    if (System.getSecurityManager() != null) {
       beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
          @Override
          public Object run() {
             //获取实例化策略，这会可是实实在在的实例化了
             return getInstantiationStrategy().instantiate(mbd, beanName, parent);
          }
       }, getAccessControlContext());
    }
else {
       beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
    }
    BeanWrapper bw = new BeanWrapperImpl(beanInstance);
    initBeanWrapper(bw);
return bw;
 }
catch (Throwable ex) {
    thrownew BeanCreationException(
          mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
 }
}

@Override
public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
 // Don't override the class with CGLIB if no overrides.
 if (bd.getMethodOverrides().isEmpty()) {
    Constructor<?> constructorToUse;
synchronized (bd.constructorArgumentLock) {
       constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
          final Class<?> clazz = bd.getBeanClass();
          if (clazz.isInterface()) {
             throw new BeanInstantiationException(clazz, "Specified class is an interface");
          }
try {
             if (System.getSecurityManager() != null) {
                constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
                   @Override
                   public Constructor<?> run() throws Exception {
                      return clazz.getDeclaredConstructor((Class[]) null);
                   }
                });
             }
else {
                //构造方法反射实例化
                constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
             }
             bd.resolvedConstructorOrFactoryMethod = constructorToUse;
          }
catch (Throwable ex) {
             throw new BeanInstantiationException(clazz, "No default constructor found", ex);
          }
       }
    }
return BeanUtils.instantiateClass(constructorToUse);
 }
else {
    // Must generate CGLIB subclass.
    return instantiateWithMethodInjection(bd, beanName, owner);
 }
}

public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
 Assert.notNull(ctor, "Constructor must not be null");
 try {
    ReflectionUtils.makeAccessible(ctor);
//核心核心！终于重bean里面获取类，类的构造方法，然后反射new除了对象，好累。
    return ctor.newInstance(args);
 }
catch (InstantiationException ex) {
    throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
 }
catch (IllegalAccessException ex) {
    throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
 }
catch (IllegalArgumentException ex) {
    throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
 }
catch (InvocationTargetException ex) {
    throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
 }
}

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
 //获取所有的属性值
 PropertyValues pvs = mbd.getPropertyValues();

if (bw == null) {
    if (!pvs.isEmpty()) {
       thrownew BeanCreationException(
             mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
    }
else {
       // Skip property population phase for null instance.
       return;
    }
 }

// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
 // state of the bean before properties are set. This can be used, for example,
 // to support styles of field injection.
 boolean continueWithPropertyPopulation = true;

//出现BeanPostProcessors又是钩子，给出各种特殊操作
 if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
       if (bp instanceof InstantiationAwareBeanPostProcessor) {
          InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
             continueWithPropertyPopulation = false;
             break;
          }
       }
    }
 }

if (!continueWithPropertyPopulation) {
    return;
 }

if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
       mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
    MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

// Add property values based on autowire by name if applicable.
    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
        //通过name属性来装配
       autowireByName(beanName, mbd, bw, newPvs);
    }

// Add property values based on autowire by type if applicable.
    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
       //通过type属性来装配
       autowireByType(beanName, mbd, bw, newPvs);
    }

    pvs = newPvs;
 }

boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
 boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

if (hasInstAwareBpps || needsDepCheck) {
    PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
if (hasInstAwareBpps) {
       for (BeanPostProcessor bp : getBeanPostProcessors()) {
          if (bp instanceof InstantiationAwareBeanPostProcessor) {
             InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
             pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvs == null) {
                return;
             }
          }
       }
    }
if (needsDepCheck) {
       checkDependencies(beanName, mbd, filteredPds, pvs);
    }
 }
//实际装配配置文件的属性
 applyPropertyValues(beanName, mbd, bw, pvs);
}

// Eagerly check singleton cache for manually registered singletons.
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
    if (logger.isDebugEnabled()) {
        if (isSingletonCurrentlyInCreation(beanName)) {
            logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
                         "' that is not fully initialized yet - a consequence of a circular reference");
        }
else {
            logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
        }
    }
    bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}

....

// Create bean instance.
if (mbd.isSingleton()) {
   sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
      @Override
      public Object getObject() throws BeansException {
         try {
            return createBean(beanName, mbd, args);
         }
catch (BeansException ex) {
            // Explicitly remove instance from singleton cache: It might have been put there
            // eagerly by the creation process, to allow for circular reference resolution.
            // Also remove any beans that received a temporary reference to the bean.
            destroySingleton(beanName);
throw ex;
         }
      }
   });
   bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

/**
 * Add an indexed constructor arg value. The current index is tracked internally
 * and all additions are at the present point.
 */
public BeanDefinitionBuilder addConstructorArgValue(Object value) {
   this.beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(
         this.constructorArgIndex++, value);
   return this;
}

/**
 * Add a reference to a named bean as a constructor arg.
 * @see #addConstructorArgValue(Object)
 */
public BeanDefinitionBuilder addConstructorArgReference(String beanName) {
   this.beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(
         this.constructorArgIndex++, new RuntimeBeanReference(beanName));
   return this;
}

/**
 * Add the supplied property value under the given name.
 */
public BeanDefinitionBuilder addPropertyValue(String name, Object value) {
   this.beanDefinition.getPropertyValues().add(name, value);
   return this;
}

/**
 * Add a reference to the specified bean name under the property specified.
 * @param name the name of the property to add the reference to
 * @param beanName the name of the bean being referenced
 */
public BeanDefinitionBuilder addPropertyReference(String name, String beanName) {
   this.beanDefinition.getPropertyValues().add(name, new RuntimeBeanReference(beanName));
   return this;
}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
      throws BeanCreationException {

//装饰器类，包装了具体的bean，将附带的功能封装在装饰器里面
   // Instantiate the bean.
   BeanWrapper instanceWrapper = null;
   if (mbd.isSingleton()) {
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
   }
if (instanceWrapper == null) {
      instanceWrapper = createBeanInstance(beanName, mbd, args);
   }
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
   Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
   mbd.resolvedTargetType = beanType;

// Allow post-processors to modify the merged bean definition.
   synchronized (mbd.postProcessingLock) {
      if (!mbd.postProcessed) {
         try {
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
         }
catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                  "Post-processing of merged bean definition failed", ex);
         }
         mbd.postProcessed = true;
      }
   }

// Eagerly cache singletons to be able to resolve circular references
   // even when triggered by lifecycle interfaces like BeanFactoryAware.
   boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
         isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
      if (logger.isDebugEnabled()) {
         logger.debug("Eagerly caching bean '" + beanName +
               "' to allow for resolving potential circular references");
      }
      addSingletonFactory(beanName, new ObjectFactory<Object>() {
         @Override
         public Object getObject() throws BeansException {
            return getEarlyBeanReference(beanName, mbd, bean);
         }
      });
   }

// Initialize the bean instance.
   Object exposedObject = bean;
try {
      populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
         exposedObject = initializeBean(beanName, exposedObject, mbd);
      }
   }
catch (Throwable ex) {
      if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
         throw (BeanCreationException) ex;
      }
else {
         throw new BeanCreationException(
               mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
      }
   }

if (earlySingletonExposure) {
      Object earlySingletonReference = getSingleton(beanName, false);
      if (earlySingletonReference != null) {
         if (exposedObject == bean) {
            exposedObject = earlySingletonReference;
         }
elseif (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
            String[] dependentBeans = getDependentBeans(beanName);
            Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
            for (String dependentBean : dependentBeans) {
               if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                  actualDependentBeans.add(dependentBean);
               }
            }
if (!actualDependentBeans.isEmpty()) {
               throw new BeanCurrentlyInCreationException(beanName,
                     "Bean with name '" + beanName + "' has been injected into other beans [" +
                     StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
                     "wrapped. This means that said other beans do not use the final version of the " +
                     "bean. This is often the result of over-eager type matching - consider using " +
                     "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
            }
         }
      }
   }

// Register bean as disposable.
   try {
      registerDisposableBeanIfNecessary(beanName, bean, mbd);
   }
catch (BeanDefinitionValidationException ex) {
      throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
   }

return exposedObject;
}

protected void publishEvent(Object event, ResolvableType eventType) {
   Assert.notNull(event, "Event must not be null");
   if (logger.isTraceEnabled()) {
      logger.trace("Publishing event in " + getDisplayName() + ": " + event);
   }

// Decorate event as an ApplicationEvent if necessary
   ApplicationEvent applicationEvent;
if (event instanceof ApplicationEvent) {
      applicationEvent = (ApplicationEvent) event;
   }
else {
      applicationEvent = new PayloadApplicationEvent<Object>(this, event);
      if (eventType == null) {
         eventType = ((PayloadApplicationEvent) applicationEvent).getResolvableType();
      }
   }

// Multicast right now if possible - or lazily once the multicaster is initialized
   if (this.earlyApplicationEvents != null) {
      this.earlyApplicationEvents.add(applicationEvent);
   }
else {
      getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
   }

// Publish event via parent context as well...
   if (this.parent != null) {
      if (this.parent instanceof AbstractApplicationContext) {
         ((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
      }
else {
         //发布事件，context接收到事件
         this.parent.publishEvent(event);
      }
   }
}

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
   try {
      Object beanInstance;
final BeanFactory parent = this;
      if (System.getSecurityManager() != null) {
         beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
            @Override
            public Object run() {
               return getInstantiationStrategy().instantiate(mbd, beanName, parent);
            }
         }, getAccessControlContext());
      }
else {
         //使用策略模式封装了具体的实现，实现由子类指定
         beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
      }
      BeanWrapper bw = new BeanWrapperImpl(beanInstance);
      initBeanWrapper(bw);
return bw;
   }
catch (Throwable ex) {
      throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
   }
}