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

来源：互联网发布：ubuntu jenkins git 编辑：程序博客网时间：2024/05/20 23:03

（一）工厂模式

从一个例子开始讲起：

首先我们建立一个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>  
<p><br>  
这样，HelloWorldTest 便会去调用Japanese类的sayHelloWorld()方法；用这种形式，我们只要修改beans.xml的配置便可以改变HelloWorldTest 类中human对象，并且不需要重新部署项目，这样就实现了human对象的热拔插。</p>  
<p>从上面的代码可以看到spring IOC的这种实现方式主要是靠BeanFactory这个类，那么这个BeanFactory到底有什么神奇之处呢？</p>  
<p>下面让我们模拟实现一个BeanFactory：</p>  
<p><br>  
 </p>  
<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>  
<p><br>  
</p>  
<p>测试方法的执行结果：你好，极度暴走</p>  
<p>漩涡鸣人</p>  
<p>22</p>  
<p> </p>  
<p>总结：从上面的代码可以看出Spring的bean工厂主要实现了以下几个步骤</p>  
<p>1.解析配置文件（bean.xml）</p>  
<p>2.使用反射机制动态加载每个class节点中配置的类</p>  
<p>3.为每个class节点中配置的类实例化一个对象</p>  
<p>4.使用反射机制调用各个对象的seter方法，将配置文件中的属性值设置进对应的对象</p>  
<p>5.将这些对象放在一个存储空间（beanMap）中</p>  
<p>6.使用getBean方法从存储空间（beanMap）中取出指定的JavaBean</p>  
<p> </p>  
<p>PS：IOC的标准定义：</p>  
<p>(Inversion of Control) </p>  
<p>　　中文译为： 控制反转</p>  
<p>　　IOC的基本概念是：不创建对象，但是描述创建它们的方式。在代码中不直接与对象和服务连接，但在配置文件中描述哪一个组件需要哪一项服务。容器负责将这些联系在一起。</p>  
<p> </p>  
<p> </p>  
<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">           
            <p style="font-size:12px;">版权声明：本文为博主原创文章，未经博主允许不得转载。</p>  
        </div>  

1 0