Spring源码分析之BeanFactory初始化

扫码关注公众号:Java 技术驿站

发送:vip
将链接复制到本浏览器,永久解锁本站全部文章

【公众号:Java 技术驿站】 【加作者微信交流技术,拉技术群】
免费领取10G资料包与项目实战视频资料

在上一篇Spring源码分析之IOC容器创建过程中,大致梳理了一下IOC容器初始化的流程。在初始化的过程中,会调用模板方法refresh(),在刷新工厂方法中,首先会获取beanFactory,即以下这行代码:

    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

beanFactory的初始化大致可分为:定位—解析—注册 这三个步骤。以下将从源码的角度分析bean工厂是如何初始化的。入口为:AbstractApplicationContext的obtainFreshBeanFactory方法:

        protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
            //具体的子类来实现
            refreshBeanFactory();
            ConfigurableListableBeanFactory beanFactory = getBeanFactory();
            if (logger.isDebugEnabled()) {
                logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
            }
            return beanFactory;
        }

            protected final void refreshBeanFactory() throws BeansException {
            //判断bean工厂是否存在,存在先关闭销毁
            if (hasBeanFactory()) {
                destroyBeans();
                closeBeanFactory();
            }
            try {
                //这里只是简单的创建了DefaultListableBeanFactory 的实例
                DefaultListableBeanFactory beanFactory = createBeanFactory();
                beanFactory.setSerializationId(getId());
                //工厂的定制化设置
                customizeBeanFactory(beanFactory);
                //实际加载解析bean定义的入口
                loadBeanDefinitions(beanFactory);
                synchronized (this.beanFactoryMonitor) {
                    this.beanFactory = beanFactory;
                }
            }
            catch (IOException ex) {
                throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
            }
        }

(2)AbstractXmlApplicationContext的loadBeanDefinitions方法


        protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
            //创建一个bean定义读取器beanDefinitionReader 
            XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
            beanDefinitionReader.setEnvironment(this.getEnvironment());
            //设置资源加载器
            beanDefinitionReader.setResourceLoader(this);
            //为Bean读取器设置SAX xml解析器
            beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
            //xml校验相关
            initBeanDefinitionReader(beanDefinitionReader);
            //加载bean的地方
            loadBeanDefinitions(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);
            }
        }

(3)AbstractBeanDefinitionReader的loadBeanDefinitions方法,通过资源路径 解析为Spring标准的resource资源

        public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
            Assert.notNull(locations, "Location array must not be null");
            int counter = 0;
            for (String location : locations) {
                counter += loadBeanDefinitions(location);
            }
            return counter;
        }
        public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
            //获取初始化过程中的资源加载器
            ResourceLoader resourceLoader = getResourceLoader();
            if (resourceLoader == null) {
                throw new BeanDefinitionStoreException(
                        "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
            }

            if (resourceLoader instanceof ResourcePatternResolver) {
                // Resource pattern matching available.
                try {
                    //获取资源
                    Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
                    //委派实现加载
                    int loadCount = loadBeanDefinitions(resources);
                    if (actualResources != null) {
                        for (Resource resource : resources) {
                            actualResources.add(resource);
                        }
                    }
                    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.
                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;
            }
        }

(4)XmlBeanDefinitionReader 的loadBeanDefinitions方法

        public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
            Assert.notNull(encodedResource, "EncodedResource must not be null");
            if (logger.isInfoEnabled()) {
                logger.info("Loading XML bean definitions from " + encodedResource.getResource());
            }

            Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
            if (currentResources == null) {
                currentResources = new HashSet<EncodedResource>(4);
                this.resourcesCurrentlyBeingLoaded.set(currentResources);
            }
            if (!currentResources.add(encodedResource)) {
                throw new BeanDefinitionStoreException(
                        "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
            }
            try {
                //将配置资源解析为流的形式
                InputStream inputStream = encodedResource.getResource().getInputStream();
                try {
                    InputSource inputSource = new InputSource(inputStream);
                    if (encodedResource.getEncoding() != null) {
                        inputSource.setEncoding(encodedResource.getEncoding());
                    }
                    //开始正式的加载配置文件
                    return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
                }
                finally {
                    inputStream.close();
                }
            }
            catch (IOException ex) {
                throw new BeanDefinitionStoreException(
                        "IOException parsing XML document from " + encodedResource.getResource(), ex);
            }
            finally {
                currentResources.remove(encodedResource);
                if (currentResources.isEmpty()) {
                    this.resourcesCurrentlyBeingLoaded.remove();
                }
            }
        }

        protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
                throws BeanDefinitionStoreException {
            try {
                //转换为Document对象,方便后面对各个元素来进行解析
                Document doc = doLoadDocument(inputSource, resource);
                //解析Document对象
                return registerBeanDefinitions(doc, resource);
            }
            catch (BeanDefinitionStoreException ex) {
                throw 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 {
            //创建Document解析器
            BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
            //获取已经注册到IOC容器中bean的数量
            int countBefore = getRegistry().getBeanDefinitionCount();
            //注册解析
            documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
            return getRegistry().getBeanDefinitionCount() - countBefore;
        }

(4)DefaultBeanDefinitionDocumentReader的registerBeanDefinitions方法,此步骤完成了bean的解析以及注册

    public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
            this.readerContext = readerContext;
            logger.debug("Loading bean definitions");
            //获取根节点
            Element root = doc.getDocumentElement();
            doRegisterBeanDefinitions(root);
        }

        protected void doRegisterBeanDefinitions(Element root) {
            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;
                    }
                }
            }
            //解析bean定义之前的自定义操作,可用于子类实现相关的接口来定制化操作
            preProcessXml(root);
            //从根元素开始解析
            parseBeanDefinitions(root, this.delegate);
            //解析bean定义之前的自定义操作,方便扩展
            postProcessXml(root);

            this.delegate = parent;
        }

        protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
            //是否是Spring的默认空间
            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)) {
                            //是Spring自定义的则使用默认的方法是解析
                            parseDefaultElement(ele, delegate);
                        }
                        else {
                            //使用用户自定义的方式去解析
                            delegate.parseCustomElement(ele);
                        }
                    }
                }
            }
            else {
                //使用用户自定义的规则去解析元素
                delegate.parseCustomElement(root);
            }
        }

        private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
            //包含import节点的  则解析
            if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
                importBeanDefinitionResource(ele);
            }
            //包含alias节点的  则开始解析
            else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
                processAliasRegistration(ele);
            }
            //包含bean节点的  则开始解析 bean是我们经常会用到的 讲深入分析这个入口
            else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
                processBeanDefinition(ele, delegate);
            }
            //包含beans节点的
            else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
                // recurse
                doRegisterBeanDefinitions(ele);
            }
        }

        protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
            //解析文档Element 成Spring标准描述bean文件beanDefinition(bean解析)
            BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
            if (bdHolder != null) {
                bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
                try {
                    // bean定义的注册  即存放到一个map中 key为bean的名字  value为beanDefinition(注册)
                    BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
                }
                catch (BeanDefinitionStoreException ex) {
                    getReaderContext().error("Failed to register bean definition with name '" +
                            bdHolder.getBeanName() + "'", ele, ex);
                }
                // Send registration event.
                getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
            }
        }

至此,beanFactory就完成了整个的定位-解析–注册的流程。bean的定义信息就保存在beanDefinitionMap中,之后的实例化,依赖注入都是根据beanDefinitionMap中的定义信息来的。初始化之后的beanFactory的结构可以参考如下:

20191123100197\_1.png

除了Spring默认的初始化的一些bean的定义信息外,还有我们自定义的两个bean,demoA 和 demoB,定义信息中包含每个bean的详细的信息,包含是否是单例,类路径等等。


来源:http://ddrv.cn/a/88268

赞(0) 打赏
版权归原创作者所有,任何形式的转载请联系博主:daming_90:Java 技术驿站 » Spring源码分析之BeanFactory初始化

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏