自己動手寫spring容器(2)

上篇我們自己寫了一個很簡單的spring容器，該容器只是做了簡單的bean的實例化，並沒有spring的核心之一的IOC（依賴注入），也叫做控制反轉，這里我就不講這個的具體含義，不知道的園友可以自行百度，百度上有很多介紹spring IOC的，在這里我們要實現的就是spring的IOC

首先，我們需要准備一個bean的配置文件，在上篇額配置文件基礎上加入了Dao的內容，現在我們要做的就是service對Dao的依賴注入。

1　　 <bean id="personService" class="com.yangyang.service.impl.PersonServiceImpl">
        <property name="personDao" ref="personDao"></property>
        <property name="age" value="10"></property>
    </bean>
    <bean id="personDao" class="com.yangyang.dao.impl.PersonDaoImpl">
    </bean>

 分析這個xml文件，知需要建立一個PropertyDefinition類，用來存儲Property的屬性，在此只列舉了name,ref,value三個簡單的屬性，對集合類型的屬性暫時沒有做處理。

package com.juit;

/**
 * 屬性模型
 * @author Administer
 *
 */
public class PropertyDefinition {

    /**
     * 屬性名稱
     */
    private String name;
    /**
     * 屬性引用值
     */
    private String ref;
    
    /**
     * 屬性value值
     */
    private String value;
    public PropertyDefinition(String name, String ref,String value) {
        this.name = name;
        this.ref = ref;
        this.value=value;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getRef() {
        return ref;
    }
    public void setRef(String ref) {
        this.ref = ref;
    }
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    };
}

當然，由於property 在bean 的下面，因此需要在BeanDefinition中加入PropertyDefinition：

完整的BeanDefinition如下：

package com.juit;

import java.util.ArrayList;
import java.util.List;

/**
 * Bean對象
 * @author Administer
 *
 */
public class BeanDefinition {

    private String id;//bean的id
    private String className;//bean的類
    private List<PropertyDefinition> propertyDefinitions=new ArrayList<PropertyDefinition>();//bean對象的屬性
    
    public BeanDefinition(String id, String className) {
        this.id = id;
        this.className = className;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getClassName() {
        return className;
    }
    public void setClassName(String className) {
        this.className = className;
    }
    public List<PropertyDefinition> getPropertyDefinitions() {
        return propertyDefinitions;
    }
    public void setPropertyDefinitions(List<PropertyDefinition> propertyDefinitions) {
        this.propertyDefinitions = propertyDefinitions;
    }
}

並在解析xml文件的地方加入對property的解析，完整的readXml如下：

private void readXml2(String fileName) {
        //創建一個讀取器
        SAXReader saxReader=new SAXReader();
        Document document=null;
        try {
            //獲取要讀取的配置文件的路徑
            URL xmlPath=this.getClass().getClassLoader().getResource(fileName);
            //讀取文件內容
            document=saxReader.read(xmlPath);
            //獲取xml中的根元素
            Element rootElement=document.getRootElement();
            for (Iterator iterator = rootElement.elementIterator(); iterator.hasNext();) {
                Element element = (Element) iterator.next();
                String id=element.attributeValue("id");//獲取bean的id屬性值
                String clazz=element.attributeValue("class");//獲取bean的class屬性值
                BeanDefinition beanDefinition=new BeanDefinition(id,clazz);
                //獲取bean的Property屬性
                for (Iterator subElementIterator = element.elementIterator(); subElementIterator.hasNext();) {
                    Element subElement = (Element) subElementIterator.next();
                    String propertyName=subElement.attributeValue("name");
                    String propertyRef= subElement.attributeValue("ref");
                    String propertyValue=subElement.attributeValue("value");
                    PropertyDefinition propertyDefinition=new PropertyDefinition(propertyName, propertyRef,propertyValue);
                    beanDefinition.getPropertyDefinitions().add(propertyDefinition);
                }
                beanDefines.add(beanDefinition);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

接下來就要來實現關鍵的對依賴對象的注入功能的邏輯了。

public YhdClassPathXmlApplicationContext(String fileName){
        
        //1.讀取spring的配置文件
            this.readXml(fileName);
        //2.實例化bean
        this.instanceBeans();
        //3.實現對依賴對象的注入功能
        this.injectObject();
    }    

下面來完成injectObject這個功能：

/**
     * 為bean對象的屬性注入值
     * 
     * Administer
     * 2013-8-18 下午7:59:03
     */
    private void injectObject() {
        //遍歷配置文件中定義的所有的bean
        for (BeanDefinition beanDefinition : beanDefines) {
            //找到要注入的bean
            Object bean=sigletons.get(beanDefinition.getId());
            if (bean != null) {
                try {
                    BeanInfo info = Introspector.getBeanInfo(bean.getClass());//通過類Introspector的getBeanInfo方法獲取對象的BeanInfo 信息
                    //通過BeanInfo來獲取屬性的描述器(PropertyDescriptor),通過這個屬性描述器就可以獲取某個屬性對應的getter/setter方法,然后我們就可以通過反射機制來調用這些方法。
                    PropertyDescriptor[] pds = info.getPropertyDescriptors();//獲得 bean所有的屬性描述
                    //遍歷要注入的bean的所有屬性
                    for (PropertyDefinition propertyDefinition : beanDefinition.getPropertyDefinitions()) {
                        //遍歷要注入bean通過屬性描述器得到的所有屬性以及行為
                        for (PropertyDescriptor propertyDescriptor : pds) {
                            //用戶定義的bean屬性與java內省后的bean屬性名稱相同時
                            if (propertyDefinition.getName().equals(propertyDescriptor.getName())) {
                                Method setter=propertyDescriptor.getWriteMethod();//獲取屬性的setter方法
                                //取到了setter方法
                                if (setter != null) {
                                    Object value=null;//用來存儲引用的值
                                    if (propertyDefinition.getRef() != null && !propertyDefinition.getRef().equals("")) {
                                        value=sigletons.get(propertyDefinition.getRef());//獲取引用的對象的值
                                    }else {
                                        //ConvertUtil依賴兩個jar包，一個是common-beanutils,而common-beanutils又依賴common-logging
                                        //ConvertUtil將任意類型轉化為需要的類型
                                        value=ConvertUtils.convert(propertyDefinition.getValue(), propertyDescriptor.getPropertyType());
                                    }
                                    setter.setAccessible(true);//保證setter方法可以訪問私有
                                    try {
                                        setter.invoke(bean, value);//把引用對象注入到屬性
                                    } catch (Exception e) {
                                        e.printStackTrace();
                                    }
                                }
                                break;//找到了注入的屬性后，跳出循環
                            }
                        }
                    }
                } catch (IntrospectionException e) {
                    e.printStackTrace();
                }
            }
        }
    }

這里用到了commons-beanutils-core-1.8.3.jar、commons-logging-1.1.1.jar這兩個jar，大家可以到apache的網站上進行下載，主要是用到了ConvertUtils.convert將任意類型轉化為需要的類型的方法。

其實依賴注入的思想也很簡單，它是通過反射機制實現的。

最后還剩下一步測試，同理

    @Test
    public void testInstanceSping() {
        YhdClassPathXmlApplicationContext ctx=new YhdClassPathXmlApplicationContext("resources/beans.xml");
        PersonService personService=(PersonService)ctx.getBean("personService");
        personService.savePerson();
    }

personService接口代碼：

package com.yangyang.service;

public interface PersonService {
    public void savePerson();

}

PersonServiceImpl實現的代碼：

package com.yangyang.service.impl;

import com.yangyang.dao.PersonDao;
import com.yangyang.service.PersonService;

public class PersonServiceImpl implements PersonService{
    private PersonDao personDao;
    private Integer age;
    
    public PersonDao getPersonDao() {
        return personDao;
    }
    
    public void setPersonDao(PersonDao personDao) {
        this.personDao = personDao;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public void savePerson() {
        System.out.println("age:"+age);
        System.out.println("service中的save方法調用成功");
        personDao.savePerson();
    }

}

在控制台上我們可以看到：

age:10

service中的save方法調用成功

好，這樣依賴注入就完成了，下篇就要來實現比這個稍微復雜的注解的依賴注入的實現，敬請期待。。。