Spring学习--IOC容器的初始化过程

IOC容器初始化概述

IOC容器初始化是由refresh()方法来启动的,这个方法标志着IOC容器的正式启动。Spring将IOC容器启动的过程分开,并使用不同的模块来完成,如使用ResourceLoader,BeanDefinition等模块, IOC容器的启动主要包括三个过程:

  • Resource定位过程:

        Resource定位指beanDefinition的资源定位,由ResourceLoader通过统一的Resource接口来完成,这个Resource对各种形式的BeanDefinition的使用都提供了统一的接口。这个过程类似于容器寻找数据的过程。

  • BeanDefinition的载入:

       BeanDefinition载入过程指的是把用户定义好的Bean表示为容器内部的数据结构,这个容器的数据结构其实就是BeanDefinition。实际上BeanDefinition就是POJO对象在容器的抽象,通过BeanDefinition来定义的数据结构,像是世间万物在java中的抽象,java的对象又在容器中的抽象就是BeanDefinition。

  • 向容器注册BeanDefinition:

       这个注册过程是通过调用BeanDefinitionRegistry接口来完成的,就是把载入过程中解析得到的BeanDefinition向IOC容器进行注册。通过下面的源码可以得到,注册过程就是在IOC容器将BeanDefinition注入到一个HashMap中,IOC容器就是通过这个HashMap来持有BeanDefinition数据的。

自己手写一个IOC容器的初始化

//创建IOC配置文件的抽象资源,这个抽象资源包含了BeanDefinition的定义信息
ClassPathResource resource = new ClassPathResource("bean.xm");

//创建一个bean工厂
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();

//创建一个读取器,这里使用XmlBeanDefinitionReader来载入XML文件形式的Bean工厂
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);

//XMLBeanFactory具体使用reader读入配置信息
reader.loadBeanDefinitions(resource);

1、BeanDefinition的Resource定位

        以上面编程式的使用DefaultListablebeanFactory时,首先需要定义一个Resource来定位容器BeanDefinition。DefaultListableBeanFactory不能够直接使用Resource,需要一个BeanDefinition来对这些信息进行处理,ApplicationContext中,Spring已经提供了一系列不同的Resource的读取器的实现。

       常用的Resource资源类型如下:

  • FileSystemResource:以文件的绝对路径方式进行访问资源,效果类似于Java中的File;
  • ClassPathResourcee:以类路径的方式访问资源,效果类似于this.getClass().getResource("/").getPath();
  • ServletContextResource:web应用根目录的方式访问资源,效果类似于request.getServletContext().getRealPath("");
  • UrlResource:访问网络资源的实现类。例如file: http: ftp:等前缀的资源对象;
  • ByteArrayResource: 访问字节数组资源的实现类

       下面具体说一下,以FileSystemXmlApplicationContext为例的BeanDefinition的定位过程。

         1、FileSystemXmlApplicationContext的类关系

    直接就是一个图:

 

          

 从上面的继承关系来看,FileSystemXmlApplicationContext继承于AbstractApplicationContext,AbstractApplicationContext的基类是DefaultResourceLoader来继承了ResourceLoader的能力。

首先看一下FileSystemXmlApplicationContext的具体实现


	public FileSystemXmlApplicationContext() {
	}


	public FileSystemXmlApplicationContext(ApplicationContext parent) {
		super(parent);
	}


	public FileSystemXmlApplicationContext(String configLocation) throws BeansException {
		this(new String[] {configLocation}, true, null);
	}


	public FileSystemXmlApplicationContext(String... configLocations) throws BeansException {
		this(configLocations, true, null);
	}


	public FileSystemXmlApplicationContext(String[] configLocations, ApplicationContext parent) throws BeansException {
		this(configLocations, true, parent);
	}


	public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh) throws BeansException {
		this(configLocations, refresh, null);
	}


	public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
			throws BeansException {

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



	@Override
	protected Resource getResourceByPath(String path) {
		if (path != null && path.startsWith("/")) {
			path = path.substring(1);
		}
		return new FileSystemResource(path);
	}

在构造方法的中调用了refresh方法,这个方法标志着启动IOC容器的初始化,我们点进去,进入到了FileSystemXmlApplicationContext的基类AbstractApplicationContext中。

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

			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) {
				if (logger.isWarnEnabled()) {
					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;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

这个Refresh方法其实是与Bean的生命周期有关,这里我还没有具体看Bean声明周期这一块,等我看完再做具体解释。这里重点看obtainFreshbeanFactory()这个方法,这个方法是IOC容器初始化的入口。

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

obtainFreshBeanFactory方法中调用了refreshBeanFactory方法,这个方法是一个抽象的,具体的实现是根据它的子类的具体情况来定的,由于我们现在看的是FileSystemXmlApplicationContext的过程,所以我们进入AbstractFreshableApplicationContext类中的refreshBeanFactory方法中

	@Override
	protected final void refreshBeanFactory() throws BeansException {
    //这里判断了是否存在BeanFactory,如果存在就销毁并关闭BeanFactory
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
    //这里去创建新的Beanfactory,创建的是DefaultListableBeanFactory
		try {
			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);
		}
	}

继续点入载入方法loadBeanDefinition中,这个方法有很多的重载。

点入的loadBeanDefinition方法也是一个抽象方法,需要去实现类中查看,我们还是选择与FileSystemXmlApplicationContext相关的AbstractXmlApplicationContext类中

	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        //创建一个配置读写器
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

        //设置BeanDefinition的相关属性
		beanDefinitionReader.setEnvironment(this.getEnvironment());
		beanDefinitionReader.setResourceLoader(this);
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

        //传入读写器
		initBeanDefinitionReader(beanDefinitionReader);
		//加载获取BeanDefinition定位
        loadBeanDefinitions(beanDefinitionReader);
	}

继续点入loadBeanDefinition方法

	protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
        //初始化不会走一条路,因为还没有Resource对象
		Resource[] configResources = getConfigResources();
		if (configResources != null) {
			reader.loadBeanDefinitions(configResources);
		}
        //以String文件的方式获取
		String[] configLocations = getConfigLocations();
		if (configLocations != null) {
			reader.loadBeanDefinitions(configLocations);
		}
	}

点入第二个loadBeanDefinition方法进入。

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

loadBeanDefinition方法继续点入,查看加载过程

 public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
        return this.loadBeanDefinitions(location, (Set)null);
    }

    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具体的定位
                    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);
                }
            }
        }
    }

直接看一下DefaultResourceLoader的getResource方法

public Resource getResource(String location) {
        Assert.notNull(location, "Location must not be null");
        Iterator var2 = this.protocolResolvers.iterator();

        Resource resource;
        do {
            if (!var2.hasNext()) {
                if (location.startsWith("/")) {
                    return this.getResourceByPath(location);
                }

                if (location.startsWith("classpath:")) {
                    return new ClassPathResource(location.substring("classpath:".length()), this.getClassLoader());
                }

                try {
                    URL url = new URL(location);
                    return new UrlResource(url);
                } catch (MalformedURLException var5) {
                    return this.getResourceByPath(location);
                }
            }

            ProtocolResolver protocolResolver = (ProtocolResolver)var2.next();
            resource = protocolResolver.resolve(location, this);
        } while(resource == null);

        return resource;
    }

如果Resource不是Url也不是classpath资源,那么就调用FileSystemXmlApplicationContext的getResourceByPath方法返回一个FileSystemResource,定位到Resource。接下来就是载入BeanDefinition.

2、BeanDefinition的载入和解析

我们接着上面的,继续进入loadBeanDefinitions()方法,查看载入过程

查看BeanDefinitionReader的实现类XmlBeanDefinitionReader的loadBeanDefinitions方法

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();
        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 {
                //通过Resource对象将XMl输入文件流中
                InputStream inputStream = encodedResource.getResource().getInputStream();

                try {
                    InputSource inputSource = new InputSource(inputStream);
                    if (encodedResource.getEncoding() != null) {
                        inputSource.setEncoding(encodedResource.getEncoding());
                    }
                    //具体读取流的方法
                    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;
        }
    }

 我们继续点入到doLoadBeanDefinitions方法中查看

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {
        try {
            Document doc = this.doLoadDocument(inputSource, resource);
            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);
        }
    }

这个方法就是将Resource文件的输入流解析为Xml文件的Document对象,然后经过registerBeanDefinition方法将Document对象解析成BeanDefinition(容器内部的数据结构)

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

继续点入registerBeanDefinitions()方法中

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

这个方法将Xml的元素取出来,继续进入doRegisterBeanDefinitions()方法

    protected void doRegisterBeanDefinitions(Element root) {
        BeanDefinitionParserDelegate parent = this.delegate;
        this.delegate = this.createDelegate(this.getReaderContext(), root, parent);
        if (this.delegate.isDefaultNamespace(root)) {
            String profileSpec = root.getAttribute("profile");
            if (StringUtils.hasText(profileSpec)) {
                String[] specifiedProfiles = StringUtils.tokenizeToStringArray(profileSpec, ",; ");
                if (!this.getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
                    if (this.logger.isInfoEnabled()) {
                        this.logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec + "] not matching: " + this.getReaderContext().getResource());
                    }

                    return;
                }
            }
        }

        this.preProcessXml(root);
        this.parseBeanDefinitions(root, this.delegate);
        this.postProcessXml(root);
        this.delegate = parent;
    }

在这个方法中,我们重点看“一类三法”,也就是BeanDefinitionParserDelegate类和preProcessXml、parseBeanDefinitions、postProcessXml三个方法。其中BeanDefinitionParserDelegate类非常非常重要(需要了解代理技术,如JDK动态代理、cglib动态代理等)。Spirng BeanDefinition的解析就是在这个代理类下完成的,此类包含了各种对符合Spring Bean语义规则的处理,比如<bean></bean>、<import></import>、<alias><alias/>等的检测。对于preProcessXml、parseBeanDefinitions、postProcessXml这三个方法,其中preProcessXml和postProcessXml都是空方法,意思是在解析标签前后我们自己可以扩展需要执行的操作,也是一个模板方法模式,体现了Spring的高扩展性。parseBeanDefinitions方法才是标签的具体解析过程。所以下面进入parseBeanDefinitions方法看具体是怎么解析标签的。

前面提到Document对象不能通过XmlBeanDefinitionReader,真正去解析Document文档树的是 BeanDefinitionParserDelegate完成的,这个解析过程是与Spring对BeanDefinition的配置规则紧密相关的,parseBeanDefinitions(root, delegate)方法如下:

    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)) {
                    //默认标签
                        this.parseDefaultElement(ele, delegate);
                    } else {
                        delegate.parseCustomElement(ele);
                    }
                }
            }
        } else {
            delegate.parseCustomElement(root);
        }

    }

继续进入parseDefaultElement方法

    private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
        if (delegate.nodeNameEquals(ele, "import")) {
            this.importBeanDefinitionResource(ele);
        } else if (delegate.nodeNameEquals(ele, "alias")) {
            this.processAliasRegistration(ele);
        } else if (delegate.nodeNameEquals(ele, "bean")) {
            this.processBeanDefinition(ele, delegate);
        } else if (delegate.nodeNameEquals(ele, "beans")) {
            this.doRegisterBeanDefinitions(ele);
        }

    }

是bean标签,进入processBeanDefinition方法,这里有一点就是所有的BeanDefinition都是存放在

BeanDefinitionHolder 中。

    protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) {
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

            try {
                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.getReaderContext().getRegistry());
            } catch (BeanDefinitionStoreException var5) {
                this.getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, var5);
            }

            this.getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }

    }

而且具体的从Document解析成BeanDefinition的过程是由GeanDefinitionParserDelegate来完成的。我们继续点入parseBeanDefinitionElement这个方法

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
		return parseBeanDefinitionElement(ele, null);
	}

	/**
	 * Parses the supplied {@code <bean>} element. May return {@code null}
	 * if there were errors during parse. Errors are reported to the
	 * {@link org.springframework.beans.factory.parsing.ProblemReporter}.
	 */
	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;
	}

这个方法将Bean标签的内容放入到BeanDefinition中,并且将其他的信息也放入到BeanDefinitionHolder中,

上面的解析过程可以看做根据xml文件对<bean>的定义生成BeanDefinition对象的过程,这个BeanDefinition对象中封装的数据大多都是与<bean>相关的,例如:init-method,destory-method,factory-method,beanClass,descriptor。有了这个BeanDefinition中分装的信息,容器才能对Bean配置进行处理以及实现容器的特性。至此,我们的BeanDefine就已经载入完成了。

接着我们看一下Bean的具体解析,这就是将Bean具体的解析。

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

看到这里,我们就将BeanDefinition的载入过程的源码看完了。

3、BeanDefinition在IOC容器的注册

接着我们来看BeanDefinition的注册过程

我们回到DefaultBeanDefinitionDocumentReader类中的processBeanDefinition()方法,这里先将BeanDefinition载入,然后得到BeanDefinitionHodler来进行注册。

点击进入registerBeanDefinition方法,这里是注册的入口。

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

这个方法是将BeanDefinitionHodler分解开,得到BeanName和BeanDefinition,然后继续调用

注册接口的接口,然后去具体的容器类将key--BeanName和value--BeanDefinition放入到容器的beanDefinitionMap的一个HashMap中,这个方法会判断Bean是否存在。

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 (!isAllowBeanDefinitionOverriding()) {
				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 (!beanDefinition.equals(oldBeanDefinition)) {
				if (this.logger.isInfoEnabled()) {
					this.logger.info("Overriding bean definition for bean '" + beanName +
							"' with a different definition: replacing [" + oldBeanDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			else {
				if (this.logger.isDebugEnabled()) {
					this.logger.debug("Overriding bean definition for bean '" + beanName +
							"' with an equivalent definition: replacing [" + oldBeanDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		else {
			if (hasBeanCreationStarted()) {
				// Cannot modify startup-time collection elements anymore (for stable iteration)
				synchronized (this.beanDefinitionMap) {
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					if (this.manualSingletonNames.contains(beanName)) {
						Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
						updatedSingletons.remove(beanName);
						this.manualSingletonNames = updatedSingletons;
					}
				}
			}
			else {
				// Still in startup registration phase
				this.beanDefinitionMap.put(beanName, beanDefinition);
				this.beanDefinitionNames.add(beanName);
				this.manualSingletonNames.remove(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

		if (oldBeanDefinition != null || containsSingleton(beanName)) {
			resetBeanDefinition(beanName);
		}
	}

 以上就是Ioc容器的初始化过程,但是这个只是Bean生命周期的第一步,Bean的实例化,接着我会继续写依赖注入,调用Bean的初始化方法等关于Bean的知识文章。欢迎大家关注我,继续关注我文章。

  • 3
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: Spring IoC 的实现过程主要分为两个步骤:首先是通过配置文件或注解将需要管理的对象注册到 Spring 容器中,然后在需要使用这些对象的时候,通过容器来获取这些对象的实例。具体来说,Spring IoC 的实现过程包括以下几个步骤: 1. 配置文件或注解:在 Spring 中,我们可以通过 XML 配置文件或注解的方式来将需要管理的对象注册到 Spring 容器中。在配置文件中,我们可以使用 <bean> 标签来定义一个 Bean,指定其 ID 和 Class,以及其他的属性和依赖关系。在注解中,我们可以使用 @Component、@Service、@Controller 等注解来标记一个类,表示这个类是一个 Bean。 2. Bean 的实例化:当 Spring 容器启动时,会根据配置文件或注解中的信息,创建所有需要管理的 Bean 的实例。这个过程中,Spring 会根据配置文件或注解中的信息,使用反射机制来创建 Bean 的实例,并且自动解决 Bean 之间的依赖关系。 3. Bean 的装配:在 Bean 实例化之后,Spring 会根据配置文件或注解中的信息,将 Bean 之间的依赖关系进行装配。这个过程中,Spring 会根据配置文件或注解中的信息,自动将一个 Bean 中需要依赖的其他 Bean 注入到这个 Bean 中。 4. Bean 的生命周期:在 Spring 容器启动时,会创建所有需要管理的 Bean 的实例,并且自动解决 Bean 之间的依赖关系。在 Bean 实例化之后,Spring 会调用 Bean 的初始化方法,进行一些初始化操作。在 Spring 容器关闭时,会调用 Bean 的销毁方法,进行一些清理操作。 总之,Spring IoC 的实现过程主要是通过配置文件或注解将需要管理的对象注册到 Spring 容器中,并且在需要使用这些对象的时候,通过容器来获取这些对象的实例。 ### 回答2: Spring IoC(Inversion of Control,控制反转)是Spring框架的核心特性之一,它通过管理和控制应用中的对象依赖关系来实现。 Spring IoC的实现过程如下: 1. 根据应用的配置文件编写相应的Bean定义。Spring IoC容器通过读取配置文件,了解应用中需要管理的bean的信息,包括bean的类名、作用域、依赖关系等。 2. 创建和管理Bean实例。Spring IoC容器根据配置文件中的定义,实例化需要管理的Bean,并根据其作用域进行管理。例如,对于单例作用域的Bean,容器只会创建一个实例,并在整个应用中共享。 3. 处理Bean的依赖关系。Spring IoC容器会自动解析Bean之间的依赖关系,确保每个Bean都能获取到它所依赖的其他Bean。容器根据配置文件中的定义,进行依赖注入。常见的注入方式有构造函数注入、setter方法注入和字段注入。 4. 提供Bean的生命周期管理。Spring IoC容器负责管理Bean的生命周期,包括初始化和销毁。容器在实例化Bean之后,会调用其生命周期回调方法进行初始化操作;在容器关闭时,会调用Bean的销毁方法进行资源释放等操作。 5. 提供AOP(面向切面编程)支持。Spring IoC容器还提供了AOP的支持,通过将横切关注点(如日志记录、事务管理等)分离出来,使得系统的业务逻辑和其他关注点可以独立演化。 综上所述,Spring IoC通过配置文件和容器的管理,实现了对象的创建、依赖注入和生命周期管理,从而实现了对象之间的解耦和灵活性。通过使用Spring IoC,我们可以更方便地管理和控制应用中的对象,提高了代码的可维护性和可测试性。 ### 回答3: Spring IoC(Inversion of Control)是一种通过反转对象创建和管理的控制方式,它将对象的创建和依赖注入的过程交由IoC容器来管理。下面是Spring IoC的实现过程: 1. 配置文件定义:首先,我们需要在Spring配置文件或者使用注解方式(@ComponentScan、@Configuration等)来定义Bean的配置。配置文件包括Bean的名字、类路径和其他属性。 2. 加载配置文件:Spring IoC容器负责加载配置文件,并将其解析成内部数据结构。它读取配置文件中的内容,包括Bean的定义、依赖关系和其他属性。 3. 创建Bean实例:Spring IoC容器根据配置文件中定义的Bean的信息,创建Bean的实例。它使用Java反射机制来实例化对象,并提供了灵活的方式来自定义Bean的创建过程。可以通过构造方法、工厂方法或者使用第三方库进行Bean的创建。 4. 设置Bean属性:一旦Bean的实例创建完成,Spring IoC容器将会为Bean设置其对应的属性。这些属性可以通过Setter和Getter方法进行设置和获取。Spring IoC容器根据配置文件中定义的依赖关系,自动为Bean注入它所依赖的其他Bean。 5. Bean的生命周期管理:Spring IoC容器管理Bean的整个生命周期。它在Bean的实例创建完成之后,会调用初始化方法来完成一些初始化操作。同时,当Bean不再被使用时,容器会调用销毁方法来进行资源释放。 6. 提供Bean的引用:Spring IoC容器负责将Bean的引用提供给其他组件使用。其他组件可以通过调用容器提供的方法来获取Bean的实例,从而完成对Bean的操作和调用。 总结来说,Spring IoC实现的过程包括了配置文件的定义、加载和解析、Bean的实例化和属性设置、Bean的生命周期管理以及Bean的引用提供。通过这种方式,Spring IoC实现了对象的解耦和依赖的管理,提高了代码的灵活性和可维护性。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值