Spring 实现两种设计模式：工厂模式和单态模式（单例模式）

本文摘自：李刚 著 《轻量级 Java EE企业应用实战 Struts2+Spring+hibernate整合开发》

        在Spring 中大量使用的以下两种设计模式：工厂模式和单态模式。

工厂模式可将Java 对象的调用者从被调用者的实现逻辑中分离出来，调用者只需关心被调用者必须满足的规则(接口) ，而不必关心实例的具体实现过程。这是面向接口编程的优势，能提高程序的解耦，避免所有的类以硬编码方式耦合在一起。

        如果所有的类直接耦合，极易形成"骨牌效应"，假如B 类调用了A 类，一旦A 类需要修改，则B 类也需要修改；假如C 类调用了B 类，则C 类也需要修改......依次类推，从而导致整个系统都需要改写。造成"牵一发而动全身"，而系统重构的代价是相当高的。

        Spring 倡导”面向接口编程“，可以避免上述的问题，使设计良好的架构可保证系统重构的工作被封闭在重构的层内，绝不会影响其他层。

        Spring 容器是实例化和管理全部bean 的工厂，Spring 默认将所有的bean 设置成单态模式，无须自己完成单态模式，即对所有相同id 的bean 请求都将返回同一个共享实例。因此，单态模式可大大降低Java 对象在创建和销毁时的系统开销。

一. 单态模式的回顾

        单态模式限制了类实例的创建，但采用这种模式设计的类，可以保证仅有一个实例，并可提供访问该实例的全局访问点。J2EE应用的大量组件，都需要保证一个类只有一个实例。比如数据库引擎访问点只能有一个。

        更多的时候，为了提高性能，程序应尽量减少Java 对象的创建和销毁时的开销。使用单态模式可避免Java 类被多次实例化，让相同类的全部实例共享同一内存区。

        为了防止单态模式的类被多次实例化，应将类的构造器设成私有，这样就保证了只能通过静态方法获得类实例。而该静态方法则保证每次返回的实例都是同一个，这就需将该类的实例设置成类属性，由于该属性需要被静态方法访问，因此该属性应设成静态属性。

下面给出单态模式的示例代码：

  1. package ppp;  
  2. //单态模式测试类  
  3. public class SingletonTest {  
  4.     //该类的一个普通属性  
  5.     int value;  
  6.     //使用静态属性保存该类的一个实例  
  7.     private static SingletonTest instance;  
  8.     //构造器私有化，避免该类被多次实例化  
  9.     private SingletonTest(){  
  10.         System.out.println("正在执行构造器...");  
  11.     }  
  12.     //提供静态方法返回该类实例   
  13.     public static SingletonTest getInstance(){  
  14.         //实例化类实例前，先检查该实例是否存在  
  15.         if(instance == null){  
  16.             //如果不存在，则新建一个实例  
  17.             instance = new SingletonTest();  
  18.         }  
  19.         //返回该类的成员变量：该类的实例   
  20.         return instance;      
  21.     }  
  22.     //以下提供对普通属性value的getter和setter方法  
  23.     public int getValue(){  
  24.         return value;  
  25.     }  
  26.   
  27.     public void setValue(int values){  
  28.         this.value = values;      
  29.     }  
  30.     public static void main(String args[]){  
  31.         SingletonTest t1 = SingletonTest.getInstance();  
  32.         SingletonTest t2 = SingletonTest.getInstance();  
  33.         t2.setValue(9);  
  34.         System.out.println(t1 == t2);  
  35.     }  
  36. }  

        从程序最后的打印结果可以看出，该类的两个实例完全相同。这证明单态模式类的全部实例是同一共享实例。程序里虽然获得了类的两个实例，但实际上只执行一次构造器，因为对于单态模式的类，无论有多少次的创建实例请求，都只执行一次构造器。

 

二. 工厂模式的回顾

 

        工厂模式是根据调用数据返回某个类的一个实例，此类可以是多个类的某一个类。通常，这些类满足共同的规则(接口)或父类。调用者只关心工厂生产的实例是否满足某种规范，即实现的某个接口是否可供自己正常调用(调用者仅仅使用)。该模式给对象之间作出了清晰的角色划分，降低程序的耦合。

        接口产生的全部实例通常用于实现相同接口，接口里定义了全部实例共同拥有的方法，这些方法在不同的实现类中实现的方式不同。从而使程序调用者无须关心方法的具体实现，降低了系统异构的代价。

下面是工厂模式的示例代码：

  1. package ppp;  
  2.   
  3. //Person接口定义  
  4. public interface Person {  
  5.     public String sayHello(String name);  
  6.     public String sayGoodbye(String name);  
  7. }  

该接口定义了Person规范，规范要求实现该接口的类必须具有以下两个的方法：能打招呼，能告别。

  1. package ppp;  
  2. //American类实现Person接口  
  3. public class American implements Person {  
  4.     public String sayHello(String name){  
  5.         return name+",hello";  
  6.     }  
  7.     public String sayGoodbye(String name)  
  8.     {  
  9.         return name+",goodbye";  
  10.     }  
  11. }  

下面是Person类的另一个实现类：Chinese

  1. package ppp;    
  2. //Chinese类实现Person接口  
  3. public class Chinese implements Person {  
  4.     public String sayHello(String name){  
  5.         return name+",您好";  
  6.     }  
  7.     public String sayGoodbye(String name)  
  8.     {  
  9.         return name+",下次再见";  
  10.     }  
  11. }  

然后再看Person工厂的代码：

  1. package ppp;  
  2.   
  3. public class PersonFactory {  
  4.     public Person getPerson(String ethnic)  
  5.     {  
  6.         if(ethnic.equalsIgnoreCase("chin"))  
  7.         {  
  8.             return new Chinese();  
  9.         }else{  
  10.             return new American();        
  11.         }  
  12.     }  
  13. }  

以上是最简单的工厂模式框架，其主程序如下：

  1. package ppp;  
  2.   
  3. public class FactoryTest {  
  4.     public static void main(String[] args){  
  5.         //创建PersonFactory实例 ，获得工厂实例   
  6.         PersonFactory pf = new PersonFactory();  
  7.         //定义接口Person实例，面向接口编程   
  8.         Person p = null;  
  9.         //使用工厂获得person实例  
  10.         p = pf.getPerson("chin");  
  11.         //下面调用Person接口方法  
  12.         System.out.println(p.sayHello("wawa"));  
  13.         System.out.println(p.sayGoodbye("wawa"));  
  14.         //使用工厂获得Person的另一个实例  
  15.         p = pf.getPerson("ame");  
  16.         //再次调用Person接口的方法  
  17.         System.out.println(p.sayHello("wawa"));  
  18.         System.out.println(p.sayGoodbye("wawa"));  
  19.     }  
  20. }  

由此可看出，主程序从Person 接口的具体类中解耦出来，而且程序调用者无须关心Person 的实例化过程，主程序仅仅与工厂服务定位结合在一起，可获得所有工厂能产生的实例。具体类的变化，接口无须发生任何改变，调用者程序代码部分也无须发生任何改动。
下面是Spring 对这两种模式的实现。

 

三. Spring 对单态与工厂模式的实现

 

        随着Spring 提供工厂模式的实现，在使用Spring 时，无须自己提供工厂类。因为Spring容器是最大的工厂，而且是个功能超强的工厂。Spring 使用配置文件管理所有的bean ，其配置文件中bean 由Spring 工厂负责生成和管理。

下面是关于两个实例的配置文件：

  1. <!--下面是xml文件的文件头-->  
  2. <?xml version = "1.0" encoding = "gb2312"?>  
  3. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"  
  4.    "http://www.springsource.org/dtd/spring-beans.dtd">  
  5. <!--beans是Spring配置文件的根元素-->  
  6. <beans>  
  7. <!--定义第一个bean，该bean的id是chinese-->  
  8. <bean id = "chinese" class = "ppp.Chinese"/>  
  9. <!--定义第二个bean，该bean的id是American-->  
  10. <bean id = "american" class = "ppp.American"/>  
  11. </beans>  

主程序部分如下：

  1. package ppp;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.FileSystemXmlApplicationContext;  
  5. public class SpringTest {  
  6.     public static void main(String[] args) {  
  7.         //实例化Spring容器  
  8.         ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");  
  9.         //定义Person接口实例  
  10.         Person p = null;  
  11.         //通过Spring上下文获得Chinese实例  
  12.         p = (Person)ctx.getBean("chinese");  
  13.         //执行chinese实例的方法  
  14.         System.out.println(p.sayHello("wawa"));  
  15.         System.out.println(p.sayGoodbye("wawa"));  
  16.           
  17.         p = (Person)ctx.getBean("american");  
  18.         System.out.println(p.sayHello("wawa"));  
  19.         System.out.println(p.sayGoodbye("wawa"));  
  20.     }  
  21. }  

       使用Spring 时，即使没有工厂类PersonFactory ，程序一样可以使用工厂模式， Spring完全可以提供所有工厂模式的功能。

       下面对主程序部分进行简单的修改：   

  1. package ppp;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.FileSystemXmlApplicationContext;  
  5. public class SpringTest{  
  6.      public static void main(String[] args){  
  7.          //实例化Spring容器  
  8.          ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");  
  9.          //定义p1接口的实例p1  
  10.          Person p1 = null;  
  11.          //通过Spring上下文获得Chinese实例  
  12.          p1 = (Person)ctx.getBean("Chinese");  
  13.          //定义p2接口的实例p2  
  14.          Person p2 = null;  
  15.          p2 = (Person)ctx.getBean("Chinese");  
  16.          System.out.println(p1 == p2);  
  17.      }  
  18. }  

          程序的执行结果是：true

        表明Spring对接受容器管理的全部的bean，默认采用单态模式管理，建议不要随意更改bean的行为方式。因为从性能上讲，单态的bean比非单态的bean性能更为优秀。

        仔细检查上面的代码就会发现如下的特点;

        （1）除测试部分的主程序外，代码并未出现Spring的特定类和接口。

        （2）调用者的代码，也就是测试用的主程序部分，仅仅面向Person的接口编程，而无需知道实现类的具体名称。同时，通过修改配置文件来彻底切换底层的具体实现类。

        （3）由于厂无需多个实例，因此工厂应该采用单态模式设计，其中Spring上下文也就是Spring工厂，已被设计成单态。

          Spring工厂模式，不仅提供了创建bean的功能，还提供了对bean的生命周期的管理。最重要的是还以管理bean和bean之间的依赖关系。

posted @ 2017-10-19 22:21  748573200000  阅读(15140)  评论(0)  编辑  收藏  举报