1.2 XmlBeanFactory的实例化

　　源代码分析，是一件既痛苦又快乐的事情，看别人写的代码是通过的，但当你能够看明白的时候，相信快乐也会随之而来，为了减少痛苦，更快的带来快乐，

　　本文以spring框架的XmlBeanFactory为入手点进行分析

首先来打开该类的代码，我们将看到如下代码：

 public class XmlBeanFactory extends DefaultListableBeanFactory {

    private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);

    public XmlBeanFactory(Resource resource) throws BeansException {
        this(resource, null);
    }

    public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
        super(parentBeanFactory);
        this.reader.loadBeanDefinitions(resource);
    }

 }

这个类的代码很简单，一个成员对象加两个构造函数，从这里我们可以看出，最重要的地方在于最后一个构造函数：

 public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
         super(parentBeanFactory);
         this.reader.loadBeanDefinitions(resource);
     }

第一句就是将父亲工厂交给父类的构造函数，

　　实际上最后也就是把父工厂保存到类的parentBeanFactory成员对象中，这个对象是在AbstractBeanFactory抽象类中定义的，而这个父工厂也会一直传递到该抽象类进行保存。

　　第二句就是整个类中最重要的地方了，顾名思义，它的目的是通过XmlBeanDefinitionReader这个XML的Reader从资源resource中（也就是你的配置文件）读取bean的定义。

　　接下来我们打开XmlBeanDefinitionReader的loadBeanDefinitions方法，我们可看到在这个方法里代码就一行，调用了一个同名不同参的方法，而参数是EncodedResource的一个实例，这个类实际上是Resource的一个包装类，用来保存资源的Encode的，

 public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
         return loadBeanDefinitions(new EncodedResource(resource));
     }

那接下来我们再看被调用的loadBeanDefinitions方法，

 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<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
         if (currentResources == null) {
             currentResources = new HashSet<EncodedResource>(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();
             }
         }
     }

这个方法里最主要的部分就是：

　　

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

这里的目的是将资源包装成一个InputSource，连同Resource作为参数传递到doLoadBeanDefinitions方法

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

　　很遗憾,这个类没有什么实际作为,只有一些对异常的处理.把解析的逻辑委托给了doLoadDocument这个方法

然后调用registerBeanDefinitions方法,注册Bean的信息

     protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
         return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
                 getValidationModeForResource(resource), isNamespaceAware());
     }

就是为了将资源解释成为Document对象,这里不做详细解释，不了解的话请去看看关于JAXP的介绍。

 public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
             ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {

         DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
         if (logger.isDebugEnabled()) {
             logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]");
         }
         DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
         return builder.parse(inputSource);
     }

来看看registerBeanDefinitions的实现 

 

 public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
         BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
         documentReader.setEnvironment(this.getEnvironment());
         int countBefore = getRegistry().getBeanDefinitionCount();
         documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
         return getRegistry().getBeanDefinitionCount() - countBefore;
     }

　　在这里, 有一个BeanDefinitionDocumentReader接口, 实际上Spring对它有一个默认的实现类叫DefaultBeanDefinitionDocumentReader, 来看看它的家族

BeanDefinitionDocumentReader只有2个方法 ,

registerBeanDefinitions就是其中一个

 public interface BeanDefinitionDocumentReader {

     /**
      * Set the Environment to use when reading bean definitions.
      * <p>Used for evaluating profile information to determine whether a
      * {@code <beans/>} document/element should be included or ignored.
      */
     void setEnvironment(Environment environment);

     /**
      * Read bean definitions from the given DOM document and
      * register them with the registry in the given reader context.
      * @param doc the DOM document
      * @param readerContext the current context of the reader
      * (includes the target registry and the resource being parsed)
      * @throws BeanDefinitionStoreException in case of parsing errors
      */
     void registerBeanDefinitions(Document doc, XmlReaderContext readerContext)
             throws BeanDefinitionStoreException;

 }

　　该方法需要两个参数, 一个是Document模型,这个应该是我们读取配置文件获取到的, 另一个是XmlReaderContext对象, 我们在上面方法中看到是通过createReaderContext(resource)得到的, 那就看看具体如何得到

 public XmlReaderContext createReaderContext(Resource resource) {
         return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
                 this.sourceExtractor, this, getNamespaceHandlerResolver());
     }

　　能过构造函数new出来的, 且有一个重要参数resource 
再继续来看DefaultBeanDefinitionDocumentReader对BeanDefinitionDocumentReader的registerBeanDefinitions方法实现

 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) {
         String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
         if (StringUtils.hasText(profileSpec)) {
             Assert.state(this.environment != null, "Environment must be set for evaluating profiles");
             String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                     profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
             if (!this.environment.acceptsProfiles(specifiedProfiles)) {
                 return;
             }
         }

         // 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;
         this.delegate = createDelegate(this.readerContext, root, parent);

         preProcessXml(root);
         parseBeanDefinitions(root, this.delegate);
         postProcessXml(root);

         this.delegate = parent;
     }

嘿嘿, 开始解析Dom了哦, 其中主要是parseBeanDefinitions方法, 来看看具体是如何解析的

这里创建了一个XmlBeanDefinitionParser接口的实现，这个接口的具体类是DefaultXmlBeanDefinitionParser，这个接口很简单，只有registerBeanDefinitions一个方法，这个方法的作用也很明了，就是用来注册Bean的定义的，所以说类和方法的名字一定要起得有意义，这样可以让人一看就大概了解其作用，减少了很多阅读代码的痛苦。废话不多说，我们打开DefaultXmlBeanDefinitionParser的registerBeanDefinitions方法，这个类就是解释XML配置文件的核心类了，打开registerBeanDefinitions方法后我们看到如下代码：

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

　　看到了吧, 循环解析Domcument节点 
parseDefaultElement方法和delegate的parseCustomElement方法 
先来看parseDefaultElement方法

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

看到这就很清楚了, 就是根据节点的名称作不同解析, 如我们Spring配置文件中常有以下几种配置

<import resource="classpath:xxx" />
<bean id="car" class="entity.CarFactoryBean">
        <property name="carInfo" value="超级跑车,400,2000000" />
    </bean>

对<import>节点, 调用importBeanDefinitionResource方法解析, 此方法中, 又回到第一步读取配置文件并解析. 如此递归循环.

...
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
          importBeanDefinitionResource(ele);
}
...

对<alias>节点, 调用processAliasRegistration进行别名解析

...
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
            processAliasRegistration(ele);
        }
...

我们主要看对<bean>节点调用processBeanDefinition进行解析

...
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
            processBeanDefinition(ele, delegate);
        }
...

processBeanDefinition:

 protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
 2         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));
         }
     }

　　嘿嘿, 又用到delegate对象了, 且调用它的parseBeanDefinitionElement方法, 返回一个BeanDefinitionHolder, 进去看它的parseBeanDefinitionElement方法

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

parseBeanDefinitionElement

 public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
         String id = ele.getAttribute(ID_ATTRIBUTE);
         String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
         //解析id, name等属性,
         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");
             }
         }
         //并验证beanName是否唯一, 并将beanName保存在aliases中
         if (containingBean == null) {
             checkNameUniqueness(beanName, aliases, ele);
         }
         //解析bean定义本身，而不考虑名称或别名。可能返回null，如果bean定义的解析过程中出现的问题
         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;
     }

　　可以看到, 在BeanDefinitionHolder中保存了BeanDefinition的定义 
OK, 重头戏开始, 最经典的部分出现了, 请看parseBeanDefinitionElement方法

 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);
             }
             AbstractBeanDefinition bd = createBeanDefinition(className, parent);

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

　　在这个方法中, 解析了bean的所有属性, 有最常用的class, scope, lazy-init等等. 并返回一个AbstractBeanDefinition实例. 至于具体怎么解析, 就只能进一步跟踪了, 不过既然到了这一步, 已经明白了它的基本原理, 具体实现就不作介绍

 public static AbstractBeanDefinition createBeanDefinition(
             String parentName, String className, ClassLoader classLoader) throws ClassNotFoundException {

         GenericBeanDefinition bd = new GenericBeanDefinition();
         bd.setParentName(parentName);
         if (className != null) {
             if (classLoader != null) {
                 bd.setBeanClass(ClassUtils.forName(className, classLoader));
             }
             else {
                 bd.setBeanClassName(className);
             }
         }
         return bd;
     }

　　这一步将节点解析成BeanDefinitionHolder对象, 再看看如何注册, 回到DefaultBeanDefinitionDocumentReader的processBeanDefinition方法 
看到对解析到的bdHolder对象又做了decorateBeanDefinitionIfRequired操作, 来看看实现

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

decorateBeanDefinitionIfRequired 

 public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
             Element ele, BeanDefinitionHolder definitionHolder, BeanDefinition containingBd) {

         BeanDefinitionHolder finalDefinition = definitionHolder;

         // Decorate based on custom attributes first.
         NamedNodeMap attributes = ele.getAttributes();
         for (int i = 0; i < attributes.getLength(); i++) {
             Node node = attributes.item(i);
             finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
         }

         // Decorate based on custom nested elements.
         NodeList children = ele.getChildNodes();
         for (int i = 0; i < children.getLength(); i++) {
             Node node = children.item(i);
             if (node.getNodeType() == Node.ELEMENT_NODE) {
                 finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
             }
         }
         return finalDefinition;
     }

 这里关键就2行代码,主要是做一些合法性验证,比如 文件头,语法,属性的合法性,由于代码过长不一一解释,代码如下

 public BeanDefinitionHolder decorateIfRequired(
             Node node, BeanDefinitionHolder originalDef, BeanDefinition containingBd) {

         String namespaceUri = getNamespaceURI(node);
         if (!isDefaultNamespace(namespaceUri)) {
             NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
             if (handler != null) {
                 return handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
             }
             else if (namespaceUri != null && namespaceUri.startsWith("http://www.springframework.org/")) {
                 error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);
             }
             else {
                 // A custom namespace, not to be handled by Spring - maybe "xml:...".
                 if (logger.isDebugEnabled()) {
                     logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");
                 }
             }
         }
         return originalDef;
     }

回到DefaultBeanDefinitionDocumentReade.processBeanDefinition这个方法 只行完delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);之后

接着调用了BeanDefinitionReaderUtils的registerBeanDefinition方法注册bdHolder, 来看看如何实现的

     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 aliase : aliases) {
                 registry.registerAlias(beanName, aliase);
             }
         }
     }

 　　看吧, 又调用了BeanDefinitionRegistry的registerBeanDefinition方法, 跟踪之 (这个要看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);
             }
         }

         synchronized (this.beanDefinitionMap) {
             BeanDefinition oldBeanDefinition = this.beanDefinitionMap.get(beanName);
             if (oldBeanDefinition != null) {
                 if (!this.allowBeanDefinitionOverriding) {
                     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.frozenBeanDefinitionNames = null;
             }
             this.beanDefinitionMap.put(beanName, beanDefinition);
         }

         resetBeanDefinition(beanName);
     }

　　这里, 看到了一个最最重要的对象就是beanDefinitionMap, 这个map存放了所有的bean对象, 和我们通常讲的容器概念最为接近, getBean时实际是也是从这里领取对象, 相同的还有一个beanDefinitionNames, 但这个只保存bean的名称 
完成上面之后, 还有一步操作beanFactory.registerAlias(beanName, aliases[i]); 
这个实现实际是上AbstractBeanFactory抽象类所定义的

是不是特兴奋, 已经揭开它神秘的面纱了 
定义 -> 定位 -> 装载 -> 注册 这几步已经完成了, 以后继续看Spring是如何创建bean及实例化的

多数内容来自:http://leayer.iteye.com/blog/806016