前言

上一節(jié)我們分析了Spring的實(shí)例化和IOC過程吼旧。在熟悉了Spring的處理流程后凰锡，我們自己能不能寫一個IOC的容器和實(shí)現(xiàn)依賴注入呢？要注意哪些問題呢？本章節(jié)我們重點(diǎn)關(guān)注兩個問題寡夹。

• 手寫一個簡單的IOC容器并實(shí)現(xiàn)依賴注入
• 分析Spring是怎樣解決循環(huán)依賴的問題

1处面、加載配置文件

先來看配置文件厂置，我們定義了兩個Bean菩掏，User和Role。

<beans>
    <bean id="user" class="ioc.entity.User">
        <property name="id" value="u_1001"/>
        <property name="name" value="吳蓓蓓"/>
        <property name="age" value="15"/>
        <property name="role" ref="role"></property>
    </bean>
    <bean id="role" class="ioc.entity.Role">
        <property name="id" value="r_2001"/>
        <property name="name" value="管理員"/>
    </bean> 
</beans>

掃描方式很簡單昵济，main方法指定了XML文件的路徑智绸。獲取文件的輸入流，轉(zhuǎn)成Document對象解析即可访忿，這點(diǎn)和Spring的做法是一致的瞧栗。并把property屬性簡單化處理，放在一個List<Map<String海铆，String>>中迹恐。

    /***
     * 遍歷XML文件，解析bean標(biāo)簽
     * @param location
     * @throws Exception
     */
    private void loadBeans(String location) throws Exception {
        // 加載 xml 配置文件
        InputStream inputStream = new FileInputStream(location);
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder docBuilder = factory.newDocumentBuilder();
        Document doc = docBuilder.parse(inputStream);
        Element root = doc.getDocumentElement();
        NodeList nodes = root.getChildNodes();
        
        for (int i = 0; i < nodes.getLength(); i++) {
            
            BeanDefinition beanDefinition = new BeanDefinition();
            
            Node node = nodes.item(i);
            if (node instanceof Element) {
                Element ele = (Element) node;
                String id = ele.getAttribute("id");
                String beanName = ele.getAttribute("class");
                
                beanDefinition.setId(id);
                beanDefinition.setBeanName(beanName);
                
                NodeList propertyNodes = ele.getElementsByTagName("property");
                List<Map<String,String>> propertyList = new ArrayList<>();
                Map<String,String> propertyMap;
                for (int j = 0; j < propertyNodes.getLength(); j++) {
                    
                    propertyMap = new HashMap<String, String>();
                    Node propertyNode = propertyNodes.item(j);
                    if (propertyNode instanceof Element) {
                        Element propertyElement = (Element) propertyNode;
                        String name = propertyElement.getAttribute("name");
                        String value = propertyElement.getAttribute("value");
                        propertyMap.put("propertyName", name);
                        if (value!=null && value.length()>0) {
                            propertyMap.put("propertyValue", value);
                            propertyMap.put("propertyType", "string");
                        }else{
                            String ref = propertyElement.getAttribute("ref");
                            propertyMap.put("propertyValue", ref);
                            propertyMap.put("propertyType", "ref");
                        }
                    }
                    propertyList.add(propertyMap);
                }
                beanDefinition.setPropertyList(propertyList);
                beanNames.add(id);
                beanClassMap.put(id, beanDefinition);
            }
        }
        doLoadBeanDefinitions();
    }

2卧斟、實(shí)例化

拿到beanName的集合殴边，遍歷進(jìn)行實(shí)例化和依賴注入。

private void doLoadBeanDefinitions() throws Exception{
    for(String beanName:beanNames){
        
        BeanDefinition beanDefinition = beanClassMap.get(beanName);
        
        DI(beanDefinition);
    }
}
private void  DI(BeanDefinition beanDefinition) throws Exception{
        
    Class<?> beanClass = createBean(beanDefinition.getBeanName());
    
    Object bean = beanClass.newInstance();
    
    List<Map<String,String>> propertyList = beanDefinition.getPropertyList();
    
    for (int i = 0; i < propertyList.size(); i++) {
        Map<String,String> property = propertyList.get(i);
        
        String propName = property.get("propertyName");
        String propValue = property.get("propertyValue");
        String propType = property.get("propertyType");
        
        Field declaredField = bean.getClass().getDeclaredField(propName);
        declaredField.setAccessible(true);
        
        if ("string".equals(propType)) {
            declaredField.set(bean, propValue);
        }else{
            Object beanInstance = beanMap.get(propValue);
            if (beanInstance!=null) {
                declaredField.set(bean, beanInstance);
            }else{
                BeanDefinition bd = beanClassMap.get(propValue);
                DI(bd);
                declaredField.set(bean,beanMap.get(propValue) );
            }
        }
    }
    beanMap.put(beanDefinition.getId(), bean);
}
private Class<?> createBean(String className){
    Class<?> beanClass = null;
    try {
        beanClass = Class.forName(className);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    return beanClass;
}

3珍语、測試

進(jìn)行main函數(shù)锤岸，看看測試結(jié)果。

public static void main(String[] args) throws Exception {
    String path = "D:\\Workspaces\\Netty\\src\\ioc\\ioc_1.xml";
    new IOC_1(path);
    Iterator<Entry<String, Object>> item = beanMap.entrySet().iterator();
    while(item.hasNext()){
        Entry<String, Object> next = item.next();
        if (next.getValue() instanceof User) {
            User user = (User) next.getValue();
            System.out.println("userId:"+user.getId());
            System.out.println("userName:"+user.getName());
            System.out.println("userRoleName:"+user.getRole().getName());
        }else{
            Role role = (Role) next.getValue();
            System.out.println("roleId:"+role.getId());
            System.out.println("roleName:"+role.getName());
        }
        System.out.println("-----------------");
    }
}

輸出結(jié)果如下

roleId:r_2001
roleName:管理員
-----------------
userId:u_1001
userName:吳蓓蓓
userRoleName:管理員
-----------------

從結(jié)果來看板乙，這兩個Bean的實(shí)例化和依賴注入是沒問題的是偷，完成了我們的本章節(jié)提出的第一個小目標(biāo)。

4募逞、循環(huán)依賴

如果我們把配置文件改一下蛋铆，讓User和Role形成循環(huán)依賴呢？我們的程序還能正常嗎放接？

<beans>
    <bean id="user" class="ioc.entity.User">
        <property name="id" value="u_1001"/>
        <property name="name" value="吳蓓蓓"/>
        <property name="age" value="15"/>
        <property name="role" ref="role"></property>
    </bean>
    <bean id="role" class="ioc.entity.Role">
        <property name="id" value="r_2001"/>
        <property name="name" value="管理員"/>
        <property name="user" ref="user"></property>
    </bean> 
</beans>

哈哈刺啦，不敢運(yùn)行。就上面的代碼而言透乾，它肯定會死循環(huán)洪燥。User依賴Role，注入的時候發(fā)現(xiàn)還沒有Role的實(shí)例乳乌，就先去實(shí)例化Role捧韵；實(shí)例化Role的時候，又發(fā)現(xiàn)依賴了User汉操，再去實(shí)例化User...好了再来，下面我們看下Spring是怎么解決這事的。
分析Spring之前，我們先來了解幾個緩存的定義

看到這幾個緩存针炉，我們可以大概理出一個思路挠他。

1、實(shí)例化Bean的時候篡帕，先從singletonObjects查找緩存殖侵，
如果命中就可以直接返回，未命中的話先把Bean放入singletonsCurrentlyInCreation镰烧，說明自己正在創(chuàng)建中拢军。
2、具體開始實(shí)例化怔鳖。完成后茉唉，把beanName和對應(yīng)的bean工廠放入singletonFactories。
3结执、依賴注入度陆，當(dāng)有循環(huán)依賴的時候，重復(fù)第1個步驟昌犹。
還是從singletonObjects查找緩存坚芜，雖然還是未命中，但是發(fā)現(xiàn)bean正在創(chuàng)建中了斜姥。
然后從singletonFactories中獲取bean的工廠對象鸿竖，拿到該Bean的對象。然后把這個Bean提前曝光铸敏，放入earlySingletonObjects缚忧。
4、注入完成杈笔，循環(huán)依賴問題解決闪水。

來看個流程圖，再整理下思路蒙具。

Spring IOC循環(huán)依賴

基于上面的思路球榆，把上面我們自己實(shí)現(xiàn)的代碼重新改造一下。全部代碼在GitHub:手寫簡單IOC容器禁筏，大家可以拿下來運(yùn)行一下看看持钉。

• 1、還是先遍歷所有的beanName

    /**
     * 遍歷XML中配置的bean篱昔，進(jìn)行實(shí)例化和IOC
     * @throws Exception
     */
    private void doLoadBeanDefinitions() throws Exception{
        for(String beanName:beanNames){
            BeanDefinition beanDefinition = beanClassMap.get(beanName);
            doGetBean(beanDefinition);
        }
    }

• 2每强、 獲取Bean實(shí)例

    private Object doGetBean(BeanDefinition beanDefinition) throws Exception{
        Object bean = null; 
        String beanName = beanDefinition.getId();   
        Object sharedInstance = getSingleton(beanName,true);
        if (sharedInstance !=null) {
            bean = sharedInstance;
        }else{
            Object singletonObject = getSingleton(beanDefinition);
            bean = singletonObject;
        }
        return bean;
    }

• 3始腾、下面來看兩個getSingleton方法。第一個主要是為了判斷是否正在創(chuàng)建中空执，如果是就從工廠里先拿到一個Bean返回浪箭；第二個是Bean實(shí)際創(chuàng)建過程。

    /**
     * 先從緩存中獲取辨绊，如果未命中并且沒有在創(chuàng)建中奶栖，返回NULL
     * 如果Bean正在創(chuàng)建中，從工廠中先拿到Bean返回(還未填充屬性)
     * @param beanName
     * @param allowEarlyReference
     * @return
     */
    private Object getSingleton(String beanName,boolean allowEarlyReference){
        Object beanObject = singletonObjects.get(beanName);
        
        if (beanObject == null && singletonsCurrentlyInCreation.contains(beanName)) {
            
            beanObject = earlySingletonObjects.get(beanName);
            if (beanObject ==null && allowEarlyReference) {
                Object singletonFactory = singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    beanObject = singletonFactory;
                    earlySingletonObjects.put(beanName, beanObject);
                    singletonFactories.remove(beanName);
                }
            }
        }
        return beanObject;
    }
    
    /**
     * 先從緩存獲取Bean邢羔，如果未命中驼抹，直接創(chuàng)建桑孩，并把創(chuàng)建完且注入完成的Bean放入緩存
     * @param beanDefinition
     * @return
     * @throws Exception
     */
    private Object getSingleton(BeanDefinition beanDefinition) throws Exception{
        String beanName = beanDefinition.getId();
        Object singletonObject = singletonObjects.get(beanName);
        if (singletonObject == null) {
            singletonObject = createBean(beanDefinition);
            singletonObjects.put(beanName,singletonObject);
            singletonFactories.remove(beanName);
            earlySingletonObjects.remove(beanName);
        }
        return singletonObject;
    }
    

• 4拜鹤、Bean的實(shí)際創(chuàng)建，重點(diǎn)是創(chuàng)建之前把之前放入singletonsCurrentlyInCreation流椒，創(chuàng)建之后把自己的實(shí)例放入bean工廠敏簿，singletonFactories。

    /**
     * 實(shí)際創(chuàng)建Bean的過程
     * 先把自己放入singletonsCurrentlyInCreation宣虾，說明正在創(chuàng)建中
     * 把創(chuàng)建好的實(shí)例放入工廠惯裕。singletonFactories
     * @param beanDefinition
     * @return
     * @throws Exception
     */
    private Object createBean(BeanDefinition beanDefinition) throws Exception{
        String beanName = beanDefinition.getId();
        singletonsCurrentlyInCreation.add(beanName);
        Object bean = beanDefinition.getBeanClass().newInstance();
        if (!singletonObjects.containsKey(beanName)) {
            singletonFactories.put(beanName, bean);
            earlySingletonObjects.remove(beanName);
        }
        populateBean(bean, beanDefinition.getPropertyList());
        return bean;
    }

• 5、注入屬性绣硝，屬性值的類型如果是ref引用類型蜻势，就再循環(huán)調(diào)用doGetBean。同一個Bean在第二次調(diào)用的時候鹉胖，就會拿到工廠里的Bean對象并返回握玛，完成注入。

    public void populateBean(Object bean,List<Map<String,String>> pvs) throws Exception{    
        for (int i = 0; i < pvs.size(); i++) {
            Map<String,String> property = pvs.get(i);
            
            String propName = property.get("propertyName");
            String propValue = property.get("propertyValue");
            String propType = property.get("propertyType");         
            Field declaredField = bean.getClass().getDeclaredField(propName);
            declaredField.setAccessible(true);       
            if ("string".equals(propType)) {
                declaredField.set(bean, propValue);
            }else{
                String beanName = propValue;
                Object beanObject = singletonObjects.get(beanName);             
                if (beanObject!=null) {
                    declaredField.set(bean,beanObject);
                }else{
                    Object refBean = doGetBean(beanClassMap.get(beanName));
                    declaredField.set(bean, refBean);
                }
            }
        }
    }

5甫菠、總結(jié)

關(guān)于循環(huán)依賴挠铲，Spring源碼里處理的時候非常的繞，還有很多內(nèi)部類糅雜在一塊寂诱，剛開始看的我簡直懷疑人生拂苹。最好先弄明白那幾個緩存的含義，再去理解這個流程痰洒。
關(guān)于Spring源碼這一塊就不貼了瓢棒，太分散而且太多，有興趣的小伙伴可以自行翻閱丘喻。
下面推薦一篇博客脯宿，也是寫的是循壞依賴這一塊內(nèi)容。
田小波：循環(huán)依賴的解決辦法