前言

上一节我们分析了Spring的实例化和IOC过程。在熟悉了Spring的处理流程后，我们自己能不能写一个IOC的容器和实现依赖注入呢？要注意哪些问题呢？本章节我们重点关注两个问题。

• 手写一个简单的IOC容器并实现依赖注入
• 分析Spring是怎样解决循环依赖的问题

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文件的路径。获取文件的输入流，转成Document对象解析即可，这点和Spring的做法是一致的。并把property属性简单化处理，放在一个List<Map<String，String>>中。

    /***
     * 遍历XML文件，解析bean标签
     * @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、实例化

拿到beanName的集合，遍历进行实例化和依赖注入。

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、测试

进行main函数，看看测试结果。

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

输出结果如下

roleId:r_2001
roleName:管理员
-----------------
userId:u_1001
userName:吴蓓蓓
userRoleName:管理员
-----------------

从结果来看，这两个Bean的实例化和依赖注入是没问题的，完成了我们的本章节提出的第一个小目标。

4、循环依赖

如果我们把配置文件改一下，让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="管理员"/>
        <property name="user" ref="user"></property>
    </bean> 
</beans>

哈哈，不敢运行。就上面的代码而言，它肯定会死循环。User依赖Role，注入的时候发现还没有Role的实例，就先去实例化Role；实例化Role的时候，又发现依赖了User，再去实例化User...好了，下面我们看下Spring是怎么解决这事的。
分析Spring之前，我们先来了解几个缓存的定义

名称	作用
singletonObjects	用于存放完全初始化好的 bean，从该缓存中取出的 bean 可以直接使用
earlySingletonObjects	存放原始的 bean 对象（尚未填充属性），用于解决循环依赖
singletonFactories	存放 bean 工厂对象，用于解决循环依赖
singletonsCurrentlyInCreation	当前正在创建的bean的名称

看到这几个缓存，我们可以大概理出一个思路。

1、实例化Bean的时候，先从singletonObjects查找缓存，
如果命中就可以直接返回，未命中的话先把Bean放入singletonsCurrentlyInCreation，说明自己正在创建中。
2、具体开始实例化。完成后，把beanName和对应的bean工厂放入singletonFactories。
3、依赖注入，当有循环依赖的时候，重复第1个步骤。
还是从singletonObjects查找缓存，虽然还是未命中，但是发现bean正在创建中了。
然后从singletonFactories中获取bean的工厂对象，拿到该Bean的对象。然后把这个Bean提前曝光，放入earlySingletonObjects。
4、注入完成，循环依赖问题解决。

来看个流程图，再整理下思路。

Spring IOC循环依赖

基于上面的思路，把上面我们自己实现的代码重新改造一下。全部代码在GitHub:手写简单IOC容器，大家可以拿下来运行一下看看。

• 1、还是先遍历所有的beanName

    /**
     * 遍历XML中配置的bean，进行实例化和IOC
     * @throws Exception
     */
    private void doLoadBeanDefinitions() throws Exception{
        for(String beanName:beanNames){
            BeanDefinition beanDefinition = beanClassMap.get(beanName);
            doGetBean(beanDefinition);
        }
    }

• 2、 获取Bean实例

    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方法。第一个主要是为了判断是否正在创建中，如果是就从工厂里先拿到一个Bean返回；第二个是Bean实际创建过程。

    /**
     * 先从缓存中获取，如果未命中并且没有在创建中，返回NULL
     * 如果Bean正在创建中，从工厂中先拿到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，如果未命中，直接创建，并把创建完且注入完成的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的实际创建，重点是创建之前把之前放入singletonsCurrentlyInCreation，创建之后把自己的实例放入bean工厂，singletonFactories。

    /**
     * 实际创建Bean的过程
     * 先把自己放入singletonsCurrentlyInCreation，说明正在创建中
     * 把创建好的实例放入工厂。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引用类型，就再循环调用doGetBean。同一个Bean在第二次调用的时候，就会拿到工厂里的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、总结

关于循环依赖，Spring源码里处理的时候非常的绕，还有很多内部类糅杂在一块，刚开始看的我简直怀疑人生。最好先弄明白那几个缓存的含义，再去理解这个流程。
关于Spring源码这一块就不贴了，太分散而且太多，有兴趣的小伙伴可以自行翻阅。
下面推荐一篇博客，也是写的是循坏依赖这一块内容。
田小波：循环依赖的解决办法