Spring Bean加载（一）

最新推荐文章于 2024-08-15 15:54:28 发布
最新推荐文章于 2024-08-15 15:54:28 发布
阅读量250 收藏
点赞数
分类专栏： spring学习 文章标签： spring bean 源码 class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jcrt141lww/article/details/75621022
版权

前言

当前查看版本Spring 4.3.1.RELEASE，参考《Spring源码深度解析》

Spring加载Bean方式

该图是自己绘制的并不是顺序图！！！只是为了记录当前查看源码到什么位置仅供参考。看不清，可以找我要文件<.-.-.>
源码阅读顺序
这里写图片描述

1、XmlBeanFactory

//过时的
/** @deprecated */
@Deprecated
public class XmlBeanFactory extends DefaultListableBeanFactory {
    private final XmlBeanDefinitionReader reader;//主角
    public XmlBeanFactory(Resource resource) throws BeansException {
        this(resource, (BeanFactory)null);
    }

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

2、ApplicationContext

ApplicationContext子类
上图是我自己绘制的ApplicationContext类图部分
XmlWebApplicationContext中的loadBeanDefinitions方法

    public static final String DEFAULT_CONFIG_LOCATION = "/WEB-INF/applicationContext.xml";//默认配置文件
    public static final String DEFAULT_CONFIG_LOCATION_PREFIX = "/WEB-INF/";//配置文件前缀
    public static final String DEFAULT_CONFIG_LOCATION_SUFFIX = ".xml";//配置文件后缀
    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
        beanDefinitionReader.setEnvironment(this.getEnvironment());
        beanDefinitionReader.setResourceLoader(this);
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
        this.initBeanDefinitionReader(beanDefinitionReader);
        this.loadBeanDefinitions(beanDefinitionReader);
    }

    protected void initBeanDefinitionReader(XmlBeanDefinitionReader beanDefinitionReader) {
    }
    protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException {
        String[] configLocations = this.getConfigLocations();
        //调用父类方法获取配置文件路径，没有配置调用getDefaultConfigLocations()方法
        if(configLocations != null) {
            String[] var3 = configLocations;
            int var4 = configLocations.length;
            for(int var5 = 0; var5 < var4; ++var5) {
                String configLocation = var3[var5];
                reader.loadBeanDefinitions(configLocation);
            }
        }
    }
    protected String[] getDefaultConfigLocations() {
        return this.getNamespace() != null?new String[]{"/WEB-INF/" + this.getNamespace() + ".xml"}:new String[]{"/WEB-INF/applicationContext.xml"};
    }

AbstractXmlApplicationContext中的loadBeanDefinitions方法

    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory){
    //同上面
    }
    protected void initBeanDefinitionReader(XmlBeanDefinitionReader reader) {
        reader.setValidating(this.validating);
    }
    protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
        Resource[] configResources = this.getConfigResources();
        //configResources = null
        if(configResources != null) {
            reader.loadBeanDefinitions(configResources);
        }

        String[] configLocations = this.getConfigLocations();
        if(configLocations != null) {
            reader.loadBeanDefinitions(configLocations);
        }
    }
    protected Resource[] getConfigResources() {
        return null;
    }

由上面代码可以看出主角是XmlBeanDefinitionReader类下面就开始了解这个类

父类AbstractBeanDefinitionReader类中loadBeanDefinitions重载方法

    //调用子类的loadBeanDefinitions(Resource resource)方法
    public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
        Assert.notNull(resources, "Resource array must not be null");
        int counter = 0;
        Resource[] var3 = resources;
        int var4 = resources.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            Resource resource = var3[var5];
            counter += this.loadBeanDefinitions((Resource)resource);
        }
        return counter;
    }
    //调用下面方法
    public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
        return this.loadBeanDefinitions(location, (Set)null);
    }
    //代码那么长主要作用调用子类的loadBeanDefinitions(Resource resource)方法
    public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
        ResourceLoader resourceLoader = this.getResourceLoader();
        if(resourceLoader == null) {
            throw new BeanDefinitionStoreException("Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
        } else {
            int loadCount;
            if(!(resourceLoader instanceof ResourcePatternResolver)) {
                Resource resource = resourceLoader.getResource(location);
                loadCount = this.loadBeanDefinitions((Resource)resource);
                if(actualResources != null) {
                    actualResources.add(resource);
                }

                if(this.logger.isDebugEnabled()) {
                    this.logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
                }

                return loadCount;
            } else {
                try {
                    Resource[] resources = ((ResourcePatternResolver)resourceLoader).getResources(location);
                    loadCount = this.loadBeanDefinitions(resources);
                    if(actualResources != null) {
                        Resource[] var6 = resources;
                        int var7 = resources.length;
                        for(int var8 = 0; var8 < var7; ++var8) {
                            Resource resource = var6[var8];
                            actualResources.add(resource);
                        }
                    }
                    if(this.logger.isDebugEnabled()) {
                        this.logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
                    }
                    return loadCount;
                } catch (IOException var10) {
                    throw new BeanDefinitionStoreException("Could not resolve bean definition resource pattern [" + location + "]", var10);
                }
            }
        }
    }
    //调用本类的loadBeanDefinitions(String location)方法
    public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
        Assert.notNull(locations, "Location array must not be null");
        int counter = 0;
        String[] var3 = locations;
        int var4 = locations.length;
        for(int var5 = 0; var5 < var4; ++var5) {
            String location = var3[var5];
            counter += this.loadBeanDefinitions(location);//调用第二个方法
        }

XmlBeanDefinitionReader中loadBeanDefinitions重载方法

    //作用：将Resource封装成EncodedResour（带编码的Resource）调用下一个方法
    public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
        return this.loadBeanDefinitions(new EncodedResource(resource));
    }
    //执行方法
    public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
        Assert.notNull(encodedResource, "EncodedResource must not be null");
        if(this.logger.isInfoEnabled()) {
            this.logger.info("Loading XML bean definitions from " + encodedResource.getResource());
        }

        Set<EncodedResource> currentResources = (Set)this.resourcesCurrentlyBeingLoaded.get();
        //线程安全 ，但这里 currentResources应该本来就是线程安全的，所以推测不是为了线程安全。应该是为了线程能使用同一个 currentResources
        //来源http://blog.csdn.net/ykdsg/article/details/8674947
        if(currentResources == null) {
            currentResources = new HashSet(4);
           this.resourcesCurrentlyBeingLoaded.set(currentResources);
        }
        if(!((Set)currentResources).add(encodedResource)) {
            throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!");
        } else {
            int var5;
            try {
                InputStream inputStream = encodedResource.getResource().getInputStream();
                try {
                    InputSource inputSource = new InputSource(inputStream);
                    if(encodedResource.getEncoding() != null) {
                        inputSource.setEncoding(encodedResource.getEncoding());
                    }
                    //调用doLoadBeanDefinitions方法
                    var5 = this.doLoadBeanDefinitions(inputSource, encodedResource.getResource());
                } finally {
                    inputStream.close();
                }
            } catch (IOException var15) {
                throw new BeanDefinitionStoreException("IOException parsing XML document from " + encodedResource.getResource(), var15);
            } finally {
                ((Set)currentResources).remove(encodedResource);
                if(((Set)currentResources).isEmpty()) {
                    this.resourcesCurrentlyBeingLoaded.remove();
                }
            }
            return var5;
        }
    }
    //调用下一方法
    public int loadBeanDefinitions(InputSource inputSource) throws BeanDefinitionStoreException {
        return this.loadBeanDefinitions(inputSource, "resource loaded through SAX InputSource");
    }
    //调用doLoadBeanDefinitions(InputSource inputSource, Resource resource)方法
    public int loadBeanDefinitions(InputSource inputSource, String resourceDescription) throws BeanDefinitionStoreException {
        return this.doLoadBeanDefinitions(inputSource, new DescriptiveResource(resourceDescription));
    }
以上就是XmlBeanDefinitionReader类的重载方法介绍

下面开始介绍执行方法了

    protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {
        try {
            //获取Document对象
            Document doc = this.doLoadDocument(inputSource, resource);
            //注册Bean
            return this.registerBeanDefinitions(doc, resource);
        } catch (BeanDefinitionStoreException var4) {
            throw var4;
        } catch (SAXParseException var5) {
            throw new XmlBeanDefinitionStoreException(resource.getDescription(), "Line " + var5.getLineNumber() + " in XML document from " + resource + " is invalid", var5);
        } catch (SAXException var6) {
            throw new XmlBeanDefinitionStoreException(resource.getDescription(), "XML document from " + resource + " is invalid", var6);
        } catch (ParserConfigurationException var7) {
            throw new BeanDefinitionStoreException(resource.getDescription(), "Parser configuration exception parsing XML from " + resource, var7);
        } catch (IOException var8) {
            throw new BeanDefinitionStoreException(resource.getDescription(), "IOException parsing XML document from " + resource, var8);
        } catch (Throwable var9) {
            throw new BeanDefinitionStoreException(resource.getDescription(), "Unexpected exception parsing XML document from " + resource, var9);
        }
    }

    protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
        return this.documentLoader.loadDocument(inputSource, this.getEntityResolver(), this.errorHandler, this.getValidationModeForResource(resource), this.isNamespaceAware());
        //调用下面方法获取验证模式
    }
    protected int getValidationModeForResource(Resource resource) {
        //获取xml文件验证模式XSD或DTD
        int validationModeToUse = this.getValidationMode();//1
        if(validationModeToUse != 1) {
            return validationModeToUse;
        } else {
            //由代码自动识别判断
            int detectedMode = this.detectValidationMode(resource);
            return detectedMode != 1?detectedMode:3;
        }
    }
    //调用XmlValidationModeDetector中detectValidationMode方法
    protected int detectValidationMode(Resource resource) {
        if(resource.isOpen()) {
            throw new BeanDefinitionStoreException("Passed-in Resource [" + resource + "] contains an open stream: cannot determine validation mode automatically. Either pass in a Resource that is able to create fresh streams, or explicitly specify the validationMode on your XmlBeanDefinitionReader instance.");
        } else {
            InputStream inputStream;
            try {
                inputStream = resource.getInputStream();
            } catch (IOException var5) {
                throw new BeanDefinitionStoreException("Unable to determine validation mode for [" + resource + "]: cannot open InputStream. Did you attempt to load directly from a SAX InputSource without specifying the validationMode on your XmlBeanDefinitionReader instance?", var5);
            }
            try {
                //调用XmlValidationModeDetector中detectValidationMode方法
                return this.validationModeDetector.detectValidationMode(inputStream);
            } catch (IOException var4) {
                throw new BeanDefinitionStoreException("Unable to determine validation mode for [" + resource + "]: an error occurred whilst reading from the InputStream.", var4);
            }
        }
    }

XmlValidationModeDetector代码节选

    //常量
    public static final int VALIDATION_NONE = 0;
    public static final int VALIDATION_AUTO = 1;
    public static final int VALIDATION_DTD = 2;//DTD校验
    public static final int VALIDATION_XSD = 3;//XSD校验
    //通过判断是否存在<!--DOCTYPE-->选择DTD或XSD
    private static final String DOCTYPE = "DOCTYPE";
    private static final String START_COMMENT = "<!--";
    private static final String END_COMMENT = "-->";
    public int detectValidationMode(InputStream inputStream) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
        byte var4;
        try {
            boolean isDtdValidated = false;

            while(true) {
                String content;
                if((content = reader.readLine()) != null) {
                    content = this.consumeCommentTokens(content);
                    if(this.inComment || !StringUtils.hasText(content)) {
                        continue;
                    }
                    if(this.hasDoctype(content)) {
                        //存在DOCTYPE使用DTD校验
                        isDtdValidated = true;
                    } else if(!this.hasOpeningTag(content)) {
                        continue;
                    }
                }
                //对应XSD和DTD常量
                int var5 = isDtdValidated?2:3;
                return var5;
            }
        } catch (CharConversionException var9) {
            var4 = 1;
        } finally {
            reader.close();
        }

        return var4;
    }
        private boolean hasDoctype(String content) {
        return content.contains("DOCTYPE");
    }
DefaultDocumentLoader源码节选

    /**
     * JAXP attribute used to configure the schema language for validation.
     */
    private static final String SCHEMA_LANGUAGE_ATTRIBUTE = "http://java.sun.com/xml/jaxp/properties/schemaLanguage";

    /**
     * JAXP attribute value indicating the XSD schema language.
     */
    private static final String XSD_SCHEMA_LANGUAGE = "http://www.w3.org/2001/XMLSchema";
    @Override
    public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
            ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {

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

        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(namespaceAware);

        if (validationMode != XmlValidationModeDetector.VALIDATION_NONE) {
            factory.setValidating(true);
            if (validationMode == XmlValidationModeDetector.VALIDATION_XSD) {
                // Enforce namespace aware for XSD...
                //判断当前是否使用 xml schema 验证
                factory.setNamespaceAware(true);
                try {
                    factory.setAttribute(SCHEMA_LANGUAGE_ATTRIBUTE, XSD_SCHEMA_LANGUAGE);
                }
                catch (IllegalArgumentException ex) {
                    ParserConfigurationException pcex = new ParserConfigurationException(
                            "Unable to validate using XSD: Your JAXP provider [" + factory +
                            "] does not support XML Schema. Are you running on Java 1.4 with Apache Crimson? " +
                            "Upgrade to Apache Xerces (or Java 1.5) for full XSD support.");
                    pcex.initCause(ex);
                    throw pcex;
                }
            }
        }
        return factory;
    }
获取完Document对象后开始注册Bean

回到XmlBeanDefinitionReader的doLoadBeanDefinitions方法调用下面的方法

    public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    //创建DefaultBeanDefinitionDocumentReader
        BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
        int countBefore = getRegistry().getBeanDefinitionCount();
        //调用DefaultBeanDefinitionDocumentReader中registerBeanDefinitions方法
        documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
        return getRegistry().getBeanDefinitionCount() - countBefore;
    }
DefaultBeanDefinitionDocumentReader源码节选
    public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
        this.readerContext = readerContext;
        logger.debug("Loading bean definitions");
        Element root = doc.getDocumentElement();
        //核心终于到了
        doRegisterBeanDefinitions(root);
    }

由于贴太多代码篇幅太长，下篇

渣渣lww
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【微服务】spring 控制bean加载顺序使用详解
congge
09-26 5587
spring 控制bean加载顺序使用详解
Spring源码剖析——核心IOC容器原理
拂晓的专栏
08-05 1万+
IOC介绍  相信大多数人在学习Spring时 IOC 和 Bean 算得上是最常听到的两个名词，IOC在学习Spring当中出现频率如此之高必然有其原因。如果我们做一个比喻的话，把Bean说成Spring中主角的话，那么IOC便是这个主角进行演出的舞台,没有IOC作为Bean的承载，那么Bean便不会在编程中大放异彩。作为Spring核心组件的重要一员，了解其内部实现对我们编程和窥探Spring内
SQL Server Error 4014，A fatal error occurred while reading the input stream from the network
Hehuyi_In的博客
06-17 2478
One of our servers would periodically suffer from a fatal error during batch processing. This was a SQL Server 2008 instance running on Windows 2008 R2. The error in question: A fatal error occurred while reading the input stream from the network. The s
加载xml 文件时,webshere 报sun.io.MalformedInputException
Fangrn的专栏
10-27 204
最近在做信诚人寿的一个项目，服务器web容器使用的是webshere 6.0，之前在做一个项目的时候使用的是was5，要知道这个东东对于很多的配置和写法都是要求得很严格的，在tomcat上跑得好好的放到was上就各种问题都有了 [09-10-27 17:12:40:574 CST] 0000009d SystemErr R org.springframework.beans.factor...
Spring的Bean加载流程
热门推荐
张维鹏的博客
02-22 7万+
Spring IOC容器就像是一个生产产品的流水线上的机器，Spring创建出来的Bean就好像是流水线的终点生产出来的一个个精美绝伦的产品。既然是机器，总要先启动，Spring也不例外。因此Bean的加载流程总体上来说可以分为两个阶段： 容器启动阶段 Bean创建阶段 一、容器启动阶段： 容器的启动阶段做了很多的预热工作，为后面Bean的实例化做好了充分的准备，我们首先看一下容器的启动阶段都做了哪些预热工作。 1、配置元信息： Spring IOC容器将对象实例的创建与对象实例的使用分离，当业务
Spring bean加载顺序
weixin_40413961的博客
06-02 1190
在默认配置下，Spring的Bean加载顺序主要取决于Bean的定义顺序、依赖关系和生命周期回调方法。虽然类路径扫描的顺序可能因运行环境而异，但通过使用@DependsOn注解和depends-on属性，可以显式控制Bean的加载和初始化顺序。Spring并不会随机改变Bean的加载顺序，而是遵循上述策略确保Bean在合理的顺序中加载和初始化。
Spring Bean的加载方式
qq_33753147的博客
10-30 1346
Spring Bean的加载方式
spring Bean加载流程
宋忠瑾的博客
11-23 2532
一、读取注解 先通过扫描指定路径下的spring注解或者XML配置，然后将其解析并封装到BeanDefintaion这个接口的实现类中。 二、bean生命周期 2.1 实例化 AbstractAutoWireCapableBeanFactory.doCreateBean中会调用createBeaninstance()方法，该阶段主要是从beanDefinitionMap循环读取bean，获取他的属性，然后利用反射读取对象的构造方法，进行实例化对象，此时是一个空对象在JVM堆中所有属性并未赋值。 2.2 初始
Spring的bean加载流程
qq_38645103的博客
06-26 5478
spring的bean记载流程
Spring Bean加载顺序的控制
qq_48025216的博客
05-29 2428
Spring Bean加载顺序的控制，最终测试结果为：一般情况下会按照SPring类的书写的顺序去创建，但是也不一定，最终其实得看你的编译出来的文件，的Class文件到底是什么样子的，包括操作系统文件的排序规则等一系列的因素。
springBean加载过程源码解析文档，附有代码类名和行数
06-15
Spring Bean 加载过程是 Spring 框架中最核心的部分之一，涉及到 ApplicationContext 的初始化、Bean 的加载和注册等过程。在 Spring Boot 应用程序中，SpringApplication 负责加载和管理 Bean。 SpringApplication...
Spring Bean 加载顺序 .
10-13
让我们详细探讨Spring Bean加载顺序的各个环节。 1. **配置源解析**： Spring支持多种配置方式，包括XML、Java配置类（@Configuration）、注解（@Component、@Service等）以及通过@ConfigurationProperties处理...
详解Spring简单容器中的Bean基本加载过程
08-30
Spring 简单容器中的 Bean ...Spring 简单容器中的 Bean 基本加载过程是一个复杂的过程，它涉及到 XML 文件的解析、bean 的注册和加载等多个步骤。只有了解这个过程，才能更好地使用 Spring 框架来开发企业级应用程序。
Spring动态加载bean后调用实现方法解析
08-25
在 Spring 框架中，动态加载 bean 是一个非常实用的功能，特别是在我们需要在不改变原有程序结构的基础上添加新的 bean 的时候。通过使用 Spring 的 BeanFactoryPostProcessor 接口类，我们可以动态地加载所需要的 ...
Spring多种加载Bean方式解析
08-30
本篇文章主要介绍了Spring多种加载Bean方式解析，通过对Bean加载方式的详细解析，了解Spring中的Bean加载机制。 定义Bean的方式 在Spring中，定义Bean的方式有多种，常见的定义Bean的方式有三种： 1. 通过xml的...
MybatisPlus之租户拦截器TenantLineInnerInterceptor使用攻略
Mr朱鹏的博客
08-12 480
MybatisPlus之租户拦截器TenantLineInnerInterceptor使用攻略
dubbo和springcloud有什么异同？
最新发布
yszbrzdd的博客
08-15 276
Dubbo主要关注于高效的 RPC 调用和服务治理。提供了一个综合的微服务解决方案，涵盖了从服务注册到配置管理的广泛功能。它们可以根据具体需求和现有技术栈选择使用，也可以结合使用，例如在 Spring Cloud 环境中集成 Dubbo 作为 RPC 框架。
SpringBoot
qq_74812898的博客
08-12 573
SpringBoot
SpringBoot中整合RabbitMQ（测试+部署上线 最完整）
qq_73440769的博客
08-12 1262
包括RabbitMQ在虚拟机本地测试和部署上线通过微信小程序测试，包括Java代码使用示例，也有部署RabbitMQ中的一些困难和解决办法，和最后的解决，配置部署代码一条龙。
"SpringBean加载过程源码解析，包含代码类名和行数详解
总的来说，SpringBean加载过程源码解析文档是一份系统而详细的分析文档，能够帮助开发人员深入理解Spring框架中Bean加载的原理和流程，对于理解和应用Spring框架是非常有价值的。通过对SpringBean加载过程的源码解析...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值