解析Spring IOC原理——工厂模式与反射机制的综合应用

（一）工厂模式

从一个例子开始讲起：

首先我们建立一个Chinese.java类，该类的sayHelloWorld(String name)方法，用中文对名为name的人问好，其内容如下：

[java] view plaincopyprint?

public class Chinese {
/**-- 用中文对某人问好. --*/
publicvoid sayHelloWorld(String name) {
String helloWorld = "你好，" + name;
System.out.println(helloWorld);
}
}

下面我们接着建立一个American.java类，该类的sayHelloWorld(String name)方法，用英文对名为name的人问好，其内容如下：下面我们接着建立一个American.java类，该类的sayHelloWorld(String name)方法，用英文对名为name的人问好，其内容如下：

[html] view plaincopyprint?

publicclass American {
/*-- 用英文对某人问好 --*/
publicvoid sayHelloWorld(String name) {
String helloWorld = "Hello，" + name;
System.out.println(helloWorld);
}
}

最后我们编写一个测试类对这两个类的sayHelloWorld(String name)方法进行测试，下面是该类的内容：

[java] view plaincopyprint?

publicclass HelloWorldTest {
/*-- 测试Chinese和American的sayHelloWorld()方法 --*/
publicstaticvoid main(String[] args) {
Chinese chinese = new Chinese();
chinese.sayHelloWorld("极度暴走");
American american = new American();
american.sayHelloWorld("jidubaozou");
}
}

现实生活中我们总是把同一类产品放在一个工厂中生产，消费者只需要告诉工厂自己需要这一类产品中的哪一种产品，工厂就能够生产出对应的产品，从而完成交易。

这里我们把上面例子中的HelloWorldTest类想象为消费者，而Chinese和American类想象为产品，根据上面的例子，我们可以看到每当HelloWorldTest这个消费者需要一个产品时都要去自己去生产（new），这样消费者就不得不去了解各个产品的内部结构及生产过程。显然对于消费者来说这样是很麻烦的。

而在程序设计领域中这个问题就叫做强耦合问题，HelloWorldTest类与Chinese和American这两个类都存在强耦合关系。设想一下，如果程序中的很多类都需要用到Chinese和American类这两个类，那么每个类就必须和这两个类强耦合，而且现实的项目中类似于Chinese这种类往往不仅两个，这样会使得整个程序的耦合度很高，增大程序的复杂度。这时我们就想到，能否也使用一个工厂来生产这些类，这样如果某个类需要用到工厂中的哪个类，就只要通过和工厂生产就行了，从而降低了整个程序的耦合度。

下面看看工厂模式是如何实现的：

首先建立接口类Human.java，其内容如下：

[java] view plaincopyprint?

public interface Human {
/** *//**
* 对某人问好.
* @param name 姓名
*/
public void sayHelloWorld(String name);
}

并将American.java类和Chinese.java类改为实现该接口，即类头分别改成：public class American implements Human和public class Chinese implements Human。

接着编写HumanFactory.java工厂类，其内容为：

[java] view plaincopyprint?

public class HumanFactory {
/** *//**
* 通过类型字段获取人的相应实例
* @param type 类型
* @return 返回相应实例
*/
public Human getHuman(String type) {
if ("chinese".equals(type)) {
return new Chinese();
} else {
return new American();
}
}
}

最后我们还需要修改测试类HelloWorld.java类，修改后的内容如下：

[java] view plaincopyprint?

public class HelloWorldTest {
/** *//**
* 测试sayHelloWorld()方法.
* @param args
*/
public static void main(String[] args) {
HumanFactory factory = new HumanFactory();
Human human1 = factory.getHuman("chinese");
human1.sayHelloWorld("极度暴走");
Human human2 = factory.getHuman("american");
human2.sayHelloWorld("jidubaozou");
}
}

通过上面的例子可以看到，使用工厂模式实现的方式， HelloWorldTest 不再与Chinese类和American类耦合，而只是和他们共同的接口耦合，从而很大程度的降低的程序的耦合性。到这里或许很多人会有一点疑虑，使用工厂模式的HelloWorldTest 类也是需要耦合两个类（即HumanFactory 类和Human 接口）那么为什么能说降低耦合度呢，这就要是何时要使用工厂模式的问题了。假如类似于我们这个例子，HumanFactory 这个工厂只生产两个类，那的确没有什么必要使用工厂模式，但是现实的项目中往往有更多和Chinese类类似的类，比如English，Japanese，这时候就能体现出工厂模式的优势了

（二）Spring IOC的原理

首先我们来讲下为什么要引入IOC：

假设上面举例的那个程序已经部署到服务器中，并已经上线运行，这时项目来了这样一个新需求：增加一个Japanese类，并且在HelloWorldTest 类中调用Japanese的sayHelloWorld方法。在没有引入IOC之前，很显然我们为了这个新需求，必须把项目停止下来，然后从新编译HumanFactory 和HelloWorldTest这两个类，最后再重新上线运行。

而使用IOC，则能够在不重新编译部署的情况下实现上面的新需求！

那么我们来看一下IOC是去怎么实现这个新需求的：

首先我们在com.human包内创建一个Japanese类：

[java] view plaincopyprint?

public class Japanese implements Human{
private String name;
private String age;
public void sayHelloWorld(String string){
System.out.println("你好，"+string);
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

然后对HelloWorldTest 类做如下修改

[java] view plaincopyprint?

public class HelloWorldTest {
public static void main(String[] args) {
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
BeanFactory beanFactory=ctx.getBeanFactory();
Human human=beanFactory.getBean("human");
human.sayHelloWorld("极度暴走");
}
}

然后我们在beans.xml中做如下配置：

[html] view plaincopyprint?

<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="human" class="com.human.Japanese">
<property name="name">
<value>漩涡鸣人</value>
</property>
<property name="password">
<value>22</value>
</property>
<pre class="html" name="code"></bean>
</beans></pre>
这样，HelloWorldTest 便会去调用Japanese类的sayHelloWorld()方法；用这种形式，我们只要修改beans.xml的配置便可以改变HelloWorldTest 类中human对象，并且不需要重新部署项目，这样就实现了human对象的热拔插。
从上面的代码可以看到spring IOC的这种实现方式主要是靠BeanFactory这个类，那么这个BeanFactory到底有什么神奇之处呢？
下面让我们模拟实现一个BeanFactory：
<pre class="java" name="code">import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
/** *//**
* bean工厂类.
*/
public class BeanFactory {
private Map<String, Object> beanMap = new HashMap<String, Object>();
/** *//**
* bean工厂的初始化.
* @param xml xml配置文件
*/
public void init(String xml) {
try {
//读取指定的配置文件
SAXReader reader = new SAXReader();
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
//从class目录下获取指定的xml文件
InputStream ins = classLoader.getResourceAsStream(xml);
Document doc = reader.read(ins);
Element root = doc.getRootElement();
Element foo;
//遍历bean
for (Iterator i = root.elementIterator("bean"); i.hasNext();) {
foo = (Element) i.next();
//获取bean的属性id和class
Attribute id = foo.attribute("id");
Attribute cls = foo.attribute("class");
//利用Java反射机制，通过class的名称获取Class对象
Class bean = Class.forName(cls.getText());
//获取对应class的信息
java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(bean);
//获取其属性描述
java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();
//设置值的方法
Method mSet = null;
//创建一个对象
Object obj = bean.newInstance();
//遍历该bean的property属性
for (Iterator ite = foo.elementIterator("property"); ite.hasNext();) {
Element foo2 = (Element) ite.next();
//获取该property的name属性
Attribute name = foo2.attribute("name");
String value = null;
//获取该property的子元素value的值
for(Iterator ite1 = foo2.elementIterator("value"); ite1.hasNext();) {
Element node = (Element) ite1.next(); value = node.getText();
break;
}
for (int k = 0; k < pd.length; k++) {
if (pd[k].getName().equalsIgnoreCase(name.getText())) { mSet = pd[k].getWriteMethod();
//利用Java的反射机制调用对象的某个set方法，并将值设进去
mSet.invoke(obj, value);
}
}
}
//将对象放入beanMap中，其中key为id值，value为对象
beanMap.put(id.getText(), obj);
}
} catch (Exception e) {
System.out.println(e.toString());
}
}
/** *//**
* 通过bean的id获取bean的对象.
* @param beanName bean的id
* @return 返回对应对象
*/
public Object getBean(String beanName) {
Object obj = beanMap.get(beanName);
return obj;
}
/** *//**
* 测试方法.
* @param args
*/
public static void main(String[] args) {
BeanFactory factory = new BeanFactory();
factory.init("bean.xml");
Human human= (Human) factory.getBean("human");
human.sayHelloWorld("极度暴走");
System.out.println("Name=" + human.getName());
System.out.println("age=" + human.getAge());
}
}
</pre>
测试方法的执行结果：你好，极度暴走
漩涡鸣人
22
总结：从上面的代码可以看出Spring的bean工厂主要实现了以下几个步骤
1.解析配置文件（bean.xml）
2.使用反射机制动态加载每个class节点中配置的类
3.为每个class节点中配置的类实例化一个对象
4.使用反射机制调用各个对象的seter方法，将配置文件中的属性值设置进对应的对象
5.将这些对象放在一个存储空间（beanMap）中
6.使用getBean方法从存储空间（beanMap）中取出指定的JavaBean
PS：IOC的标准定义：
(Inversion of Control)
中文译为：控制反转
IOC的基本概念是：不创建对象，但是描述创建它们的方式。在代码中不直接与对象和服务连接，但在配置文件中描述哪一个组件需要哪一项服务。容器负责将这些联系在一起。
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<div style="padding-top:20px">
版权声明：本文为博主原创文章，未经博主允许不得转载。
</div>

解析Spring IOC原理——工厂模式与反射机制的综合应用相关推荐

java 反射工厂模式_Java反射机制demo（七）—反射机制与工厂模式
Java反射机制demo(七)-反射机制与工厂模式工厂模式简介工厂模式是最常用的实例化对象模式. 工厂模式的主要作用就是使用工厂方法代替new操作. 为什么要使用工厂模式?直接new不好吗? 直 ...
Spring Ioc原理解析
Spring Ioc原理解析 IoC理论的背景我们都知道,在采用面向对象方法设计的软件系统中,它的底层实现都是由N个对象组成的,所有的对象通过彼此的合作,最终实现系统的业务逻辑. 图1:软件系统中耦 ...
Spring Ioc原理及解析
IOC简介 IoC是Inversion of Control的缩写,多数书籍翻译成"控制反转",还有些书籍翻译成为"控制反向"或者"控制倒置" ...
Spring IOC 原理解析
Spring IOC 原理 ? IOC DI(依赖注入) **DI注入的几种方式** IOC容器 IOC原理要想理解IOC,就需要知道一下IOC.DI 和IOC容器都是干什么的 IOC spring ...
spring ioc原理分析
spring ioc原理分析 spring ioc 的概念简单工厂方法 spirng ioc实现原理 spring ioc的概念 ioc: 控制反转将对象的创建由spring管理.比如,我们以前用 ...
Spring IOC 原理
Spring IOC原理 IOC理解自己写的简单的IOC容器 IOC的原理定位.加载.注册基于XML配置的IOC容器初始化 1.寻找入口 2.获取配置路径 3.开始启动 4.创建容器 5.载入配 ...
IOC和工厂模式的区别
Spring的IOC和工厂模式的区别 IOC是使用了反射的技术来动态的生成对象工厂模式的对象生成是提前在工厂类中定死的 IOC更加灵活 IoC--Inversion of Control 控制反转 ...
控制反转(IoC) ？工厂模式？
不知道大家还记不记得当年程杰的<大话设计模式>了,最近一直想搞明白控制反转到底是怎么回事,刚刚觉得高大上了一点,然后再进一步去学习去对比的时候才发现,以前早就接触过这类的思想,设计原则的依 ...
spring ioc原理解析
概述 Spring IOC控制反转,分为两个方面解释: 控制:对象对于内部成员的控制反转:将之前对象管理自己内部成员,转变为ioc容器管理,目的是接耦 IOC的好处是: 无需手动创建,拿来就用享受 ...

解析Spring IOC原理——工厂模式与反射机制的综合应用

解析Spring IOC原理——工厂模式与反射机制的综合应用相关推荐

最新文章

热门文章