Java程序员从笨鸟到菜鸟之（六十八）细谈Spring（二）自己动手模拟spring

手写Spring IOC容器

最新推荐文章于 2018-11-14 10:21:32 发布

转载最新推荐文章于 2018-11-14 10:21:32 发布 · 194 阅读

本文通过手写简易版Spring框架的IOC容器，演示了如何利用Java反射机制实现类的实例化及依赖注入过程。

在我们学习spring之前，根据spring的特性，我们来自己来模拟一个spring出来，也就是说不利用spring来实现spring的效果。本实例主要是实现spring的IOC功能。

点击下载源码：用力点

首先我们把我们用的dao、service、entity定义出来：

Student.Java :

[java]view plaincopy 
   
print?
 package com.bzu.entity;  
 public class Student {  
 private int id;  
 private String name;  
 private String address;  
 ******************set、get方法省略  
 }  

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

[java]view plaincopy 
   
print?
 StudentdaoImp.java  
 public class StudentDaoImp implements StudentDao {  
 public void add(Student stu) {  
 System.out.println("stu is saved");  
 }  
 }  

StudentServiceImp.java

[java]view plaincopy 
   
print?
 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出来，我们就通过spring的IOC把这里的dao层注入进来。不要忘了对dao提供set。Get方法，因为IOC的底层其实就是利用反射机制实现的，他把dao注入进来，其实底层就是通过反射set进来的。

好了，我们所需的dao层、service层还有entity定义好了之后，万事俱备只欠东风了，下一步我们就是定义我们自己的ClassPathXmlApplicationContext类了，通过他，在我们new出他的对象的时候，他来加载配置文件，然后把我们的dao操作注入到我们的service层，在spring中，ClassPathXmlApplicationContext类实现了BeanFactory接口，在此我们也定义一个BeanFactory接口，其实这个接口没什么具体的作用，我们就是为了来模拟spring。在定义这个接口和实现类之前，我们先来看一下我们所需的xml是怎么编写的，下面我们就具体来看一下beans.xml的配置：

Beans.xml：

[html]view plaincopy 
   
print?
 <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中那么多繁琐的配置，当然啦，我们这是只是实现其中的一个功能，spring提供了很多那么强大的功能，配置当然繁琐一些了。相信上边的代码不用我解释大家也能看懂了吧。

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

BeanFactory.java:

[java]view plaincopy 
   
print?
 public interface BeanFactory {  
 public Object getBean(String id);  
 }  

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

ClassPathXmlApplicationContext.java

[java]view plaincopy 
   
print?
 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");// 取名字为disk的所有元素  
 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.println(id);  
 System.out.println(clazz);  
 beans.put(id, o);  
 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  
 String methodName = "set" + name.substring(0, 1).toUpperCase()  
 + name.substring(1);  
 System.out.println("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存到map的key里面，然后value就装我们的具体bean对象。说完这个容器之后，下面我们在来看一下ClassPathXmlApplicationContext的构造方法，这个构造方法是我们spring管理容器的核心，这个构造方法的前半部分是利用的jdom解析方式，把xml里面的bean一个个的解析出来，然后把解析出来的bean在放到我们bean容器里。如果这段代码看不懂的话，那你只好在去看看jdom解析xml了。好了，我们下面在来看一下这个构造的方法，后半部分主要是在对配置文件进行解析出bean的同时去查看一下这个bean中有没有需要注射bean的，如果有的话，他就去通过这些里面的property属性获取他要注射的bean名字，然后构造出set方法，然后通过反射，调用注入bean的set方法，这样我们所需要的bean就被注入进来了。如果这段代码你看不懂的话，那你只能去看一下有关反射的知识了。最后我们就来看一下实现接口的getBean放了，其实这个方法很简单，就是根据提供的bean的id，从bean容器内把对应的bean取出来。

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

[java]view plaincopy 
   
print?
 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);  
 }  

运行代码，控制台输出：

com.bzu.service.imp.StudentServiceImp

method name = setStuDao

stu is saved

好，成功注入进来，到此，我们模仿的spring就到此结束了，下一篇我们就开始对spring进行一个全面深入了解了，敬请期待。

建议不要硬着头皮看spring代码，本身的代码800多m，就是不上班开始看也不知道什么时候看完。如果想学学ioc,控制反转这些建议看看jodd项目，比较简练，但是我仍然不建议过多的看这些框架的代码，因为这些代码要完成任务需要很多琐碎的类实现，比如读取某个包下面的所有类，解析class的头文件,反射各种信息，再加上封装，很有可能在读源码的过程中掉到各种细节里出不来，所以读这种源码要事无巨细，理解原理即可。
基本原理其实就是通过反射解析类及其类的各种信息，包括构造器、方法及其参数，属性。然后将其封装成bean定义信息类、constructor信息类、method信息类、property信息类，最终放在一个map里，也就是所谓的container，池等等，其实就是个map。。汗。。。。当你写好配置文件，启动项目后，框架会先按照你的配置文件找到那个要scan的包，然后解析包里面的所有类，找到所有含有@bean，@service等注解的类，利用反射解析它们，包括解析构造器，方法，属性等等，然后封装成各种信息类放到一个map里。每当你需要一个bean的时候，框架就会从container找是不是有这个类的定义啊？如果找到则通过构造器new出来（这就是控制反转，不用你new,框架帮你new），再在这个类找是不是有要注入的属性或者方法，比如标有@autowired的属性，如果有则还是到container找对应的解析类，new出对象，并通过之前解析出来的信息类找到setter方法，然后用该方法注入对象（这就是依赖注入）。如果其中有一个类container里没找到，则抛出异常，比如常见的spring无法找到该类定义，无法wire的异常。还有就是嵌套bean则用了一下递归，container会放到servletcontext里面，每次reQuest从servletcontext找这个container即可，不用多次解析类定义。如果bean的scope是singleton，则会重用这个bean不再重新创建，将这个bean放到一个map里，每次用都先从这个map里面找。如果scope是session，则该bean会放到session里面。仅此而已，没必要花更多精力。建议还是多看看底层的知识。