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

（一）工厂模式

从一个例子开始讲起：

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

     

[java] view plain copy print ?

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

 

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

[html] view plain copy print ?

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

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

[java] view plain copy print ?

1. publicclass HelloWorldTest {  
2.   
3.     /*-- 测试Chinese和American的sayHelloWorld()方法 --*/  
4.     publicstaticvoid main(String[] args) {  
5.        Chinese chinese = new Chinese();  
6.        chinese.sayHelloWorld("极度暴走");  
7.          
8.        American american = new American();  
9.        american.sayHelloWorld("jidubaozou");  
10.     }  
11. }  

 

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

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

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

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

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

[java] view plain copy print ?

1. public interface Human {  
2.   
3.     /** *//** 
4.      * 对某人问好. 
5.      * @param name 姓名 
6.      */  
7.     public void sayHelloWorld(String name);  
8. }  

 

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

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

 

[java] view plain copy print ?

1. public class HumanFactory {  
2.   
3.        /** *//** 
4.         * 通过类型字段获取人的相应实例 
5.         * @param type 类型 
6.         * @return 返回相应实例 
7.         */  
8.        public Human getHuman(String type) {  
9.               if ("chinese".equals(type)) {  
10.                      return new Chinese();  
11.               } else {  
12.                      return new American();  
13.               }  
14.        }  
15. }  

 

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

 

[java] view plain copy print ?

1. public class HelloWorldTest {  
2.   
3.        /** *//** 
4.         * 测试sayHelloWorld()方法. 
5.         * @param args 
6.         */  
7.        public static void main(String[] args) {  
8.               HumanFactory factory = new HumanFactory();  
9.               Human human1 = factory.getHuman("chinese");  
10.               human1.sayHelloWorld("极度暴走");  
11.   
12.               Human human2 = factory.getHuman("american");  
13.               human2.sayHelloWorld("jidubaozou");  
14.               }  
15. }  

通过上面的例子可以看到，使用工厂模式实现的方式， 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 plain copy print ?

1. public class Japanese implements Human{  
2.      private String name;  
3.      private String age;  
4.        
5.      public void sayHelloWorld(String string){  
6.          System.out.println("你好，"+string);  
7.      }  
8.      public String getAge() {  
9.      return age;  
10.      }  
11.      public void setAge(String age) {  
12.      this.age = age;  
13.      }  
14.      public String getName() {  
15.      return name;  
16.      }  
17.      public void setName(String name) {  
18.          this.name = name;  
19.      }  
20. } 
    

然后对HelloWorldTest 类做如下修改

[java] view plain copy print ?

1. public class HelloWorldTest {  
2.   
3.        public static void main(String[] args) {  
4.              ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");  
5.              BeanFactory beanFactory=ctx.getBeanFactory();  
6.              Human human=beanFactory.getBean("human");  
7.              human.sayHelloWorld("极度暴走");  
8.              }  
9. } 
   

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

[html] view plain copy print ?

1. <?xml version="1.0" encoding="UTF-8"?>  
2.   
3. <beans>  
4.     <bean id="human" class="com.human.Japanese">  
5.        <property name="name">  
6.            <value>漩涡鸣人</value>  
7.        </property>  
8.        <property name="password">  
9.            <value>22</value>  
10.        </property>  
11. <pre class="html" name="code"></bean>  
12. </beans>
    

这样，HelloWorldTest 便会去调用Japanese类的sayHelloWorld()方法；用这种形式，我们只要修改beans.xml的配置便可以改变HelloWorldTest 类中human对象，并且不需要重新部署项目，这样就实现了human对象的热拔插。</p>  

总结：从上面的代码可以看出Spring的bean工厂主要实现了以下几个步骤
1.解析配置文件（bean.xml）
2.使用反射机制动态加载每个class节点中配置的类
3.为每个class节点中配置的类实例化一个对象
4.使用反射机制调用各个对象的seter方法，将配置文件中的属性值设置进对应的对象
5.将这些对象放在一个存储空间（beanMap）中</p>  
6.使用getBean方法从存储空间（beanMap）中取出指定的JavaBean
PS：IOC的标准定义：
(Inversion of Control)
中文译为： 控制反转
IOC的基本概念是：不创建对象，但是描述创建它们的方式。在代码中不直接与对象和服务连接，但在配置文件中描述哪一个组件需要哪一项服务。容器负责将这些联系在一起。