自己写的一个简单的IOC容器

      作为一个学习JAVA只有4个月的同学，我能深切的理解初次接触Spring框架产生的困惑，也同样有探索SpringIOC容器的实现方式的冲动。我觉得IOC的那种将控制转交给容器的方式，配合上java接口，简直是太完美了，能有效的实现对象之间的解耦。于是，我经过自己的努力，自己写了一个IOC容器。

      这个容器是模仿SpringIOC容器写的，操作什么的都非常的相似。同样是通过读取配置文件中的内容来实现注入的。解析配置的XML文件是采用SAX方式，实现注入是采用反射技术。以下是所有的代码：

       首先，我建立3个接口，分别控制容器，bean元素，property元素

容器：

 import java.util.List;

/**

 * IOC容器接口

 * */

public interface IocContainer {

 /**

  * 用于启动IOC容器，根据配置文件完成对容器中所有bean的注册

  * */

 public void startIocContainer(String config);

 /**

  * 用于根据bean对象的id获得IOC容器中的bean的class属性所指向的对象

  * */

 public Object beanToObject(String id);

}

 

Bean：

import org.dom4j.Element;

public interface IocBean {

 /**

  * 根据配置文件的bean元素为当前bean对象赋值

  * */

 public void configToBean(Element bean);

}

 

Property：

import org.dom4j.Element;

public interface IocProperty {

 /**

  * 根据配置文件的bean元素下的property元素为当前property对象赋值

  * */

 public void configToProperty(Element property);

}

然后，根据这三个接口写出对应的三个实现类，其中容器的实现类较为复杂，Object beanToObject方法用到了反射。

容器：

import interfaceIOC.IocContainer;

import java.io.File;

import java.lang.reflect.Method;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.Element;

import org.dom4j.io.SAXReader;

import testEntity.Dao;

public class WizardIocContainer implements IocContainer {

 private Map<String,WizardIocBean> beanMap;

 /**

  * @param config 需要传入配置文件的绝对路径

  * */

 public void startIocContainer(String config) {

  //访问配置文件

  File file=new File(config);

  //用SAX方式解析XML配置文件

  SAXReader reader=new SAXReader();

  try {

   Document doc=reader.read(file);

   Element root=doc.getRootElement();

   List<Element> eles=root.elements("bean");

   //对所有bean元素进行遍历，保存其id属性值到beanMap中

   //System.out.println(eles.size());

   Map<String,WizardIocBean> bMap=new HashMap<String,WizardIocBean>();

   for(Element ele:eles){

    

    WizardIocBean bean=new WizardIocBean();

    bean.configToBean(ele);

    bMap.put(bean.getId(),bean);

   }

   beanMap=bMap;

  } catch (DocumentException e) {

   e.printStackTrace();

  }

  

 }

 public Object beanToObject(String id){

  if(beanMap==null){

   System.out.println("请先启动Ioc容器");

   return null;

  }else{

   //根据id获得bean对象

   WizardIocBean bean=beanMap.get(id);

   //获得class属性中类名

   String className=bean.getClassName();

   //利用反射动态生成对象

   try{

    Class cls=Class.forName(className);

    Object obj=cls.newInstance();

    //为对象注入property中的值

     //获取该bean中的说有property内容

    Map<String,WizardIocProperty> propertyMap=bean.getPropertyMap();

     //若没有property内容，直接返回obj

    if(propertyMap==null){

     return obj;

    }

    //对其进行遍历

    Set<String> propertyNames=propertyMap.keySet();

    for(String propertyName:propertyNames){

     //获取对应的property

     WizardIocProperty property=propertyMap.get(propertyName);

     //若ref为空，直接执行对应的set方法就可以完成对obj对象的注入

     if(property.getRef()==null){

      //获得要注入的值

      String value=property.getValue();

      //拼凑出对应set方法的方法名

      String setName="set"+property.getName().toLowerCase()

           .substring(0, 1).toUpperCase()+

            property.getName()

            .toLowerCase().substring(1);

      //System.out.println(setName);

      //执行set方法,为对象赋值

      try{

       Method methodSet=cls.getMethod(setName, String.class);

       methodSet.invoke(obj, property.getValue());

      }catch(Exception e){

       e.printStackTrace();

      }

     }else{

      //获得ref中的值，这个值对应某一bean的id

      String ref=property.getRef();

      Class cls1=Class.forName(beanMap.get(ref).getClassName());

      String setName1="set"+property.getName().toLowerCase()

        .substring(0, 1).toUpperCase()+

         property.getName()

          .toLowerCase().substring(1);

      try{

       Class paramType=null;

       Method[] methods=cls.getMethods();

       for(Method m:methods){

        

        //System.out.println(m.getName());

        if(setName1.equals(m.getName())){

         Class<?>[] paramTypes=m.getParameterTypes();

         paramType=paramTypes[0];

         Method methodSet=cls.getMethod(setName1,paramType);

         Object obj1=cls1.newInstance();

         methodSet.invoke(obj, obj1);

        }

       }

       

      }catch(Exception e){

       e.printStackTrace();

      }

      

      

     }

    }

    return obj;

   }catch(Exception e){

    e.printStackTrace();

    return null;

     

   }

   

  }

  

  

 }

 

 

 

 

Bean：

import interfaceIOC.IocBean;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.dom4j.Element;

public class WizardIocBean implements IocBean{

 private String id;

 private String className;

 private Map<String,WizardIocProperty> propertyMap;

 public void configToBean(Element bean) {

  id=bean.attributeValue("id");

  className=bean.attributeValue("class");

  List<Element> eles=bean.elements("property");

  Map<String,WizardIocProperty> pMap=new HashMap<String,WizardIocProperty>();

  for(Element ele:eles){

   WizardIocProperty property=new WizardIocProperty();

   property.configToProperty(ele);

   pMap.put(property.getName(), property);

  }

  propertyMap=pMap;

 }

 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 Map<String, WizardIocProperty> getPropertyMap() {

  return propertyMap;

 }

 public void setPropertyMap(Map<String, WizardIocProperty> propertyMap) {

  this.propertyMap = propertyMap;

 }

 

}

 

Property：

import org.dom4j.Element;

import interfaceIOC.IocProperty;

public class WizardIocProperty implements IocProperty {

 private String name;

 private String value;

 private String ref;

 public void configToProperty(Element property) {

  name=property.attributeValue("name");

  value=property.attributeValue("value");

  ref=property.attributeValue("ref");

 }

 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 version="1.0" encoding="UTF-8"?>

<beans>

 <bean id="jdbcdao" class="testEntity.JdbcDao"></bean>

 <bean id="myBatisdao" class="testEntity.MyBatisDao"></bean>

 <bean id="testDao" class="testEntity.TestController">

  <property name="where" value="这里"></property>

  <property name="dao" ref="myBatisdao"></property>

 </bean>

</beans>

 

 

测试类：

Dao接口：

public interface Dao {

 public void excute();

}

JDBCDao实现类

public class JdbcDao implements Dao {

 public void excute(){

  System.out.println("JdbcDao方式");

 }

}

MyBatisDao实现类

public class MyBatisDao implements Dao {

 public void excute(){

  System.out.println("MyBatisDao方式");

 }

}

 

 

TestController（为其分别注入dao 和 where）

public class TestController {

 private Dao dao;

 private String where;

 

 

 public Dao getDao() {

  return dao;

 }

 public void setDao(Dao dao) {

  this.dao = dao;

 }

 public String getWhere() {

  return where;

 }

 public void setWhere(String where) {

  this.where = where;

 }

 public void excute(){

  System.out.println(where);

  dao.excute();

 }

}

 

最后测试：

 

public class TestWizardSet {

 public static void main(String[] args) {

  String config="src/WizardIocContainerConfig.xml";

  WizardIocContainer wic=new WizardIocContainer();

  wic.startIocContainer(config);

  TestValue tv=(TestValue)wic.beanToObject("testValue");

  tv.excute();

 }

}

        当在配置中为dao注入不同的类是，如注入jdbcDao则执行jdbcDao中的excute方法，注入mybatisDao这执行mybatisDao中的excute方法，这样就可以实现dao的解耦，在代码不变的情况下，执行不同的逻辑。