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

阅读量：2490 次

发布时间：2019-05-11

本文共 9193 字，大约阅读时间需要 30 分钟。

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);		//学生操作，查询学生信息，查询到返回学生对象，否则返回null	Student 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 {	@Override	public boolean addStudent(Student student) {		// TODO Auto-generated method stub		System.out.println("++++begin add student+++++");		//模拟add 操作		int flag =1;		if(flag ==0) 			return false;		else 			return true;	}	@Override	public boolean delStudent(Student student) {		// TODO Auto-generated method stub		return false;	}	@Override	public boolean modifyStudent(Student student) {		// TODO Auto-generated method stub		return false;	}	@Override	public 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";		else			return retStudent.toString();	}	public static void main(String[] args) {		// create and publish an endpoint		StudentService 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
    
     beans = new HashMap
     
      ();		public ClassPathXmlApplicationContext() throws Exception{		SAXBuilder sb=new  SAXBuilder();		Document doc = sb.build( this.getClass().getClassLoader().getResourceAsStream("beans.xml"));				Element root= doc.getRootElement();		List
      
        list= root.getChildren("bean");		for( int i=0; i

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

然后，我们编写一个测试代码，来测试运行时动态获取实现类对象 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，表示全部测试函数调用前，调用一次	@BeforeClass	public static void init() throws  Exception{		        BeanFactory factory = new ClassPathXmlApplicationContext();		studentService= new StudentService();				studentDAO= (StudentDAO)factory.getBean("u");		studentService.setStudentDAO(studentDAO);			}		@Test	public void addStudentTest() throws Exception{				Student studentObj = new Student();		assertTrue(studentService.addStudent(studentObj));			}		@Test	public 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
    
     beans = new HashMap
     
      ();		public ClassPathXmlApplicationContext() throws Exception{		SAXBuilder sb=new  SAXBuilder();		Document doc = sb.build( this.getClass().getClassLoader().getResourceAsStream("beans.xml"));				Element root= doc.getRootElement();		List
      
        list=root.getChildren("bean");		for( int i=0; i
       
        ) 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);	}}