Java仿Spring控制反转

最新推荐文章于 2023-10-26 09:51:04 发布

渴鱼y

最新推荐文章于 2023-10-26 09:51:04 发布

阅读量809

点赞数 3

分类专栏：本科专业课程文章标签： Java仿Spring控制反转

本文链接：https://blog.csdn.net/jy_z11121/article/details/90345191

版权

本科专业课程专栏收录该内容

15 篇文章 0 订阅

订阅专栏

课题分析：学习了Java后进行的实战，还并不了解Spring以及控制反转，所以应该先了解Spring和控制反转。其实是“Spring的控制反转”，表明控制反转应用在Spring中。

一、Spring

人们开始追逐更加方便更加简易和轻量级的技术框架 → Spring
Spring精髓：控制反转IoC 和依赖注入DI

1、IoC

Ioc是指：在程序开发中，实例的创建不再由调用者管理，而是由Spring容器创建。Spring容器会负责控制程序之间的关系，而不是由程序代码直接控制，因此，控制权由程序转移到了Spring容器中，控制权发生了反转，这就是Spring的IoC思想。

通过IoC模式可以彻底解决高耦合(耦合指程序中，模块及模块之间信息或参数依赖的程度)问题，它把耦合从代码中移出去，放到统一的XML文件中，通过一个容器在需要的时候把这个依赖关系形成，即把需要的接口实现注入到需要它的类中(这可能就是“依赖注入”说法的来源了)。

IOC模式，系统中通过引入实现了IOC模式的IOC容器，即可由IOC容器来管理对象的生命周期、依赖关系等，从而使得应用程序的配置和依赖性规范与实际的应用程序代码分开。其中一个特点就是通过文本的配置文件进行应用程序组件间相互关系的配置，而不用重新修改并编译具体的代码。

IOC的底层原理：XML解析、工厂模式、反射。 可以把IoC模式看做是工厂模式的升华，可以把IoC看作是一个大工厂，只不过这个大工厂里要生成的对象都是在XML文件中给出定义的，然后利用Java的“反射”编程，根据XML中给出的类名生成相应的对象。从实现来看，IoC是把以前在工厂方法里写死的对象生成代码，改变为由XML文件来定义，也就是把工厂和对象生成这两者独立分隔开来，目的就是提高灵活性和可维护性。

在这里插入图片描述

IoC中最基本的Java技术就是“反射”编程。反射又是一个生涩的名词，通俗的说反射就是根据给出的类名（字符串）来生成对象。这种编程方式可以让对象在生成时才决定要生成哪一种对象。反射的应用是很广泛的，象Hibernate、Spring中都是用“反射”做为最基本的技术手段。

当前比较知名的IOC容器有：PicoContainer、Avalon、Spring、JBoss、HiveMind、EJB等。在上面的几个IOC容器中，轻量级的有PicoContainer、Avalon、Spring、HiveMind等，超重量级的有EJB，而半轻半重的有容器有JBoss，Jdon等。

优缺点

IoC最大的好处是什么？因为把对象生成放在了XML里定义，所以当我们需要换一个实现子类将会变得很简单（一般这样的对象都是实现于某种接口的），只要修改XML就可以了，这样我们甚至可以实现对象的热插拨（有点象USB接口和SCSI硬盘了）。

比如有这样两个类：

class UserDao{
	add() {
		...
	}
}

class UserService{
	execute() {
		UserDao dao = new UserDao();
		dao.add();
	}
}

那么问题出现了，由于UserService需要调用UserDao，两者关联紧密，一旦UserDao的路径或者里面的方法变化了，那么UserService也要变，这就是耦合度高，“牵一发，动全身”，所以不利于重新扩展。

利用工厂模式改善这一“高耦合”（但还属不是最佳方法，最佳方法就是IOC，借助XML解析、工厂模式、反射）：

IoC最大的缺点是什么？（1）生成一个对象的步骤变复杂了（事实上操作上还是挺简单的），对于不习惯这种方式的人，会觉得有些别扭和不直观。（2）对象生成因为是使用反射编程，在效率上有些损耗。但相对于IoC提高的维护性和灵活性来说，这点损耗是微不足道的，除非某对象的生成对效率要求特别高。（3）缺少IDE重构操作的支持，如果在Eclipse要对类改名，那么你还需要去XML文件里手工去改了，这似乎是所有XML方式的缺憾所在。

2、DI

IoC和DI是同一思想下不同维度的表现。Spring容器在创建被调用者的实例时，会自动将调用者需要的对象实例注入给调用者，这就是依赖注入。

【控制反转强调：关系的产生由容器控制。依赖注入强调：关系的注入是由容器在运行时完成。其本质是一样的。( 两者的简单易懂的介绍，可点击这里。)】

3、Spring简介

Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

轻量——从大小与开销两方面而言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也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。

所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

Look Here

Spring提供了两种IoC容器，分别为BeanFactory和ApplicationContext。关于两者的详细讲解与比较不再赘述，有兴趣自己查阅。下面只给出实现：

简单介绍下…

BeanFactory：基础类型的IoC容器；一个管理Bean的工厂，主要负责初始化各种Bean，并调用它们的生命周期方法。
ApplicationContext：是BeanFactory的子接口，也被称为应用上下文；功能更多；有两个常用实现类：ClassPathXmlApplicationContext、FileSystemXmlApplicationContext。
BeanFactory和ApplicationContext都是通过XML配置文件加载Bean的，具有一定的区别，通常使用后者（原因略…）。

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
	     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	     xmlns:aop="http://www.springframework.org/schema/aop"
	     xmlns:tx="http://www.springframework.org/schema/tx"
	     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
           
 <!-- 在.XML文件中注入School类 -->
 <bean id="schoolBean" class="ioc.iocexample.School">
	   <constructor-arg index="0">
	     <value>湖二师</value>
	   </constructor-arg>
 </bean>
 
 <!-- 在.XML文件中注入Student类 -->
 <bean id="studentBean" class="ioc.iocexample.Student">
	 <property name="id"      value="11111"/>
	 <property name="name"    value="Sunny"/>
	 <property name="school"  ref ="schoolBean"/>
 </bean>
</beans>

配置文件解读：

文档声明(必须位于第一行)：<?xml 版本信息[编码信息][文档独立性信息]?>

<和?、?和xml、?和>之间不能有空格
中括号[]内的内容为可选项

声明一个bean，可以理解为实例化了一个对象。那这里实例化了两个对象（school和student），各个属性都已经赋值上去。
id表示一个实例化类名，其后的class表示要实例化的类。
通过给property赋值，Spring就会通过类的各个属性的set方法，逐一给属性赋其后的value值或ref值。ref表示这个值是个引用类型的，它指向了另一个bean的id值，即“湖二师”。
注释：<! - - 注释信息 - ->

package ioc.iocexample;

public class School {
		private String name;
		public School(String name) {
			this.name = name;
		}
		public void printInfo() {
			System.out.println("所在学校：" + name);
		}
}

package ioc.iocexample;

public class Student {
	public int id;
	public String name;
	private School school;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public School getSchool() {
		return school;
	}
	public void setSchool(School school) {
		this.school = school;
	}
}

package ioc.iocexample;

import org.springframework.beans.factory.BeanFactory;//需要spring-beans-4.2.0.RELEASE.jar
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;//需要spring-context-4.2.0.RELEASE.jar
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.core.io.FileSystemResource;

public class Client {
	private static String xmlLocation = "E:/000/ioc_test1/IOCSpring/sources/ApplicationContext.xml";
	public static void main(String[] args) {
		//下面是正确的
		//Step1、启动Spring，装载上下文
		BeanFactory factory = new FileSystemXmlApplicationContext(xmlLocation);
		//Step2、获得配置的Student实例：与.XML文件中的id = studentBean相匹配
		Student student = (Student)factory.getBean("student");	//getBean()方法的返回值是Class类型，所以此处进行强制类型转换	
		student.getSchool().printInfo();
		
//		下面是错误的，可能配置文件没有写对地方，我是右键Client.class创建的config.xml，可是也不行。用xmlLocation也不行，百度了很久，也没有得到解决。。。
//		ApplicationContext factory = new ClassPathXmlApplicationContext("config.xml"); 
//		Student student = (Student)factory.getBean("student");		
//		student.getSchool().printInfo();
	}
}

在这里插入图片描述

二、Java仿Spring控制反转实现

综上，Java仿Spring控制反转就是让我们利用反射机制，创建类的实例对象。可以先简单的将属性以及属性值保存到配置文件中（不简单的话就要遵循xml的相关语法写在.xml文件里…），然后在创建实例对象的过程中利用此来进行实例对象的属性的赋值，最后即可得到一个正确的实例对象。
下面是我利用配置文件保存相关信息，通过反射编程，完成试验（本应该使用XML文件的…能力不够，暂时不使用XML文件）。

package demo.spring;

public class Student {
	public String name;
	public String id;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	@Override
	public String toString(){
		return "id = " + id + ", name = " + name;		
	}
}

package demo.spring;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

public class ReflectTest {
	public static Object iocFunction(Class cls) throws InstantiationException, IllegalAccessException, ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException, FileNotFoundException, IOException{
		//0.0:加载配置文件
		Properties pro = new Properties();
		pro.load(new FileInputStream("config/instance.properties"));
		//0.1:获取方法形参的对象实例
		Object obj = cls.newInstance();
		//1、利用反射机制获取这个类的所有属性
		Field fs[] = cls.getDeclaredFields();
		//2、类中的属性与配置文件中保存的属性能够对应起来时，我们就将配置文件中保存的这个属性对应的值赋给类中的这个属性
		for(Field f : fs){
			//看配置文件中是否存在与属性名对应的值，如果没有，则isHere为null			
			Object isHere = pro.getProperty(f.getName());
			//3、利用反射，动态调用obj对象中的所有setXXX()方法，为类中的属性赋值
			if (isHere != null){
				//3.1：获取方法名“setXXX”
				String methodName = "set" + f.getName().substring(0,1).toUpperCase() + f.getName().substring(1);
				//3.2：获取setXXX()方法的参数类型
				Class<?> paramType = Class.forName(f.getType().getName());				
				//3.3：根据方法名及该方法具有的参数即可利用反射执行此方法
				//3.3.1：获得此方法
				Method method = cls.getDeclaredMethod(methodName, paramType);

				//3.3.2：执行此方法
				//3.3.2.1：获得执行此方法的实参
				Object paramExecute = new Object();
				paramExecute = isHere;
				//3.3.2.2：执行方法
				method.invoke(obj, paramExecute);
			}
		}
		return obj;
	}
}

package demo.spring;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
public class Test {
	/**
	 * @param args
	 * @throws InvocationTargetException 
	 * @throws NoSuchMethodException 
	 * @throws ClassNotFoundException 
	 * @throws IllegalAccessException 
	 * @throws InstantiationException 
	 * @throws IllegalArgumentException 
	 * @throws SecurityException 
	 * @throws IOException 
	 * @throws FileNotFoundException 
	 */
	public static void main(String[] args) throws SecurityException, IllegalArgumentException, InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, FileNotFoundException, IOException {
		Student stu = (Student)ReflectTest.iocFunction(Student.class);
		System.out.println(stu);
	}
}

运行以上代码，可以得到一个Student实例对象，其属性为配置文件中所设置的。输出到控制台，如下所示：
在这里插入图片描述

三、Java仿Spring控制反转实现(改进)

渴鱼y

关注

3
点赞
踩
2

收藏

觉得还不错? 一键收藏
2
评论
Java仿Spring控制反转

控制反转介绍控制反转（Inversion of Control，英文缩写为IoC），另外一个名字叫做依赖注入（Dependency Injection，简称DI），是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。IOC和DI是同一思想下不同维度的表现。两者的简单易懂的介绍，请点击这里。通过IoC模式可以彻底解决高耦合(耦合指程序中，模块及模块之...
复制链接

扫一扫

专栏目录