Spring IOC核心流程是什么

本篇内容主要讲解“spring ioc核心流程是什么”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“Spring ioC核心流程是什么”吧!

初始化

大致单步跟了下Spring IOC的初始化过程，整个脉络很庞大，初始化的过程主要就是读取XML资源，并解析，最终注册到Bean Factory中：

在完成初始化的过程后，Bean们就在BeanFactory中蓄势以待地等调用了。下面通过一个具体的例子，来详细地学习一下初始化过程，例如当加载下面一个bean：

<bean id="XiaoWang" class="com.springstudy.talentshow.SuperInstrumentalist">    <property name="instruments">        <list>            <ref bean="piano"/>            <ref bean="saxophone"/>        </list>    </property></bean>

加载时需要读取、解析、注册bean，这个过程具体的调用栈如下所示：

下面对每一步的关键的代码进行详细分析：

准备

保存配置位置，并刷新
在调用ClassPathXmlApplicationContext后，先会将配置位置信息保存到configLocations，供后面解析使用，之后，会调用AbstractApplicationContext的refresh方法进行刷新：

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh,        ApplicationContext parent) throws BeansException {    super(parent);    // 保存位置信息，比如`com/springstudy/talentshow/talent-show.xml`    setConfigLocations(configLocations);    if (refresh) {        // 刷新        refresh();    }}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) {            // Destroy already created singletons to avoid dangling resources.            destroyBeans();            // Reset 'active' flag.            cancelRefresh(ex);            // Propagate exception to caller.            throw ex;        }    }}

创建载入BeanFactory

protected final void refreshBeanFactory() throws BeansException {    // ... ...    DefaultListableBeanFactory beanFactory = createBeanFactory();    // ... ...    loadBeanDefinitions(beanFactory);    // ... ...}

创建XMLBeanDefinitionReader

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)     throws BeansException, IOException {    // Create a new XmlBeanDefinitionReader for the given BeanFactory.    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);    // ... ...    // Allow a subclass to provide custom initialization of the reader,    // then proceed with actually loading the bean definitions.    initBeanDefinitionReader(beanDefinitionReader);    loadBeanDefinitions(beanDefinitionReader);

读取

创建处理每一个resource

public int loadBeanDefinitions(String location, Set<Resource> actualResources)     throws BeanDefinitionStoreException {    // ... ...    // 通过Location来读取Resource    Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);    int loadCount = loadBeanDefinitions(resources);    // ... ...}public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {    Assert.notNull(resources, "Resource array must not be null");    int counter = 0;    for (Resource resource : resources) {        // 载入每一个resource        counter += loadBeanDefinitions(resource);    }    return counter;}

处理XML每个元素

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {    // ... ...    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)) {                // 处理每个xml中的元素，可能是import、alias、bean                parseDefaultElement(ele, delegate);            }            else {                delegate.parseCustomElement(ele);            }        }    }    // ... ...}

解析和注册bean

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {    // 解析    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);    if (bdHolder != null) {        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);        try {            // 注册            // Register the final decorated instance.            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));    }}

本步骤中，通过parseBeanDefinitionElement将XML的元素解析为BeanDefinition，然后存在BeanDefinitionHolder中，然后再利用BeanDefinitionHolder将BeanDefinition注册，实质就是把BeanDefinition的实例put进BeanFactory中，和后面将详细的介绍解析和注册过程。

解析

处理每个Bean的元素

public AbstractBeanDefinition parseBeanDefinitionElement(        Element ele, String beanName, BeanDefinition containingBean) {    // ... ...    // 创建beandefinition    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());    // 处理“Constructor”    parseConstructorArgElements(ele, bd);    // 处理“Preperty”    parsePropertyElements(ele, bd);    parseQualifierElements(ele, bd);    // ... ...}

处理属性的值

public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {    String elementName = (propertyName != null) ?                    "<property> element for property '" + propertyName + "'" :                    "<constructor-arg> element";    // ... ...    if (hasRefAttribute) {    // 处理引用        String refName = ele.getAttribute(REF_ATTRIBUTE);        if (!StringUtils.hasText(refName)) {            error(elementName + " contains empty 'ref' attribute", ele);        }        RuntimeBeanReference ref = new RuntimeBeanReference(refName);        ref.setSource(extractSource(ele));        return ref;    }    else if (hasValueAttribute) {    // 处理值        TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));        valueHolder.setSource(extractSource(ele));        return valueHolder;    }    else if (subElement != null) {    // 处理子类型（比如list、map等）        return parsePropertySubElement(subElement, bd);    }    // ... ...}

4 注册

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);        }    }}public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)        throws BeanDefinitionStoreException {    // ......    // 将beanDefinition注册    this.beanDefinitionMap.put(beanName, beanDefinition);    // ......}

注册过程中，最核心的一句就是：this.beanDefinitionMap.put(beanName, beanDefinition)，也就是说注册的实质就是以beanName为key，以beanDefinition为value，将其put到HashMap中。

注册

    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);        }    }}public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)        throws BeanDefinitionStoreException {    // ......    // 将beanDefinition注册    this.beanDefinitionMap.put(beanName, beanDefinition);    // ......

理解了以上两个过程，我们就可以自己实现一个简单的Spring框架了。于是，我根据自己的理解实现了一个简单的IOC框架Simple Spring，有兴趣可以看看。

注册过程中，最核心的一句就是：this.beanDefinitionMap.put(beanName, beanDefinition)，也就是说注册的实质就是以beanName为key，以beanDefinition为value，将其put到HashMap中。

注入依赖

当完成初始化IOC容器后，如果bean没有设置lazy-init(延迟加载)属性，那么bean的实例就会在初始化IOC完成之后，及时地进行初始化。初始化时会先建立实例，然后根据配置利用反射对实例进行进一步操作，具体流程如下所示：

创建bean的实例
创建bean的实例过程函数调用栈如下所示：

注入bean的属性
注入bean的属性过程函数调用栈如下所示：

在创建bean和注入bean的属性时，都是在doCreateBean函数中进行的，我们重点看下：

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd,            final Object[] args) {        // Instantiate the bean.        BeanWrapper instanceWrapper = null;        if (mbd.isSingleton()) {            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);        }        if (instanceWrapper == null) {            // 创建bean的实例            instanceWrapper = createBeanInstance(beanName, mbd, args);        }        // ... ...        // Initialize the bean instance.        Object exposedObject = bean;        try {            // 初始化bean的实例，如注入属性            populateBean(beanName, mbd, instanceWrapper);            if (exposedObject != null) {                exposedObject = initializeBean(beanName, exposedObject, mbd);            }        }        // ... ...    }

到此，相信大家对“Spring IOC核心流程是什么”有了更深的了解，不妨来实际操作一番吧！这里是编程网网站，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！