維基百科對“依賴反轉”相關概念的敘述

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