首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >IOC容器初始化过程

IOC容器初始化过程

作者头像
凯哥Java
发布2019-06-30 11:04:32
2.8K0
发布2019-06-30 11:04:32
举报
文章被收录于专栏:凯哥Java凯哥Java

IOC容器的初始化分为三个过程实现:

  • 第一个过程是Resource资源定位。这个Resouce指的是BeanDefinition的资源定位。这个过程就是容器找数据的过程,就像水桶装水需要先找到水一样。
  • 第二个过程是BeanDefinition的载入过程。这个载入过程是把用户定义好的Bean表示成Ioc容器内部的数据结构,而这个容器内部的数据结构就是BeanDefition。
  • 第三个过程是向IOC容器注册这些BeanDefinition的过程,这个过程就是将前面的BeanDefition保存到HashMap中的过程。

上面提到的过程一般是不包括Bean的依赖注入的实现。在Spring中,Bean的载入和依赖注入是两个独立的过程。依赖注入一般发生在应用第一次通过getBean向容器索取Bean的时候。下面的一张图描述了这三个过程调用的主要方法,图中的四个过程其实描述的是上面的第二个过程和第三个过程:

1 Resource定位

下面来看看主要的三个ApplicationContext的实现类是如何定位资源的,也就是找到我们通常所说“applicationContetx.xml”等配置文件的。

1.1 ClassPathXmlApplicationContext与FileSystemXmlApplicationContext

这两个类都是非Web容器时,常用的ApplicationContext类。他们很相似,所有的构造方法都在重载调用一段核心的代码。这段代码虽然很短,但是其中是一个很复杂的执行过程,它完成了IOC容器的初始化。

super(parent);  
        setConfigLocations(configLocations);  
        if (refresh) {  
            refresh();  
        }

这其中的setConfigLocations方法就是在进行资源定位。这个方法在AbstractRefreshableConfigApplicationContext类中实现。这个方法首先进行了非空了检验。这个Assert是Spring框架的一个工具类,这里面进行了一个非空判断。然后对这个路径进行了一些处理。这样就完成了资源的定位。这个定位其实就是使用者主动把配置文件的位置告诉Spring框架。

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

1.2 XmlWebApplicationContext

这个类是web容器初始化spring IOC容器的类。对于web应用来说,我们通常是不是直接去初始化这个容器的,它的装载是一个自动进行的过程。这是因为我们在web.xml中配置了这样一句话,这其实就是spring的入口

<listener>  
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
    </listener>

(1)下面来看这个类ContextLoaderListener,从它的定义就能看出,这是一个ServletContextListener,它的核心方法就是下面的contextInitialized事件,也就是当web容器初始化的时候,spring容器也进行了初始化。

public class ContextLoaderListener extends ContextLoader implements ServletContextListener
/** 
 * Initialize the root web application context. 
 */  
@Override  
public void contextInitialized(ServletContextEvent event) {  
    initWebApplicationContext(event.getServletContext());  
}

这个方法将servletContext作为参数传入,它的目标就是为了读取web.xml配置文件,找到我们对spring的配置。 (2)下面来看initWebApplicationContext方法,它完成了对webApplictionContext的初始化工作。这个方法里的有比较重要的几段代码,他们主要完成了webAppliction构建,参数的注入,以及保存构建webApplictionContext

if (this.context == null) {  
                this.context = createWebApplicationContext(servletContext);  
            }

这段代码看字面意思就知道是新建了一个webApplicationContext。它是由一个工具类产生一个新的wac,这个方法中调用了determineContextClass方法,它决定了容器初始化为哪种类型的ApplicationContext,因为我们可以在web.xml中对这种类型进行指定。而如果没有指定的话,就将使用默认的XmlWebApplicationContext。

protected Class<?> determineContextClass(ServletContext servletContext) {  
        String contextClassName = servletContext.getInitParameter(CONTEXT_CLASS_PARAM);  
        if (contextClassName != null) {  
            try {  
                return ClassUtils.forName(contextClassName, ClassUtils.getDefaultClassLoader());  
            }  
            catch (ClassNotFoundException ex) {  
                throw new ApplicationContextException(  
                        "Failed to load custom context class [" + contextClassName + "]", ex);  
            }  
        }  
        else {  
            contextClassName = defaultStrategies.getProperty(WebApplicationContext.class.getName());  
            try {  
                return ClassUtils.forName(contextClassName, ContextLoader.class.getClassLoader());  
            }  
            catch (ClassNotFoundException ex) {  
                throw new ApplicationContextException(  
                        "Failed to load default context class [" + contextClassName + "]", ex);  
            }  
        }  
    }
  • 注入参数,初始化这个空的容器 。这个过程的入口是configureAndRefreshWebApplicationContext这个方法中完成了wac的Id设置,将servletContext注入到wac中,还有最重要的方法,就是setConfigLocation.这里从web.xml中寻找指定的配置文件的位置,也就是我们通常配置的“contextConfigLocation”属性
String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);  
        if (configLocationParam != null) {  
            wac.setConfigLocation(configLocationParam);  
        }

那么如果没有指定呢?在XMLWebApplicationContext中这样一些常量,他们表示了配置文件的默认位置

/** Default config location for the root context */  
    public static final String DEFAULT_CONFIG_LOCATION = "/WEB-INF/applicationContext.xml";  
  
    /** Default prefix for building a config location for a namespace */  
    public static final String DEFAULT_CONFIG_LOCATION_PREFIX = "/WEB-INF/";  
  
    /** Default suffix for building a config location for a namespace */  
    public static final String DEFAULT_CONFIG_LOCATION_SUFFIX = ".xml";
  • spring容器初始化完成后,放入serverletContext中,这样在web容器中就可以拿到applicationContext
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);

2 BeanDefinition载入

这个过程是最繁琐,也是最重要的一个过程。这一个过程分为以下几步,

  • 构造一个BeanFactory,也就是IOC容器
  • 调用XML解析器得到document对象
  •  按照Spring的规则解析BeanDefition

对于以上过程,都需要一个入口,也就是前面提到的refresh()方法,这个方法AbstractApplicationContext类中,它描述了整个ApplicationContext的初始化过程,比如BeanFactory的更新,MessgaeSource和PostProcessor的注册等等。它更像是个初始化的提纲,这个过程为Bean的声明周期管理提供了条件。

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);  
  
            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) {  
                logger.warn("Exception encountered during context initialization - cancelling refresh attempt", ex);  
  
                // Destroy already created singletons to avoid dangling resources.  
                destroyBeans();  
  
                // Reset 'active' flag.  
                cancelRefresh(ex);  
  
                // Propagate exception to caller.  
                throw ex;  
            }  
        }  
    }

2.1 构建IOC容器

这个过程的入口是refresh方法中的obtainFreshBeanFactory()方法。整个过程构建了一个DefaultListableBeanFactory对象,这也就是IOC容器的实际类型。这一过程的核心如下:

2.1.1 obtainFreshBeanFactory

这个方法的作用是通知子类去初始化ioc容器,它调用了AbstractRefreshableApplicationContext的refreshBeanFactory 方法 进行后续工作。同时在日志是debug模式的时候,向日志输出初始化结果。

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

2.1.2 refreshBeanFactory

这个方法在创建IOC容器前,如果已经有容器存在,那么需要将已有的容器关闭和销毁,保证refresh之后使用的是新建立的容器。同时 在创建了空的IOC容器后,开始了对BeanDefitions的载入

protected final void refreshBeanFactory() throws BeansException {  
        if (hasBeanFactory()) {  
            destroyBeans();  
            closeBeanFactory();  
        }  
        try {  
            DefaultListableBeanFactory beanFactory = createBeanFactory();//创建了IOC容器  
            beanFactory.setSerializationId(getId());  
            customizeBeanFactory(beanFactory);  
            loadBeanDefinitions(beanFactory);// 启动对BeanDefitions的载入  
            synchronized (this.beanFactoryMonitor) {  
                this.beanFactory = beanFactory;  
            }  
        }  
        catch (IOException ex) {  
            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);  
        }  
    }
protected DefaultListableBeanFactory createBeanFactory() {  
        return new DefaultListableBeanFactory(getInternalParentBeanFactory());  
    }

2.2 解析XML文件

对于Spring,我们通常使用xml形式的配置文件定义Bean,在对BeanDefition载入之前,首先需要进行的就是XML文件的解析。整个过程的核心方法如下:

2.2.1 loadBeanDefinitions(DefaultListableBeanFactory beanFactory)

这里构造一个XmlBeanDefinitionReader对象,把解析工作交给他去实现

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {  
        // 定义一个XmlBeanDefinitionReader对象 用于解析XML  
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);  
  
        //进行一些初始化和环境配置  
        // Configure the bean definition reader with this context's  
        // resource loading environment.  
        beanDefinitionReader.setEnvironment(this.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);  
    }

2.2.2 loadBeanDefinitions

(1) AbstractXmlApplicationContext类 ,利用reader的方法解析,向下调用(Load the bean definitions with the given XmlBeanDefinitionReader.)

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

(2) AbstractBeanDefinitionReader 类 解析Resource  向下调用

public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {  
        Assert.notNull(resources, "Resource array must not be null");  
        int counter = 0;  
        for (Resource resource : resources) {  
            counter += loadBeanDefinitions(resource);  
        }  
        return counter;  
    }

(3) XmlBeanDefinitionReader 

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {  
        return loadBeanDefinitions(new EncodedResource(resource));  
    }

在下面方法得到了XML文件,并打开IO流,准备进行解析。实际向下调用

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

(4) doLoadBeanDefinitions

下面是它的核心方法,第一句调用Spring解析XML的方法得到document对象,而第二句则是载入BeanDefitions的入口

try {  
            Document doc = doLoadDocument(inputSource, resource);  
            return registerBeanDefinitions(doc, resource);  
        }

2.3 解析Spring数据结构

这一步是将document对象解析成spring内部的bean结构,实际上是AbstractBeanDefinition对象。这个对象的解析结果放入BeanDefinitionHolder中,而整个过程是由BeanDefinitionParserDelegate完成。

2.3.1 registerBeanDefinitions

解析BeanDefinitions的入口,向下调用doRegisterBeanDefinitions方法

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

2.3.2 doRegisterBeanDefinitions

定义了BeanDefinitionParserDelegate 解析处理器对象,向下调用parseBeanDefinitions 方法

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

2.3.3 parseBeanDefinitions

从document对象的根节点开始,依据不同类型解析。具体调用parseDefaultElement和parseCustomElement两个方法进行解析。这个主要的区别是因为bean的命名空间可能不同,Spring的默认命名空间是“http://www.springframework.org/schema/beans”,如果不是这个命名空间中定义的bean,将使用parseCustomElement方法。

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

2.3.4 parseDefaultElement

这个方法就是根据bean的类型进行不同的方法解析。

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  
        else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {  
            processBeanDefinition(ele, delegate);  
        }  
        //解析beans  递归返回  
        else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {  
            // recurse  
            doRegisterBeanDefinitions(ele);  
        }  
    }

2.3.5 processBeanDefinition

这个方法完成对普通,也是最常见的Bean的解析。这个方法实际上完成了解析和注册两个过程。这两个过程分别向下调用parseBeanDefinitionElement和registerBeanDefinition方法。

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {  
        //定义BeanDefinitionHolder对象 ,完成解析的对象存放在这个对象里面  
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);  
        if (bdHolder != null) {  
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);  
            try {  
                // 向容器注册解析完成的Bean  
                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));  
        }  
    }

2.3.6 parseBeanDefinitionElement

定义在BeanDefinitionParserDelegate 类中,完成了BeanDefition解析工作。在这里可以看到,AbstractBeanDefinition实际上spring的内部保存的数据结构

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {  
        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, MULTI_VALUE_ATTRIBUTE_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);  
        }  
  
        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;  
    }
/** 
     * Parse the bean definition itself, without regard to name or aliases. May return 
     * {@code null} if problems occurred during the parsing of the bean definition. 
     */  
    public AbstractBeanDefinition parseBeanDefinitionElement(  
            Element ele, String beanName, BeanDefinition containingBean) {  
  
        this.parseState.push(new BeanEntry(beanName));  
  
        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);  
            }  
            AbstractBeanDefinition bd = createBeanDefinition(className, parent);  
  
            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);  
            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));  
  
            parseMetaElements(ele, bd);  
            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());  
            parseReplacedMethodSubElements(ele, bd.getMethodOverrides());  
  
            parseConstructorArgElements(ele, bd);  
            parsePropertyElements(ele, bd);  
            parseQualifierElements(ele, bd);  
  
            bd.setResource(this.readerContext.getResource());  
            bd.setSource(extractSource(ele));  
  
            return bd;  
        }  
        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;  
    }

2.4 注册BeanDefition

完成了上面的三步后,目前ApplicationContext中有两种类型的结构,一个是DefaultListableBeanFactory,它是Spring IOC容器,另一种是若干个BeanDefinitionHolder,这里面包含实际的Bean对象,AbstractBeanDefition。

需要把二者关联起来,这样Spring才能对Bean进行管理。在DefaultListableBeanFactory中定义了一个Map对象,保存所有的BeanDefition。这个注册的过程就是把前面解析得到的Bean放入这个Map的过程。

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

2.4.1 registerBeanDefinition

注册的入口,对于普通的Bean和Alias调用不同类型的注册方法进行注册。

public static void registerBeanDefinition(  
            BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)  
            throws BeanDefinitionStoreException {  
  
        // Register bean definition under primary name.  
        String beanName = definitionHolder.getBeanName();  
        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());  
  
        // Register aliases for bean name, if any.  
        String[] aliases = definitionHolder.getAliases();  
        if (aliases != null) {  
            for (String alias : aliases) {  
                registry.registerAlias(beanName, alias);  
            }  
        }  
    }

2.4.2 registerBeanDefinition

注册Bean 定义在DefaultListableBeanFactory中

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)  
            throws BeanDefinitionStoreException {  
        //非空断言  
        Assert.hasText(beanName, "Bean name 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);  
            }  
        }  
  
        BeanDefinition oldBeanDefinition;  
  
        oldBeanDefinition = this.beanDefinitionMap.get(beanName);  
        //同名检测  
        if (oldBeanDefinition != null) {  
            //是否能够覆盖检测  
            if (!this.allowBeanDefinitionOverriding) {  
                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,  
                        "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +  
                        "': There is already [" + oldBeanDefinition + "] bound.");  
            }  
            else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {  
                // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE  
                if (this.logger.isWarnEnabled()) {  
                    this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +  
                            " with a framework-generated bean definition ': replacing [" +  
                            oldBeanDefinition + "] with [" + beanDefinition + "]");  
                }  
            }  
            else {  
                if (this.logger.isInfoEnabled()) {  
                    this.logger.info("Overriding bean definition for bean '" + beanName +  
                            "': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");  
                }  
            }  
        }  
        else {  
            this.beanDefinitionNames.add(beanName);  
            this.manualSingletonNames.remove(beanName);  
            this.frozenBeanDefinitionNames = null;  
        }  
        //放入Map中  
        this.beanDefinitionMap.put(beanName, beanDefinition);  
  
        if (oldBeanDefinition != null || containsSingleton(beanName)) {  
            resetBeanDefinition(beanName);  
        }  
    }

2.4.3 registerAlias

定义在SimpleAliasRegistry类,对别名进行注册

public void registerAlias(String name, String alias) {  
        Assert.hasText(name, "'name' must not be empty");  
        Assert.hasText(alias, "'alias' must not be empty");  
        if (alias.equals(name)) {  
            this.aliasMap.remove(alias);  
        }  
        else {  
            if (!allowAliasOverriding()) {  
                String registeredName = this.aliasMap.get(alias);  
                if (registeredName != null && !registeredName.equals(name)) {  
                    throw new IllegalStateException("Cannot register alias '" + alias + "' for name '" +  
                            name + "': It is already registered for name '" + registeredName + "'.");  
                }  
            }  
            checkForAliasCircle(name, alias);  
            this.aliasMap.put(alias, name);  
        }  
    }
本文参与 腾讯云自媒体分享计划,分享自作者个人站点/博客。
原始发表:2018-06-23 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 1 Resource定位
    • 1.1 ClassPathXmlApplicationContext与FileSystemXmlApplicationContext
      • 1.2 XmlWebApplicationContext
      • 2 BeanDefinition载入
        • 2.1 构建IOC容器
          • 2.1.1 obtainFreshBeanFactory
          • 2.1.2 refreshBeanFactory
        • 2.2 解析XML文件
          • 2.2.1 loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
          • 2.2.2 loadBeanDefinitions
        • 2.3 解析Spring数据结构
          • 2.3.1 registerBeanDefinitions
          • 2.3.2 doRegisterBeanDefinitions
          • 2.3.3 parseBeanDefinitions
          • 2.3.4 parseDefaultElement
          • 2.3.5 processBeanDefinition
          • 2.3.6 parseBeanDefinitionElement
        • 2.4 注册BeanDefition
          • 2.4.1 registerBeanDefinition
          • 2.4.2 registerBeanDefinition
          • 2.4.3 registerAlias
      相关产品与服务
      容器服务
      腾讯云容器服务(Tencent Kubernetes Engine, TKE)基于原生 kubernetes 提供以容器为核心的、高度可扩展的高性能容器管理服务,覆盖 Serverless、边缘计算、分布式云等多种业务部署场景,业内首创单个集群兼容多种计算节点的容器资源管理模式。同时产品作为云原生 Finops 领先布道者,主导开源项目Crane,全面助力客户实现资源优化、成本控制。
      领券
      问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档