自己实现spring IOC

自己实现一个简易版的ioc容器，通过xml配置文件来加载bean

首先编写需要用到的bean，这里写三个简单的bean分别是A,B,C

package com.bean;

public class A {
    
    private String name;
    public A() {
        System.out.println("创建A");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

package com.bean;

public class B {
    
    
    private A a;
    public B() {
        System.out.println("创建B");
    }
    
    public A getA() {
        return a;
    }
    public void setA(A a) {
        this.a = a;
    }

}

package com.bean;

public class C {
    private B b;
    public C() {
        System.out.println("创建C");
    }
    public B getB() {
        return b;
    }
    public void setB(B b) {
        this.b = b;
    }

}

接下来编写配置文件 applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans>
    

    <bean name="a" class="com.bean.A" >
        <property name="name" value="Tom">
        </property>
    </bean>
    
    
    <bean name="b" class="com.bean.B" scope="prototype">
        <property name="a" ref="a">
        </property>
    </bean>
    
    <bean name="c" class="com.bean.C" scope="prototype">
        <property name="b" ref="b">
        </property>
    </bean>
    
</beans>

然后是保存bean信息的类，bean信息包括：bean的name，class，scope，和property

这里的scope值只设定为singleton和prototype两种，spring中bean 的scope值默认为singleton，表示在同一个ioc容器中只有一个实例，而prototype则是每次getBean()都会得到一个新的实例。

property有可能是一个普通属性，也可能是引用另一个bean

package com.config;

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

public class Bean {
    
    private String name;
    private String className;
    private String scope = "singleton";//scope默认为singleton
    
    private List<Property> properties = new ArrayList<Property>();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public List<Property> getProperties() {
        return properties;
    }

    public void setProperties(List<Property> properties) {
        this.properties = properties;
    }
    //重新toString 方法 为了测试的时候可能明确看到读取的bean信息
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "Bean[name="+name+" class="+className+" scope="+scope+" property="+properties+"]";
    }

    public String getScope() {
        return scope;
    }

    public void setScope(String scope) {
        this.scope = scope;
    }

}

package com.config;

public class Property {
    
    private String name;
    private String value; //value表示普通的属性值
    private String ref;   //ref表示引用的其他bean的name
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }
    public String getRef() {
        return ref;
    }
    public void setRef(String ref) {
        this.ref = ref;
    }

}

读取和解析xml文件，得到bean的信息，将其封装为bean对象，返回一个Map<beanName,bean>

package com.config.parse;

import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import com.config.Bean;
import com.config.Property;

public class ConfigManager {
    
    //读取配置文件，并返回读取结果
    public static Map<String,Bean> getConfig(String path){
        Map<String,Bean> map = new HashMap<String,Bean>();
        //dom4j 实现
        //1.创建解析器
        SAXReader reader = new SAXReader();
        //2，加载配置文件=> document对象
        InputStream is = ConfigManager.class.getResourceAsStream(path);
        Document doc = null;
        try {
            doc = reader.read(is);
        } catch (DocumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        //3.定义xpath表达式，取出所有Bean对象
        String xpath = "//bean";
        //4.对Bean元素进行遍历
        List<Element> list = doc.selectNodes(xpath);
        if(list != null){
            for(Element beanEle : list){
                //将bean元素的name/class 属性封装到Bean对象中
                String name = beanEle.attributeValue("name");
                String className = beanEle.attributeValue("class");
                String scope = beanEle.attributeValue("scope");
                
                Bean bean = new Bean();
                bean.setName(name);
                bean.setClassName(className);
                if(null != scope){ //不设置scope值时，默认为singleton
                    bean.setScope(scope);
                }
                //获得Bean元素下的所有property子元素，将属性封装到Property对象
                List<Element> children = beanEle.elements("property");
                
                if(children != null){
                    for(Element child : children){
                        Property prop = new Property();
                        String pName = child.attributeValue("name");
                        String pValue = child.attributeValue("value");
                        String pRef = child.attributeValue("ref");
                        
                        prop.setName(pName);
                        prop.setValue(pValue);
                        prop.setRef(pRef);
                        //将Property封装到Bean对象
                        bean.getProperties().add(prop);
                    }
                }
                //将Bean对象封装到Map中（用于返回）
                map.put(name, bean);
            }
        }
           
        //5.返回Map结果
        return map;
    }

}

利用反射创建bean实例并将属性注入，在容器初始化的时候，先将所有作用域为singleton的bean加载到容器中，而prototype类型的bean不会保存在容器中，每次调用getBean时都会创建一个实例。

首先创建一个beanFactory

package com.main;

public interface BeanFactory {
    
    //根据Bean的name获得Bean对象的方法
    Object getBean(String beanName);

}

实现了beanFactory，并创建容器和bean的类

package com.main;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

import com.config.Bean;
import com.config.Property;
import com.config.parse.ConfigManager;
import com.utils.BeanUtils;

public class ClassPathXmlApplicationContext implements BeanFactory {
    
    //希望在ClassPathXmlApplicationContext类一创建
    //就初始化spring容器（装载Bean实例）
    
    private Map<String, Bean> config; //获取的配置文件
    //使用一个map来作为容器
    private Map<String, Object> context = new HashMap<String, Object>(); 

    @Override
    public Object getBean(String beanName) {
        //根据bean的名称获得bean实例
        
        Object bean = context.get(beanName);
        //如果bean的scope属性为prototype，那么context中不会包含该bean，需要创建该bean并返回
        if(null == bean){
            bean= createBean(config.get(beanName));
        }
        
        return bean;
    }
    public ClassPathXmlApplicationContext(String path) {
        //1.读取配置文件获得需要初始化的Bean信息
        config = ConfigManager.getConfig(path);
        //2.遍历配置，初始化Bean
        if(config != null){
            for(Entry<String, Bean> en : config.entrySet()){
                //获取配置中的Bean信息
                String beanName = en.getKey();
                Bean bean = en.getValue();
                Object existBean = context.get(beanName);
                //先判断容器中是否已存在该bean,因为createBean方法在创建并将一个bean加载到容器时，也会创建并加载它引用的bean
                if(existBean == null && bean.getScope().equals("singleton")){
                    //如果不存在，并且bean的scope属性为singleton时才将其放入容器中
                    //根据bean配置创建bean对象
                    Object beanObj = createBean(bean);
    //                System.out.println(beanObj);
                    //3.将初始的Bean放入容器
                    context.put(beanName, beanObj);
                }
            }
        }
       
    }
    
    private Object createBean(Bean bean){
        //1.获得要创建的bean的Class
        String className = bean.getClassName();
        Class clazz = null;
        try {
            clazz = Class.forName(className);
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        //获得class后将class对应的对象创建出来
        Object beanObj = null;
        try {
            beanObj = clazz.newInstance();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        //2.获得Bean的属性，将其注入
        if(bean.getProperties() != null){
            for(Property prop : bean.getProperties()){
                
                //获得要注入的元素名称（属性名或者bean名）
                String name = prop.getName();
                //根据属性名称获得对应属性的set方法
                Method setMethod = BeanUtils.getWriteMethod(beanObj, name);
                
                Object param = null;
                //注入分两种情况
                if(prop.getValue() != null){
                    //1.value属性注入
                    //获得要注入的属性值，为了简单起见，这里没有考虑属性类型转换的问题，通常，从配置文件中直接读取的属性值都为String类型，还需要转换成具体Bean中所定义的类型
                    param = prop.getValue();
                                        
                }
                if(prop.getRef() != null){
                    //2.其他bean的注入
                    //要注入其他bean到当前bean中，先从容器中查找，当前要注入的bean是否已经创建并放入容器中
                    Object existBean = context.get(prop.getRef());
                    if(existBean == null){
                        //容器中不存在要注入的bean，创建该bean
                        existBean = createBean(config.get(prop.getRef()));
                        //将创建好的单例bean放入容器中
                        if(config.get(prop.getRef()).getScope().equals("singleton"))
                            context.put(prop.getRef(), existBean);
                    }
                    param = existBean;
                }
                
                try {
                    //调用set方法注入该属性
                    setMethod.invoke(beanObj, param);
                } catch (IllegalArgumentException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        return beanObj;
    }

}

上面用到了setXxx方法来注入属性，首先需要获得该类的setXxx方法，这里自己实现了一个简单的BeanUtils，也可以使用apache提供的BeanUtils

顺便提一下javaBean的一个命名规范，java的属性变量名都必须以小写字母开头，在特殊情况下也允许大写字母开头的属性变量名，不过必须满足“变量的前两个字母要么全部大写，要么全部小写”，例如iDcode这种命名是非法的，在sping中如果这样配置了属性名，将找不到setter方法。

package com.utils;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;



public class BeanUtils {


    //参数1.bean对象
    //参数2.要获得bean对象的属性名
    public static Method getWriteMethod(Object beanObj, String name) {
        // TODO Auto-generated method stub
        
        Class<?> className = beanObj.getClass();
        Method writeMethod = null;
        /*使用反射
        Field field = null;
        try {
            field = className.getDeclaredField(name);
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
        String firstLetter = name.substring(0, 1).toUpperCase();
        String methodName = "set"+firstLetter+name.substring(1);
        
        try {
            writeMethod = className.getDeclaredMethod(methodName, field.getType());
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        */
        
        //使用内省introspector 内省(IntroSpector)是Java语言对JavaBean 类属性、事件的一种缺省处理方法
        
        try {
            //1.分析bean对象，得到BeanInfo
            BeanInfo beanInfo = Introspector.getBeanInfo(className);
            //2.根据BeanInfo获得所有属性的描述器
            PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
            
            //3.遍历描述器
               
            if(descriptors != null){
                for(PropertyDescriptor descriptor : descriptors){
                    //判断当前遍历的描述器所描述的属性是否是我们要找的属性
                    if(name.equals(descriptor.getName())){
                        //4.如果找到了，返回该属性的set方法，如果没有找到抛出异常，提醒用户创建该属性的set方法
                        writeMethod = descriptor.getWriteMethod();
                        break;
                    }
                }
            }
            if(writeMethod == null){
                new Throwable("请创建创建该"+name+"属性的set方法");
            }
            
        } catch (IntrospectionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
        
        return writeMethod;
        
    }
    

}

接下来写一个测试类

package com.test;

import java.util.Map;

import com.bean.A;
import com.bean.B;
import com.bean.C;
import com.config.Bean;
import com.config.parse.ConfigManager;
import com.main.BeanFactory;
import com.main.ClassPathXmlApplicationContext;

public class Test {

    @org.junit.Test
    public void fun(){
        BeanFactory bf = new ClassPathXmlApplicationContext("/applicationContext.xml");
        
//        A a = (A) bf.getBean("a");
//        A a2 = (A) bf.getBean("a");
//        A a3 = (A) bf.getBean("a");
//        
//        
//        System.out.println(a.getName());
//        
//        B b = (B) bf.getBean("b");
//        B b2 = (B) bf.getBean("b");
//        B b3 = (B) bf.getBean("b");
//        System.out.println(b.getA().getName());
        C c = (C) bf.getBean("c");
        C c2 = (C) bf.getBean("c");
        C c3 = (C) bf.getBean("c");
    }

}

输出的结果如下：

创建A
创建C
创建B
创建C
创建B
创建C
创建B

结果分析，其中A为singleton类型，所以在初始化时只创建了一次，B和C都是prototype类型，每次调用getBean时都会创建一次，其中C，引用了B，B引用了A，所以创建C的时候需要先检查B和A，这时A已经在初始化时创建了，所以每次创建C时都会创建一次B。