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

最新推荐文章于 2023-07-01 10:05:17 发布

虎纠卫

最新推荐文章于 2023-07-01 10:05:17 发布

阅读量6.7k

点赞数 2

分类专栏： Sping JAVA 文章标签： spring java IOC

本文链接：https://blog.csdn.net/csolo/article/details/54907574

版权

JAVA 同时被 2 个专栏收录

17 篇文章 0 订阅

订阅专栏

Sping

4 篇文章 0 订阅

订阅专栏

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<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，表示全部测试函数调用前，调用一次
	@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<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（控制反转）、自动装配

虎纠卫

关注

2
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
Spring实践（一）IOC的原理和实现机制

Spring是java中非常优秀的框架，最近准备将Spring重新学习和梳理一遍。Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源本篇实践一下spring的IOC、自动装配、依赖注入
复制链接

扫一扫