Spring Ioc 是怎么加载bean的

你的名字 2022-05-27 04:48 151阅读 0赞

我的代码中有这么一句：

ApplicationContext ctx=new ClassPathXmlApplicationContext("spring-mybatis.xml");

今天，我想弄懂spring是怎么加载.xml文件，然后找到bean的。

首先点进去，看看ClassPathXmlApplicationContext的源码

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
                throws BeansException {
    
            super(parent);
            setConfigLocations(configLocations);
            if (refresh) {
                refresh();
            }
        }

这有个setConfigLocations(configLocations);和refresh();，先看看setConfigLocations(configLocations);

...
    
    private String[] configLocations;
    
    
    ...
    
    public void setConfigLocations(String... locations) {
            if (locations != null) {
                Assert.noNullElements(locations, "Config locations must not be null");
                this.configLocations = new String[locations.length];
                for (int i = 0; i < locations.length; i++) {
                    this.configLocations[i] = resolvePath(locations[i]).trim();
                }
            }
            else {
                this.configLocations = null;
            }
        }

从代码上看，这个configLocations是一个变量，存放xml文件的名称，我传进来的spring-mybatis.xml就赋给了configLocations, 既然configLocations只是保存变量，没其他信息，就看看refresh();

@Override
        public void refresh() throws BeansException, IllegalStateException {
            synchronized (this.startupShutdownMonitor) {
                // Prepare this context for refreshing.
                prepareRefresh();
    
                // Tell the subclass to refresh the internal bean factory.
                ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
                // Prepare the bean factory for use in this context.
                prepareBeanFactory(beanFactory);
    ...

信息很多，我也不知道是哪个，然后查了一下其它资料，第二个变量这里

// Tell the subclass to refresh the internal bean factory. ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

是加载bean工厂的，进去看看obtainFreshBeanFactory();

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
            refreshBeanFactory();
            ConfigurableListableBeanFactory beanFactory = getBeanFactory();
            if (logger.isDebugEnabled()) {
                logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
            }
            return beanFactory;
        }

看看getBeanFactory();

/** Bean factory for this context */
    private DefaultListableBeanFactory beanFactory;
    ...
    @Override
    public final ConfigurableListableBeanFactory getBeanFactory() {
        synchronized (this.beanFactoryMonitor) {
            if (this.beanFactory == null) {
                throw new IllegalStateException("BeanFactory not initialized or already closed - " +
                        "call 'refresh' before accessing beans via the ApplicationContext");
            }
            return this.beanFactory;
        }
    }

这个beanFactory怎么来的？点进去看看，我截取了几个重要的方法！

Object getBean(String name) throws BeansException;
    
    
        <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    
    
        <T> T getBean(Class<T> requiredType) throws BeansException;
    
        Object getBean(String name, Object... args) throws BeansException;
    
        <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
    
        boolean containsBean(String name);
    
        boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    
        boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

从方法可以很明显的看到，beanfactory应该是spring 容器管理bean，从容器中操作bean的方法，好，那么xml文件读取了，操作容器里面的bean 的 beanfactory也创建了。接下来，应该是beanfactory 去操作从 xml 解析的bean了。

回到obtainFreshBeanFactory()，不知道refreshBeanFactory()是干什么用，再点就去，看看refreshBeanFactory();

@Override
        protected final void refreshBeanFactory() throws BeansException {
            if (hasBeanFactory()) {
                destroyBeans();
                closeBeanFactory();
            }
            try {
                DefaultListableBeanFactory beanFactory = createBeanFactory();
                beanFactory.setSerializationId(getId());
                customizeBeanFactory(beanFactory);
                loadBeanDefinitions(beanFactory);
                synchronized (this.beanFactoryMonitor) {
                    this.beanFactory = beanFactory;
                }
            }
            catch (IOException ex) {
                throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
            }
        }

意思我看懂了，先判断有没有hasBeanFactory，有的话就关闭，保证只有一个BeanFactory，注意这两句：

customizeBeanFactory(beanFactory);
    loadBeanDefinitions(beanFactory);

但是直觉告诉我，loadBeanDefinitions才是重点，因为load是加载的意思，这个函数很可能是加载beanFactory：

@Override
        protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
            // Create a new XmlBeanDefinitionReader for the given BeanFactory.
            XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
    
            // Configure the bean definition reader with this context's
            // resource loading environment.
            beanDefinitionReader.setEnvironment(getEnvironment());
            beanDefinitionReader.setResourceLoader(this);
            beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
    
            // Allow a subclass to provide custom initialization of the reader,
            // then proceed with actually loading the bean definitions.
            initBeanDefinitionReader(beanDefinitionReader);
            loadBeanDefinitions(beanDefinitionReader);
        }

上面的beanFactory已经获取了，可以吧beanFactory看成是操作spring 容器的工具。那么beanFactory要操作的bean哪里来的？ 当然是从xml文件读取得（xml嘛，关键字）：

XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

先不管他是怎么解析的，先来看看如何加载，读取xml之后要加载，通过最后一句：

loadBeanDefinitions(beanDefinitionReader);

点进去，看看源码：

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException {
            String[] configLocations = getConfigLocations();
            if (configLocations != null) {
                for (String configLocation : configLocations) {
                    reader.loadBeanDefinitions(configLocation);
                }
            }
        }

getConfigLocations(); 中的configLocations 很明显跟上面的存放xml的变量是相同的，因此，loadBeanDefinitions是在这里将操控容器的beanFactory与xml连接在一起的。

回到刚刚的问题，怎么读取xml的内容？我在这里绕来绕去被卡住了，参考其他大神的博客，才知道几经辗转来到下面的函数：

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

documentReader.registerBeanDefinitions(doc, createReaderContext(resource));再到：

protected void doRegisterBeanDefinitions(Element root) {
            // Any nested <beans> elements will cause recursion in this method. In
            // order to propagate and preserve <beans> default-* attributes correctly,
            // keep track of the current (parent) delegate, which may be null. Create
            // the new (child) delegate with a reference to the parent for fallback purposes,
            // then ultimately reset this.delegate back to its original (parent) reference.
            // this behavior emulates a stack of delegates without actually necessitating one.
            BeanDefinitionParserDelegate parent = this.delegate;
            this.delegate = createDelegate(getReaderContext(), root, parent);
    
            if (this.delegate.isDefaultNamespace(root)) {
                String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
                if (StringUtils.hasText(profileSpec)) {
                    String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                            profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
                    if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
                        return;
                    }
                }
            }
    
            preProcessXml(root);
            parseBeanDefinitions(root, this.delegate);
            postProcessXml(root);
    
            this.delegate = parent;
        }

从parseBeanDefinitions(root, this.delegate);中解析xml元素：

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

至此，xml文件的bean被解析，然后加载进beanfactory就完成了。我画了一个流程图：

![这里写图片描述][70]

## 这块绕来绕去，我也挺乱的，没关系，自己能看懂就行。 ##

[70]: /images/20220527/9162924855284296a02f98380f747745.png