Spring实践（一）IOC的原理和实现机制

Spring是java中非常优秀的框架，最近准备将Spring重新学习和梳理一遍。

+++++++++++++++++以下摘自百度百科+++++++++++++++++++++

Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

一、Spring框架特征

轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。
控制反转——Spring通过一种称作控制反转（IoC）的技术促进了低耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。
面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。
容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。
框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。
MVC——Spring的作用是整合，但不仅仅限于整合，Spring 框架可以被看做是一个企业解决方案级别的框架。客户端发送请求，服务器控制器（由DispatcherServlet实现的)完成请求的转发，控制器调用一个用于映射的类HandlerMapping，该类用于将请求映射到对应的处理器来处理请求。HandlerMapping 将请求映射到对应的处理器Controller（相当于Action）在Spring 当中如果写一些处理器组件，一般实现Controller 接口，在Controller 中就可以调用一些Service 或DAO 来进行数据操作 ModelAndView 用于存放从DAO 中取出的数据，还可以存放响应视图的一些数据。 如果想将处理结果返回给用户，那么在Spring 框架中还提供一个视图组件ViewResolver，该组件根据Controller 返回的标示，找到对应的视图，将响应response 返回给用户。
所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

+++++++++++++++++以上摘自百度百科+++++++++++++++++++++

说了spring 这么多好，下面来实践一下。 本篇主要从一个简单例子说明spring如何来实现控制反转（总体内容参考了马士兵的spring视频）

二、首先看一个面向接口开发的小程序

这个小程序，由下面4个java 程序组成，Student.java 是实体类，StudentDAO是实体类的操作接口，StudentDAOImpl是操作的具体实现，StudentService是应用，对于Student进行操作。

package com.study.entity;/* * this is a simple entity class, descripe Student; */public class Student {String Name="";String Sex="";String Birth="";public String getName() {return Name;}public void setName(String name) {Name = name;}public String getSex() {return Sex;}public void setSex(String sex) {Sex = sex;}public String getBirth() {return Birth;}public void setBirth(String birth) {Birth = birth;}public  String toString(){return "Name="+this.Name+";Sex="+this.Sex+";Birthday="+this.Birth;}}

  

package com.study.dao;import com.study.entity.Student;/* * this interface  define entity class student's dao(data access operation) interface */public interface StudentDAO {//学生操作，新增学生boolean addStudent(Student student);//学生操作，删除学生boolean delStudent(Student  student);//学生操作，修改学生信息boolean modifyStudent(Student  student);//学生操作，查询学生信息，查询到返回学生对象，否则返回nullStudent queryStudent( String  StudentName);}

package com.study.dao.impl;import com.study.dao.StudentDAO;import com.study.entity.Student;/* * this is implement of StudentDAO; */public class StudentDAOImpl implements StudentDAO {@Overridepublic boolean addStudent(Student student) {// TODO Auto-generated method stubSystem.out.println("++++begin add student+++++");//模拟add 操作int flag =1;if(flag ==0) return false;else return true;}@Overridepublic boolean delStudent(Student student) {// TODO Auto-generated method stubreturn false;}@Overridepublic boolean modifyStudent(Student student) {// TODO Auto-generated method stubreturn false;}@Overridepublic Student queryStudent(String StudentName) {// TODO Auto-generated method stub//模拟从数据库中查询学生名, 数据库中只有一名 name 为 Tom的学生System.out.println("++++begin query student+++++");if("Tom".equals(StudentName )){Student studentTom = new Student();studentTom.setName("Tom");studentTom.setSex("male");studentTom.setBirth("19701221");return  studentTom;}else return null;}}

最后是应用类：

package com.study.student.service;import com.study.dao.StudentDAO;import com.study.dao.impl.StudentDAOImpl;import com.study.entity.Student;/* * this class  descripe StudentApi */public class StudentService {private StudentDAO studentDAO = new StudentDAOImpl();public StudentDAO getStudentDAO() {return studentDAO;}public void setStudentDAO(StudentDAO studentDAO) {this.studentDAO = studentDAO;}public boolean addStudent(Student student) {return this.studentDAO.addStudent(student);}public String queryStudent(String studentName) {Student retStudent = this.studentDAO.queryStudent(studentName);if (null == retStudent)return "null";elsereturn retStudent.toString();}public static void main(String[] args) {// create and publish an endpointStudentService studentWs = new StudentService();Student student1 = new Student();student1.setName("Tom");student1.setSex("male");student1.setBirth("1970/05/08");Student student2 = new Student();student2.setName("Lili");student2.setSex("female");student2.setBirth("1972/05/23");studentWs.addStudent(student1);studentWs.addStudent(student2);System.out.println(studentWs.queryStudent("Tom"));System.out.println(studentWs.queryStudent("LiLi"));}}

整体代码目录结构如下：

三、分析上面的应用，模拟sping

StudentDAOImpl 如果有多个实现，那么在应用中需要编码指定用哪个，都涉及到代码的修改，不便于应用的灵活。显然，如果有个配置文件可以指定应用的运行时接口实现类，大大增强了应用的灵活性。

1、首先修改StudentService ,将其内部的绑定实现去除，在运行时指定实现类

2、编写模拟spring的2个类

BeanFactory.java  是接口， ClassPathXmlApplicationContext.java 是读取配置文件

BeanFactory.java  代码如下：

package com.study.spring.simulate;public interface BeanFactory {public Object getBean(String name);}

 ClassPathXmlApplicationContext.java 代码如下：

package com.study.spring.simulate;import java.util.HashMap;import java.util.List;import java.util.Map;import org.jdom.Document;import org.jdom.Element;import org.jdom.input.SAXBuilder;public class ClassPathXmlApplicationContext implements BeanFactory{private Map<String, Object>beans = new HashMap<String, Object>();public ClassPathXmlApplicationContext() throws Exception{SAXBuilder sb=new  SAXBuilder();Document doc = sb.build( this.getClass().getClassLoader().getResourceAsStream("beans.xml"));Element root= doc.getRootElement();List<Element> list= root.getChildren("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");System.out.println(id+"："+clazz);Object  o = Class.forName(clazz).newInstance();beans.put(id, o);}}public Object getBean(String name){return beans.get(name);}}

这个类的主要逻辑是从xml文件中读取Bean，并提供返回Bean对象的功能。xml 文件 beans.xml 如下

<beans><bean id="u" class ="com.study.dao.impl.StudentDAOImpl" /><!--<bean id="StudentService" class ="com.study.student.service.StudentService" ><property name="StudentDAO" bean="u"/></bean>--></beans>

然后，我们编写一个测试代码，来测试运行时动态获取实现类对象 StudentServiceTest  ，这个类是一个junit 测试类

package com.study.student.service;import static org.junit.Assert.*;import static org.hamcrest.Matchers.*;import org.junit.BeforeClass;import org.junit.Test;import com.study.dao.StudentDAO;import com.study.entity.Student;import com.study.spring.simulate.BeanFactory;import com.study.spring.simulate.ClassPathXmlApplicationContext;public class StudentServiceTest { public  static StudentService  studentService; public  static StudentDAO studentDAO;//注意这里用beforeClass而不是before，表示全部测试函数调用前，调用一次@BeforeClasspublic static void init() throws  Exception{        BeanFactory factory = new ClassPathXmlApplicationContext();studentService= new StudentService();studentDAO= (StudentDAO)factory.getBean("u");studentService.setStudentDAO(studentDAO);}@Testpublic void addStudentTest() throws Exception{Student studentObj = new Student();assertTrue(studentService.addStudent(studentObj));}@Testpublic void queryStudentTest( ) throws Exception {assertThat(studentService.queryStudent("Tom"), is("Name=Tom;Sex=male;Birthday=19701221"));assertThat(studentService.queryStudent("Jerry"), is("null"));}}

@BeforeClass 注解是测试函数调用前，初始化对象用的，在这里对StudentDAO 对象指定了实现类：studentDAO= (StudentDAO)factory.getBean("u");    这里 id 为 “u” 的Bean ，根据配置文件是指定了StudentDAOImpl ，也就是说，如果有多个实现，通过配置文件就实现了动态指定实现类，大大增加了应用的灵活性。 这种能力，就是依赖注入，也成为IOC 控制反转。

在上面的基础上，在进行小修改，来展示一下动态装配的能力。

修改ClassPathXMLApplicationContext.java 使得这个类具有解析bean 属性并进行装配的能力

package com.study.spring.simulate;import java.lang.reflect.Method;import java.util.HashMap;import java.util.List;import java.util.Map;import org.jdom.Document;import org.jdom.Element;import org.jdom.input.SAXBuilder;public class ClassPathXmlApplicationContext implements BeanFactory{private Map<String, Object>beans = new HashMap<String, Object>();public ClassPathXmlApplicationContext() throws Exception{SAXBuilder sb=new  SAXBuilder();Document doc = sb.build( this.getClass().getClassLoader().getResourceAsStream("beans.xml"));Element root= doc.getRootElement();List<Element> list=root.getChildren("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");System.out.println(id+"："+clazz);Object  o = Class.forName(clazz).newInstance();beans.put(id, o);//下面是读取property属性for(Element propertyElement : (List<Element>) element.getChildren("property")  ){String name = propertyElement.getAttributeValue("name");String bean = propertyElement.getAttributeValue("bean");Object beanObject = beans.get(bean);//这里组装set操作方法名，将参数中的bean取出来，进行set拼接String methodName ="set"+name.substring(0,1).toUpperCase() + name.substring(1);System.out.println("method name ="+ methodName);//这里实现了动态装配，调用Method的invoke方法,用了java的反射机制Method m=o.getClass().getMethod(methodName, beanObject.getClass().getInterfaces()[0]);m.invoke(o, beanObject);}}}public Object getBean(String name){return beans.get(name);}}

 修改beans.xml  ，如下图

修改应用StudentServiceTest，如下图

四、引入spring 

在上面实践的基础上，我们引入spring包，这里使用的是spring 3.0，导入的jar包有

，我们去掉模拟的spring代码

去掉模拟spring功能的代码后，StudentServiceTest.java 报错了，我们将代码里面的对象，替换为spring的对象

  注意，要在让spring找到bean的配置文件，需要修改下面语句

 BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");

 这样，就可以执行了。

执行结果如下：

五、小结

本篇主要是实践了spring的基础特性：依赖注入、IOC（控制反转）、自动装配