容器学习(一):动手模拟spring的IoC

介绍

学习经典框架的实现原理以及设计模式在其实际中的运用,是非常有必要的,可以让我们更好进行面向对象。

 

本篇文章就来模拟Spring的IOC功能,明白原理后,可以更好的使用它,进而为进行面向对象提供一种思路。

 

点击下载源码:下载

 

动手模拟IoC实现

首先我们把我们用的daoserviceentity定义出来:

Student.java :

package com.bzu.entity;  
  public class Student {  
  private int id;  
  private String name;  
  private String address;  
  ******************set、get方法省略  
} 

 

因为spring提倡的就是面向接口编程,所以在我们写dao层和service层具体实现之前,我们先定义接口,让我们的具体实现实现接口。接口的代码很简单,在这就不贴出来了。

StudentdaoImp.java  
public class StudentDaoImp implements StudentDao {  
public void add(Student stu) {  
System.out.println("stu is saved");  
}  
}  

 

StudentServiceImp.java

public class StudentServiceImp implements StudentService {  
StudentDao stuDao=null;  
public StudentDao getStuDao() {  
return stuDao;  
}  
public void setStuDao(StudentDao stuDao) {  
this.stuDao = stuDao;  
}  
@Override  
public void add(Student stu) {  
stuDao.add(stu);  
}  
} 


      这里要注意的是,我们这里是模拟spring,主要模拟spring中的IOC功能,所以在此我们一样要在service层中定义dao的实例,当然不用new出来,我们就通过springIOC把这里的dao层注入进来。不要忘了对dao提供setGet方法,因为IOC的底层其实就是利用反射机制实现的,他把dao注入进来,其实底层就是通过反射set进来的。

     我们所需的dao层、service层还有entity定义好了之后,下一步我们就是定义我们自己的ClassPathXmlApplicationContext类了,通过他,在我们new出他的对象的时候,他来加载配置文件,然后把我们的dao操作注入到我们的service层,在spring中,ClassPathXmlApplicationContext类实现了BeanFactory接口,在此我们也定义一个BeanFactory接口,其实这个接口没什么具体的作用,我们就是为了来模拟spring

 

在定义这个接口和实现类之前,我们先来看一下我们所需的xml是怎么编写的,下面我们就具体来看一下beans.xml的配置:

Beans.xml

<beans>  
<bean id="stuDao" class="com.bzu.dao.imp.StudentDaoImp" />  
<bean id="stuService" class="com.bzu.service.imp.StudentServiceImp" >  
<property name="stuDao" bean="stuDao"/>  
</bean>  
</beans> 

 

       好了,配置文件我们看完了,下一步我们一起来看一下我们的spring容器——ClassPathXmlApplicationContext具体是怎么实现的,我们首先还是来看一下他的接口定义:

BeanFactory.java:

public interface BeanFactory {  
public Object getBean(String id);  
}  

 

我们看到,接口其实很简单,就定义了一个getBean方法,下面我们来看一下具体的实现类:

ClassPathXmlApplicationContext.java

public class ClassPathXmlApplicationContext implements BeanFactory{
 
private Map<String, Object> beans = new HashMap<String,Object>();
 
public ClassPathXmlApplicationContext() throws Exception,Exception {
SAXBuilder sb = new SAXBuilder();
 
Document doc = sb.build(this.getClass().getClassLoader()
.getResourceAsStream("beans.xml")); // 构造文档对象
Element root = doc.getRootElement(); // 获取根元素HD
List list = root.getChildren("bean");// 取名字为bean的所有元素
 
for (int i = 0; i < list.size(); i++) {
Element element = (Element) list.get(i);
String id = element.getAttributeValue("id");
String clazz = element.getAttributeValue("class");
Object o = Class.forName(clazz).newInstance();
System.out.print("bean id is " + id);
System.out.println(", clazz is " + clazz);
beans.put(id, o);
 
// 遍历property
for (Element propertyElement : (List<Element>) element
.getChildren("property")) {
String name = propertyElement.getAttributeValue("name");// userDAO
String bean = propertyElement.getAttributeValue("bean");// u
Object beanObject = beans.get(bean);// UserDAOImpl instance
 
// 构造setter方法
String methodName = "set" + name.substring(0,1).toUpperCase()
+ name.substring(1);
System.out.println("setter method name = " +methodName);
 
Method m = o.getClass().getMethod(methodName,
beanObject.getClass().getInterfaces()[0]);
m.invoke(o, beanObject);
}
 
}
}
 
@Override
public Object getBean(String id) {
return beans.get(id);
}
 
}

     首先我们定义了一个容器Map<String, Object> beans,这个容器的作用就是用来装我们从配置文件里解析来的一个个bean,为什么要用map类型,我想大家也差不多能猜到吧,我们配置文件中每一个bean都有一个id来作为自己的唯一身份。我们把这个id存到mapkey里面,然后value就装我们的具体bean对象。

     说完这个容器之后,下面我们在来看一下ClassPathXmlApplicationContext的构造方法,这个构造方法是我们spring管理容器的核心,这个构造方法的前半部分是利用的jdom解析方式,把xml里面的bean一个个的解析出来,然后把解析出来的bean在放到我们bean容器里。后半部分主要是在对配置文件进行解析出bean的同时去查看一下这个bean中有没有需要注射bean的,如果有的话,他就去通过这些里面的property属性获取他要注射的bean名字,然后构造出set方法,然后通过反射,调用注入beanset方法,这样我们所需要的bean就被注入进来了。

      最后我们就来看一下实现接口的getBean放了,其实这个方法很简单,就是根据提供的beanid,从bean容器内把对应的bean取出来。

 

好了,我们所需的东西都定义好了,下面我们据来测试一下,看看我们自己模仿的spring到底能不能自动把我们所需要的dao层给我们注入进来。

public static void main(String[] args) throws Exception {  
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext();  
Student stu = new Student();  
StudentService service = (StudentService) context.getBean("stuService");  
service.add(stu);  
}  

运行代码,控制台输出:

bean idis stuDao, clazz is com.bzu.dao.imp.StudentDaoImp

bean idis stuService, clazz is com.bzu.service.imp.StudentServiceImp

settermethod name = setStuDao

stu issaved

       

  总结

   好,成功注入进来,到此,我们模仿spring Ioc就到此结束了,最后通过图解的方式总结下有了IoC后的好处

   常规代码,不借助IoC,类和类的关系应该是这样的


StudentServiceImp需要依赖StudentdaoImp,这种依赖关系在程序未运行就确定了。

 

有了spring容器,借助IoC,类和类的关系应该是这样的


StudentServiceImp不再依赖StudentdaoImp,而是通过Spring提供服务的方式,将StudentServiceImp和StudentdaoImp联系在一起,而且这种依赖关系是在程序运行时才确定的。

StudentServiceImp独立了,独立意味着简单灵活,所以IoC延迟注入的思想,在进行面向对象开发中必不可少的利器。

容器学习(一):动手模拟spring的IoC,古老的榕树,5-wow.com

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。