Spring IOC的原理及详解

迷南。 2022-02-28 23:48 209阅读 0赞

### 文章目录 ###

*  IOC简介
 *  IOC的初始化
 *   *  1 准备
     *  2 读取
     *  3 解析
     *  注册
 *  注入依赖

# IOC简介 #

*  **为了解决对象之间的耦合度过高的问题**，软件专家Michael Mattson提出了IOC理论，用来实现对象之间的“解耦”

>  *  软件系统在没有引入IOC容器之前，对象A依赖于对象B，那么对象A在初始化或者运行到某一点的时候，自己必须主动去创建对象B或者使用已经创建的对象B。无论是创建还是使用对象B，控制权都在自己手上。
>  *  软件系统在引入IOC容器之后，这种情形就完全改变了，由于IOC容器的加入，对象A与对象B之间失去了直接联系，所以，当对象A运行到需要对象B的时候，IOC容器会主动创建一个对象B注入到对象A需要的地方。

*  IOC (Inversion of Control，控制反转)：对象之间的依赖关系由容器来创建。本来对象之间的关系是由开发者自己创建和维护的，在使用Spring框架后，对象之间的关系由容器来创建和维护，将开发者做的事让容器做，这就是控制反转。BeanFactory接口是Spring Ioc容器的核心接口。
 *  DI (Dependecy Injection，依赖注入)：我们在使用Spring容器的时候，容器通过调用set方法或者是构造器来建立对象之间的依赖关系。注入方式有设值注入、构造注入、注解注入、接口注入(基本不用)，设值注入直观，自然；构造注入可以在构造器中决定依赖关系的顺序。

> 控制反转是目标，依赖注入是我们实现控制反转的一种手段。

*  **IOC容器的技术剖析**  
    IOC中最基本的技术就是“反射(Reflection)”编程，有关反射的概念和用法，通俗来讲就是根据给出的类名（字符串方式）来动态地生成对象。这种编程方式可以让对象在生成时才决定到底是哪一种对象。  
    我们可以把IOC容器的工作模式看做是工厂模式的升华，可以把IOC容器看作是一个工厂，这个工厂里要生产的对象都在配置文件中给出定义，然后利用编程语言的的反射编程，根据配置文件中给出的类名生成相应的对象。从实现来看，IOC是把以前在工厂方法里写死的对象生成代码，改变为由配置文件来定义，也就是把工厂和对象生成这两者独立分隔开来，目的就是提高灵活性和可维护性。

# IOC的初始化 #

初始化的过程主要是**读取XML资源，并解析，最终注册到Bean Factory中：**  
![在这里插入图片描述][20190321104141739.png]  
在完成初始化的过程后，Bean们就在BeanFactory中可以等待使用了。下面通过一个具体的例子，来详细学习一下初始化过程，例如当加载下面一个bean：

加载时需要读取、解析、注册bean，这个过程具体的调用栈如下所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70]  
下面对每一步的关键代码进行详细分析：

## 1 准备 ##

**保存配置位置，并刷新**  
在调用`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);
    }

## 2 读取 ##

**创建处理每一个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`中。

## 3 解析 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 1]  
**处理每个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);
        }
        // ... ...
    }

## 注册 ##

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中。

# 注入依赖 #

当完成初始化IOC容器后，如果bean没有设置lazy-init(延迟加载)属性，那么bean的实例就会在初始化IOC完成之后，及时地进行初始化。初始化时会先建立实例，然后根据配置利用反射对实例进行进一步操作，具体流程如下所示：  
![在这里插入图片描述][20190321105808226.png]  
**创建bean的实例**  
创建bean的实例过程函数调用栈如下所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 2]  
**注入bean的属性**  
注入bean的属性过程函数调用栈如下所示：  
![在这里插入图片描述][2019032111000048.png]  
在创建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);
            }
        }
        // ... ...
    }

至此，IOC的初始化及注入结束。

[20190321104141739.png]: /images/20220301/22190710ccab43cc98097746a3af202b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70]: /images/20220301/e74111977c794bd59abc5eae281632ae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 1]: /images/20220301/dee9934029b8413f8dd86843b814173b.png
[20190321105808226.png]: /images/20220301/6d066e3206d14475ac8178987135545e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 2]: /images/20220301/5a8b8165f54b4720b45df8faacb3e6e3.png
[2019032111000048.png]: /images/20220301/7b89e9f1f5404b529041c626cd08e886.png