维基百科对“依赖反转”相关概念的叙述

早在2004年，Martin Fowler就提出了“哪些方面的控制被反转了？”这个问题。他得出的结论是：依赖对象的获得被反转了。基于这个结论，他为控制反转创造了一个更好的名字：依赖注入。许多非凡的应用（比HelloWorld.java更加优美、更加复杂）都是由两个或多个类通过彼此的合作来实现业务逻辑，这使得每个对象都需要与其合作的对象（也就是它所依赖的对象）的引用。如果这个获取过程要靠自身实现，那么如你所见，这将导致代码高度耦合并且难以测试。

        public interface BeanFactory {
        /＊＊
          ＊ Used to dereference a {@link FactoryBean} instance and distinguish it from
          ＊ beans <i>created</i> by the FactoryBean. For example, if the bean named
          ＊ <code>myJndiObject</code> is a FactoryBean, getting <code>&myJndiObject </code>
          ＊ will return the factory, not the instance returned by the factory.
          ＊/
        String FACTORY_BEAN_PREFIX = "&";
        /＊＊
         ＊ Return an instance, which may be shared or independent, of the specified bean.
         ＊ <p>This method allows a Spring BeanFactory to be used as a replacement for the
         ＊ Singleton or Prototype design pattern. Callers may retain references to
         ＊ returned objects in the case of Singleton beans.
         ＊ <p>Translates aliases back to the corresponding canonical bean name.
         ＊ Will ask the parent factory if the bean cannot be found in this factory instance.
         ＊ ＊/
        Object getBean(String name) throws BeansException;
        /＊＊
         ＊ Return an instance, which may be shared or independent, of the specified bean.
         ＊ <p>Behaves the same as {@link #getBean(String)}, but provides a measure of type
         ＊ safety by throwing a BeanNotOfRequiredTypeException if the bean is not of the
         ＊ required type. This means that ClassCastException can' t be thrown on casting
         ＊ the result correctly, as can happen with {@link #getBean(String)}.
         ＊ <p>Translates aliases back to the corresponding canonical bean name.
         ＊ Will ask the parent factory if the bean cannot be found in this factory instance.
         ＊  ＊/
        <T> T getBean(String name, Class<T> requiredType) throws BeansException;
        /＊＊
         ＊ Return an instance, which may be shared or independent, of the specified bean.
         ＊ <p>Allows for specifying explicit constructor arguments / factory method arguments,
         ＊ overriding the specified default arguments (if any) in the bean definition.
         ＊  ＊/
        Object getBean(String name, Object... args) throws BeansException;
        /＊＊
          ＊ Does this bean factory contain a bean with the given name? More specifically,
          ＊ is {@link #getBean} able to obtain a bean instance for the given name?
          ＊ <p>Translates aliases back to the corresponding canonical bean name.
          ＊ Will ask the parent factory if the bean cannot be found in this factory instance.
          ＊/
        boolean containsBean(String name);
        /＊＊
          ＊ Is this bean a shared singleton? That is, will {@link #getBean} always
          ＊ return the same instance?
          ＊ <p>Note: This method returning <code>false</code> does not clearly indicate
          ＊ independent instances. It indicates non-singleton instances, which may correspond
          ＊ to a scoped bean as well. Use the {@link #isPrototype} operation to explicitly
        ＊ check for independent instances.
        ＊ <p>Translates aliases back to the corresponding canonical bean name.
        ＊ Will ask the parent factory if the bean cannot be found in this factory instance.
        ＊/
        boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
        /＊＊
         ＊ Is this bean a prototype? That is, will {@link #getBean} always return
         ＊ independent instances?
         ＊ <p>Note: This method returning <code>false</code> does not clearly indicate
         ＊ a singleton object. It indicates non-independent instances, which may correspond
         ＊ to a scoped bean as well. Use the {@link #isSingleton} operation to explicitly
         ＊ check for a shared singleton instance.
         ＊ <p>Translates aliases back to the corresponding canonical bean name.
         ＊ Will ask the parent factory if the bean cannot be found in this factory instance.
         ＊/
        boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
        /＊＊
         ＊ Check whether the bean with the given name matches the specified type.
         ＊ More specifically, check whether a {@link #getBean} call for the given name
         ＊ would return an object that is assignable to the specified target type.
         ＊ <p>Translates aliases back to the corresponding canonical bean name.
         ＊ Will ask the parent factory if the bean cannot be found in this factory instance.
         ＊/
        boolean isTypeMatch(String name, Class targetType) throws NoSuchBeanDefinitionException;
        /＊＊
         ＊ Determine the type of the bean with the given name. More specifically,
         ＊ determine the type of object that {@link #getBean} would return for the given name.
         ＊ <p>For a {@link FactoryBean}, return the type of object that the FactoryBean creates,
         ＊ as exposed by {@link FactoryBean#getObjectType()}.
         ＊ <p>Translates aliases back to the corresponding canonical bean name.
         ＊ Will ask the parent factory if the bean cannot be found in this factory instance.
         ＊/
        Class getType(String name) throws NoSuchBeanDefinitionException;
        /＊＊
         ＊ Return the aliases for the given bean name, if any.
         ＊ All of those aliases point to the same bean when used in a {@link #getBean} call.
         ＊ <p>If the given name is an alias, the corresponding original bean name
         ＊ and other aliases (if any) will be returned, with the original bean name
         ＊ being the first element in the array.
         ＊ <p>Will ask the parent factory if the bean cannot be found in this factory instance.
         ＊/
        String[] getAliases(String name);
       }

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

        ClassPathResource res = new ClassPathResource("beans.xml"); DefaultListableBeanFactory
            factory = new DefaultListableBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
        reader.loadBeanDefinitions(res);

        ClassPathResource res = new ClassPathResource("beans.xml");

        public class FileSystemXmlApplicationContext extends AbstractXmlApplicationContext {
        public FileSystemXmlApplicationContext() {
        }
        public FileSystemXmlApplicationContext(ApplicationContext parent) {
            super(parent);
        }
        //这个构造函数的configLocation包含的是BeanDefinition所在的文件路径。
        public FileSystemXmlApplicationContext(String configLocation) throws BeansException {
            this(new String[] {configLocation}, true, null);
        }
        //这个构造函数允许configLocation包含多个BeanDefinition的文件路径。
        public FileSystemXmlApplicationContext(String[] configLocations) throws BeansException {
            this(configLocations, true, null);
        }
        /＊＊
        ＊这个构造函数在允许configLocation包含多个BeanDefinition的文件路径的同时，
        ＊还允许指定自己的双亲IoC容器。
        ＊/
        public FileSystemXmlApplicationContext(String[] configLocations, ApplicationContext
            parent) throws BeansException {
            this(configLocations, true, parent);
        }
        public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh)
            throws BeansException {
            this(configLocations, refresh, null);
        }
        /＊＊
        ＊在对象的初始化过程中，调用refresh函数载入BeanDefinition，这个refresh
        ＊启动了BeanDefinition的载入过程，我们会在下面进行详细分析。
        ＊/
        public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh,
            ApplicationContext parent)
                throws BeansException {
            super(parent);
            setConfigLocations(configLocations);
            if (refresh) {
                refresh();
            }
        }
        /＊＊
        ＊这是应用于文件系统中Resource的实现，通过构造一个FileSystemResource来
        ＊得到一个在文件系统中定位的BeanDefinition。
        ＊/
        /＊＊
        ＊这个getResourceByPath是在BeanDefinitionReader的loadBeanDefintion中被调用的。
        ＊loadBeanDefintion采用了模板模式，具体的定位实现实际上是由各个子类完成的。
        ＊/
        protected Resource getResourceByPath(String path) {
            if (path ! = null && path.startsWith("/")) {
                path = path.substring(1);
            }
            return new FileSystemResource(path);
        }
        }

        protected final void refreshBeanFactory() throws BeansException {
            //这里判断，如果已经建立了BeanFactory，则销毁并关闭该BeanFactory。
            if (hasBeanFactory()) {
                destroyBeans();
                closeBeanFactory();
            }
            //这里是创建并设置持有的DefaultListableBeanFactor的地方。
            //同时调用loadBeanDefinitions再载入BeanDefinitione的信息。
            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 XML document
            for " + getDisplayName(), ex);
            }
        }
        /＊＊
        ＊这就是在上下文中创建DefaultListableBeanFactory的地方，而getInternalParentBeanFactory()的
        ＊具体实现可以参看AbstractApplicationContext中的实现，会根据容器已有的双亲IoC容器的信息来
        ＊生成DefaultListableBeanFactory的双亲IoC容器。
        ＊/
        protected DefaultListableBeanFactory createBeanFactory() {
        return new DefaultListableBeanFactory(getInternalParentBeanFactory());
        }
        /＊＊
        ＊这里是使用BeanDefinitionReader载入Bean定义的地方，因为允许有多种载入方式，
        ＊虽然用得最多的是XML定义的形式，这里通过一个抽象函数把具体的实现委托给子类来完成。
        ＊/
        protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
            throws IOException, BeansException;
        public int loadBeanDefinitions(String location, Set actualResources) throws
            BeanDefinitionStoreException {
            //这里取得ResourceLoader，使用的是DefaultResourceLoader。
            ResourceLoader resourceLoader = getResourceLoader();
            if (resourceLoader == null) {
                throw new BeanDefinitionStoreException(
                          "Cannot import bean definitions from location [" + location + "]：
            no ResourceLoader available");
            }
        /＊＊
        ＊这里对Resource的路径模式进行解析，比如我们设定的各种Ant格式的路径定义，得到需要的
        ＊Resource集合，这些Resource集合指向我们已经定义好的BeanDefinition信息，可以是多个文件。
        ＊/
            if (resourceLoader instanceof ResourcePatternResolver) {
                // Resource pattern matching available.
                try {
    // 调用DefaultResourceLoader的getResource完成具体的Resource定位。
                Resource[] resources = ((ResourcePatternResolver) resourceLoader).
        getResources(location);
                int loadCount = loadBeanDefinitions(resources);
                if (actualResources ! = null) {
                      for (int i = 0; i < resources.length; i++) {
                          actualResources.add(resources[i]);
                      }
                }
                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.
            // 调用DefaultResourceLoader的getResource完成具体的Resource定位。
            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;
        }
    }
    //对于取得Resource的具体过程，我们可以看看DefaultResourceLoader是怎样完成的：
    public Resource getResource(String location) {
        Assert.notNull(location, "Location must not be null");
        //这里处理带有classpath标识的Resource。
        if (location.startsWith(CLASSPATH_URL_PREFIX)) {
            return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.
        length()), getClassLoader());
        }
        else {
            try {
                // Try to parse the location as a URL...
                // 这里处理URL标识的Resource定位。
                URL url = new URL(location);
                return new UrlResource(url);
            }
            catch (MalformedURLException ex) {
                // No URL -> resolve as resource path.
                /＊＊
                ＊如果既不是classpath，也不是URL标识的Resource定位，则把getResource的重任
                ＊交给getResourceByPath，这个方法是一个protected方法，默认的实现是得到一
                ＊个ClassPathContextResource，这个方法常常会用子类来实现。
                ＊/
                    return getResourceByPath(location);
                }
            }
        }

        protected Resource getResourceByPath(String path) {
            if (path ! = null && path.startsWith("/")) {
                path = path.substring(1);
            }
            return new FileSystemResource(path);
        }

        public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh,
            ApplicationContext parent)
                throws BeansException {
            super(parent);
            setConfigLocations(configLocations);
            //这里调用容器的refresh，是载入BeanDefinition的入口。
            if (refresh) {
                refresh();
            }
        }

        public void refresh() throws BeansException, IllegalStateException {
            synchronized (this.startupShutdownMonitor) {
                // Prepare this context for refreshing.
                prepareRefresh();
                // Tell the subclass to refresh the internal bean factory.
                // 这里是在子类中启动refreshBeanFactory()的地方。
                ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
                // Prepare the Bean Factory for use in this context.
                prepareBeanFactory(beanFactory);
                try {
                    // Allows post-processing of the bean factory in context subclasses.
                    postProcessBeanFactory(beanFactory);
                    // Invoke factory processors registered as beans in the context.
                    invokeBeanFactoryPostProcessors(beanFactory);
                    // Register bean processors that intercept bean creation.
                    registerBeanPostProcessors(beanFactory);
                    // Initialize message source for this context.
                    initMessageSource();
                    // Initialize event multicaster for this context.
                    initApplicationEventMulticaster();
                    // Initialize other special beans in specific context subclasses.
                    onRefresh();
                    // Check for listener beans and register them.
                    registerListeners();
                    // Instantiate all remaining (non-lazy-init) singletons.
                    finishBeanFactoryInitialization(beanFactory);
                    // Last step: publish corresponding event.
                    finishRefresh();
                }
                catch (BeansException ex) {
                    // Destroy already created singletons to avoid dangling resources.
                    destroyBeans();
                    // Reset ' active' flag.
                    cancelRefresh(ex);
                    // Propagate exception to caller.
                    throw ex;
                }
            }
        }

        protected final void refreshBeanFactory() throws BeansException {
            if (hasBeanFactory()) {
                destroyBeans();
                closeBeanFactory();
            }
            try {
            //创建IoC容器，这里使用的是DefaultListableBeanFactory。
                DefaultListableBeanFactory beanFactory = createBeanFactory();
                beanFactory.setSerializationId(getId());
                customizeBeanFactory(beanFactory);
                //启动对BeanDefintion的载入。
                loadBeanDefinitions(beanFactory);
                synchronized (this.beanFactoryMonitor) {
                    this.beanFactory = beanFactory;
                }
            }
            catch (IOException ex) {
                throw new ApplicationContextException("I/O error parsing XML document
            for " + getDisplayName(), ex);
            }
        }

        public abstract class AbstractXmlApplicationContext extends
            AbstractRefreshableConfigApplicationContext {
        public AbstractXmlApplicationContext() {
        }
        public AbstractXmlApplicationContext(ApplicationContext parent) {
            super(parent);
        }
        //这里是实现loadBeanDefinitions的地方。
        protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
            throws IOException {
            // Create a new XmlBeanDefinitionReader for the given BeanFactory.
            /＊＊
            ＊创建XmlBeanDefinitionReader，并通过回调设置到BeanFactory中去，
            ＊创建BeanFactory的过程可以参考上文对编程式使用IoC容器的相关分析，这里和前面一样，
            ＊使用的也是DefaultListableBeanFactory。
            ＊/
            XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader
            (beanFactory);
            /＊＊
            ＊Configure the bean definition reader with this context' s
            ＊resource loading environment.
            ＊/
            /＊＊
            ＊这里设置XmlBeanDefinitionReader，为XmlBeanDefinitionReader
            ＊配置ResourceLoader，因为DefaultResourceLoader是父类，所以this可以直接被使用。
            ＊/
            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.
            ＊/
        // 这是启动Bean定义信息载入的过程。
            initBeanDefinitionReader(beanDefinitionReader);
            loadBeanDefinitions(beanDefinitionReader);
        }
        protected void initBeanDefinitionReader(XmlBeanDefinitionReader beanDefinitionReader) {
        }

        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);
            }
        }
        protected Resource[] getConfigResources() {
            return null;
        }
       }

        public int loadBeanDefinitions(Resource[] resources) throws
            BeanDefinitionStoreException {
            //如果Resource为空，则停止BeanDefinition的载入。
            /＊＊
            ＊然后启动载入BeanDefinition的过程，这个过程会遍历整个Resource集合所包含的
            ＊BeanDefinition信息。
            ＊/
            Assert.notNull(resources, "Resource array must not be null");
            int counter = 0;
            for (int i = 0; i < resources.length; i++) {
                counter += loadBeanDefinitions(resources[i]);
            }
            return counter;
        }

        //这里是调用的入口。
        public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
            return loadBeanDefinitions(new EncodedResource(resource));
        }
        //这里是载入XML形式的BeanDefinition的地方。
        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 recursive loading of " + encodedResource + " - check
            your import definitions! ");
            }
            //这里得到XML文件，并得到IO的InputSource准备进行读取。
            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.set(null);
                }
            }
        }
        //具体的读取过程可以在doLoadBeanDefinitions方法中找到。
        //这是从特定的XML文件中实际载入BeanDefinition的地方。
        protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
                throws BeanDefinitionStoreException {
            try {
                int validationMode = getValidationModeForResource(resource);
                /＊＊
                ＊这里取得XML文件的Document对象，这个解析过程是由documentLoader完成的，
                ＊这个documentLoader是DefaultDocumentLoader，在定义documentLoader的地方创建。
                ＊/
                Document doc = this.documentLoader.loadDocument(
                        inputSource, getEntityResolver(), this.errorHandler, validationMode,
            isNamespaceAware());
                /＊＊
                ＊这里启动的是对BeanDefinition解析的详细过程，这个解析会使用到Spring的Bean
                ＊配置规则，是我们下面需要详细关注的地方。
                ＊/
                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 {
            // Read document based on new BeanDefinitionDocumentReader SPI.
            // 这里得到BeanDefinitionDocumentReader来对xml的BeanDefinition进行解析。
            BeanDefinitionDocumentReader documentReader =
            createBeanDefinitionDocumentReader();
            int countBefore = getRegistry().getBeanDefinitionCount();
            // 具体的解析过程在这个registerBeanDefinitions中完成。
            documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
            return getRegistry().getBeanDefinitionCount() - countBefore;
        }

        protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {
            return BeanDefinitionDocumentReader.class.cast(BeanUtils.instantiateClass
            (this.documentReaderClass));
        }
          //这样，得到了documentReader以后，为具体的Spring Bean的解析过程准备好了数据。
          /＊＊
          ＊这里是处理BeanDefinition的地方，具体的处理是委托给BeanDefinitionParserDelegate
          ＊来完成的，ele对应于我们的Spring BeanDefinition中定义的xml元素。
          ＊/
        protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate
            delegate) {
            /＊ BeanDefinitionHolder是BeanDefinition对象的封装类，封装了BeanDefinition，
            ＊Bean的名字和别名。用它来完成向IoC容器注册。得到这个BeanDefinitionHolder实际上就意
            ＊味着获得了BeanDefinition，是通过BeanDefinitionParserDelegate对XML元素的信息按照
            ＊Spring的Bean规则进行解析得到的。
            ＊/
            BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
            if (bdHolder ! = null) {
                bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
                try {
                    // 这里是向IoC容器注册解析得到的BeanDefinition的地方。
                    BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder,
                    getReaderContext().getRegistry());
                }
                catch (BeanDefinitionStoreException ex) {
                    getReaderContext().error("Failed to register bean definition with
                    name ' " + bdHolder.getBeanName() + "' ", ele, ex);
                }
                // 在BeanDefinition向IoC容器注册完以后，发送消息。
                getReaderContext().fireComponentRegistered(new BeanComponentDefinition
            (bdHolder));
            }
        }

        public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition
            containingBean) {
            //这里取得在<bean>元素中定义的id、name和aliase属性的值。
            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, BEAN_NAME_
            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);
            }
            //这个方法会引发对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;
                  }

        public AbstractBeanDefinition parseBeanDefinitionElement(
                Element ele, String beanName, BeanDefinition containingBean) {
            this.parseState.push(new BeanEntry(beanName));
            /＊＊
            ＊这里只读取定义的<bean>中设置的class名字，然后载入到BeanDefinition中去，
            ＊只是做个记录，并不涉及对象的实例化过程，对象的实例化实际上是在依赖注入时完成的。
            ＊/
            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对象，为Bean定义信息的载入做准备。
                AbstractBeanDefinition bd = createBeanDefinition(className, parent);
                //这里对当前的Bean元素进行属性解析，并设置description的信息。
                parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
                bd.setDescription(DomUtils.getChildElementValueByTagName(ele,
            DESCRIPTION_ELEMENT));
                //从名字可以清楚地看到，这里是对各种<bean>元素的信息进行解析的地方。
                parseMetaElements(ele, bd);
                parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
                parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
                //解析<bean>的构造函数设置。
                parseConstructorArgElements(ele, bd);
                //解析<bean>的property设置。
                parsePropertyElements(ele, bd);
                parseQualifierElements(ele, bd);
                bd.setResource(this.readerContext.getResource());
                bd.setSource(extractSource(ele));
                return bd;
            }
       /＊＊
       ＊下面这些异常是我们在配置bean出现问题时经常可以看到的，原来是在这里抛出的，这些检查是在
       ＊createBeanDefinition时进行的，会检查bean的class设置是否正确，比如这个类是不是能找到。
       ＊/
            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元素的property子元素集合进行解析。
        public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
            //遍历所有bean元素下定义的property元素。
            NodeList nl = beanEle.getChildNodes();
            for (int i = 0; i < nl.getLength(); i++) {
                Node node = nl.item(i);
                if (node instanceof Element && DomUtils.nodeNameEquals(node, PROPERTY_
            ELEMENT)) {
                    //在判断是property元素后对该property元素进行解析的过程。
                    parsePropertyElement((Element) node, bd);
                }
            }
        }
        public void parsePropertyElement(Element ele, BeanDefinition bd) {
            //这里取得property的名字。
            String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
            if (! StringUtils.hasLength(propertyName)) {
                error("Tag ' property' must have a ' name' attribute", ele);
                return;
            }
            this.parseState.push(new PropertyEntry(propertyName));
            try {
                /＊＊
                ＊如果同一个bean中已经有同名property的存在，则不进行解析，直接返回。也就是说，
                ＊如果在同一个bean中有同名的property设置，那么起作用的只是第一个。
                ＊/
                if (bd.getPropertyValues().contains(propertyName)) {
                    error("Multiple ' property' definitions for property ' " +
            propertyName + "' ", ele);
                    return;
                }
                /＊＊
                ＊这里是解析property值的地方，返回的对象对应对Bean定义的property属性
                ＊设置的解析结果，这个解析结果会封装到PropertyValue对象中，然后设置到
                ＊BeanDefinitionHolder中去。
                ＊/
                Object val = parsePropertyValue(ele, bd, propertyName);
                PropertyValue pv = new PropertyValue(propertyName, val);
                parseMetaElements(ele, pv);
                pv.setSource(extractSource(ele));
                bd.getPropertyValues().addPropertyValue(pv);
            }
        finally {
            this.parseState.pop();
        }
    }
    //这里取得property元素的值，也许是一个list或其他。
    public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {
        String elementName = (propertyName ! = null) ?
                          "<property> element for property ' " + propertyName + "' " ：
                          "<constructor-arg> element";
        // Should only have one child element: ref, value, list, etc.
        NodeList nl = ele.getChildNodes();
        Element subElement = null;
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            if (node instanceof Element && ! DomUtils.nodeNameEquals(node, DESCRIPTION_
            ELEMENT) &&
                    !DomUtils.nodeNameEquals(node, META_ELEMENT)) {
                // Child element is what we' re looking for.
                if (subElement ! = null) {
                    error(elementName + " must not contain more than one sub-element",
                    ele);
                }
                else {
                    subElement = (Element) node;
                }
            }
        }
        //这里判断property的属性，是ref还是value，不允许同时是ref和value。
        boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
        boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
        if ((hasRefAttribute && hasValueAttribute) ——
                ((hasRefAttribute —— hasValueAttribute) && subElement ! = null)) {
                error(elementName +
                    " is only allowed to contain either ' ref' attribute OR ' value'
                    attribute OR sub-element", ele);
        }
        //如果是ref，创建一个ref的数据对象RuntimeBeanReference，这个对象封装了ref的信息。
        if (hasRefAttribute) {
            String refName = ele.getAttribute(REF_ATTRIBUTE);
            if (! StringUtils.hasText(refName)) {
                error(elementName + " contains empty ' ref' attribute", ele);
            }
            RuntimeBeanReference ref = new RuntimeBeanReference(refName);
            ref.setSource(extractSource(ele));
            return ref;
        } //如果是value，创建一个它的数据对象TypedStringValue，这个对象封装了value的信息。
        else if (hasValueAttribute) {
            TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute
        (VALUE_ATTRIBUTE));
            valueHolder.setSource(extractSource(ele));
            return valueHolder;
        } //如果还有子元素，触发对子元素的解析。
        else if (subElement ! = null) {
            return parsePropertySubElement(subElement, bd);
        }
        else {
            // Neither child element nor "ref" or "value" attribute found.
            error(elementName + " must specify a ref or value", ele);
                return null;
            }
        }

        public Object parsePropertySubElement(Element ele, BeanDefinition bd, String
            defaultValueType) {
            if (! isDefaultNamespace(ele.getNamespaceURI())) {
                return parseNestedCustomElement(ele, bd);
            }
            else if (DomUtils.nodeNameEquals(ele, BEAN_ELEMENT)) {
                BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);
                if (nestedBd ! = null) {
                    nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);
                }
                return nestedBd;
            }
            else if (DomUtils.nodeNameEquals(ele, REF_ELEMENT)) {
                // A generic reference to any name of any bean.
                String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
                boolean toParent = false;
                if (! StringUtils.hasLength(refName)) {
                    // A reference to the id of another bean in the same XML file.
                    refName = ele.getAttribute(LOCAL_REF_ATTRIBUTE);
                    if (! StringUtils.hasLength(refName)) {
                          // A reference to the id of another bean in a parent context.
                          refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);
                          toParent = true;
                          if (! StringUtils.hasLength(refName)) {
                              error("' bean' , ' local' or ' parent' is required for <ref>
                              element", ele);
                              return null;
                          }
                    }
                }
                if (! StringUtils.hasText(refName)) {
                    error("<ref> element contains empty target attribute", ele);
                    return null;
                }
                RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);
                ref.setSource(extractSource(ele));
                return ref;
            }
            else if (DomUtils.nodeNameEquals(ele, IDREF_ELEMENT)) {
                return parseIdRefElement(ele);
            }
            else if (DomUtils.nodeNameEquals(ele, VALUE_ELEMENT)) {
                return parseValueElement(ele, defaultValueType);
            }
            else if (DomUtils.nodeNameEquals(ele, NULL_ELEMENT)) {
                // It' s a distinguished null value. Let' s wrap it in a TypedStringValue
                // object in order to preserve the source location.
                TypedStringValue nullHolder = new TypedStringValue(null);
                nullHolder.setSource(extractSource(ele));
                return nullHolder;
            }
            else if (DomUtils.nodeNameEquals(ele, ARRAY_ELEMENT)) {
                return parseArrayElement(ele, bd);
            }
            else if (DomUtils.nodeNameEquals(ele, LIST_ELEMENT)) {
                return parseListElement(ele, bd);
            }
            else if (DomUtils.nodeNameEquals(ele, SET_ELEMENT)) {
                return parseSetElement(ele, bd);
            }
            else if (DomUtils.nodeNameEquals(ele, MAP_ELEMENT)) {
                return parseMapElement(ele, bd);
            }
            else if (DomUtils.nodeNameEquals(ele, PROPS_ELEMENT)) {
                return parsePropsElement(ele);
            }
            else {
                error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
                return null;
            }
        }

        public List parseListElement(Element collectionEle, BeanDefinition bd) {
            String defaultElementType = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE);
            NodeList nl = collectionEle.getChildNodes();
            ManagedList<Object> target = new ManagedList<Object>(nl.getLength());
            target.setSource(extractSource(collectionEle));
            target.setElementTypeName(defaultElementType);
            target.setMergeEnabled(parseMergeAttribute(collectionEle));
            //具体的List元素的解析过程。
            parseCollectionElements(nl, target, bd, defaultElementType);
            return target;
        }
        protected void parseCollectionElements(
                NodeList elementNodes, Collection<Object> target, BeanDefinition bd,
            String defaultElementType) {
            //遍历所有的元素节点，并判断其类型是否为Element。
            for (int i = 0; i < elementNodes.getLength(); i++) {
                Node node = elementNodes.item(i);
                if (node instanceof Element && ! DomUtils.nodeNameEquals(node, DESCRIPTION_
            ELEMENT)) {
            /＊＊
            ＊加入到target中，target是一个ManagedList，同时触发对下一层子元素的解析过程，
            ＊这是一个递归调用。
            ＊/
                    target.add(parsePropertySubElement((Element) node, bd, defaultElement
                    Type));
                }
            }
        }

        /＊＊ Map of bean definition objects, keyed by bean name ＊/
        private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap
            <String, BeanDefinition>();

        //---------------------------------------------------------------------
        // Implementation of BeanDefinitionRegistry interface.
        //---------------------------------------------------------------------
        public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
                throws BeanDefinitionStoreException {
            Assert.hasText(beanName, "' beanName' 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，保证数据的一致性。
            synchronized (this.beanDefinitionMap) {
            /＊＊
            ＊这里检查是不是有相同名字的BeanDefinition已经在IoC容器中注册了，如果有
            ＊相同名字的BeanDefinition，但又不允许覆盖，那么抛出异常。
            ＊/
                Object oldBeanDefinition = this.beanDefinitionMap.get(beanName);
                if (oldBeanDefinition ! = null) {
                    if (! this.allowBeanDefinitionOverriding) {
                          throw new BeanDefinitionStoreException(
                          beanDefinition.getResource Description(), beanName,
                                "Cannot register bean definition [" + beanDefinition + "]
                                  for bean ' " + beanName +
                                "' : There is already [" + oldBeanDefinition + "] bound.");
                    }
                    else {
                          if (this.logger.isInfoEnabled()) {
                              this.logger.info("Overriding bean definition for bean ' " +
                              beanName +"' : replacing [" + oldBeanDefinition + "] with [" +
                              beanDefinition + "]");
                          }
                    }
                }
        /＊＊
        ＊这是正常注册BeanDefinition的过程，把Bean的名字存入到beanDefinitionNames的同时，
        ＊把beanName作为Map的key，把beanDefinition作为value存入到IoC容器持有的
        ＊beanDefinitionMap中去。
        ＊/
                else {
                this.beanDefinitionNames.add(beanName);
                this.frozenBeanDefinitionNames = null;
            }
            this.beanDefinitionMap.put(beanName, beanDefinition);
            resetBeanDefinition(beanName);
        }
    }