设计模式-工厂方法模式

参考http://blog.csdn.net/m13666368773/article/details/7676711

如果使用简单工厂模式，则工厂类必定过于臃肿。因为简单工厂模式只有一个工厂类，它需要处理所有的创建的逻辑。假如以上需求暂时只支持3种导出的格式以及2种导出的结构，那工厂类则需要6个if else来创建6种不同的类型。如果日后需求不断增加，则后果不堪设想。

简单工厂模式将所有的判断语句和创建新的类对象都放在factory当中，判断之后进行 new 对应子类

　　这时候就需要工厂方法模式来处理以上需求。在工厂方法模式中，核心的工厂类不再负责所有的对象的创建，而是将具体创建的工作交给子类去做。这个核心类则摇身一变，成为了一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个类应当被实例化这种细节。

　　这种进一步抽象化的结果，使这种工厂方法模式可以用来允许系统在不修改具体工厂角色的情况下引进新的产品，这一特点无疑使得工厂方法模式具有超过简单工厂模式的优越性。下面就针对以上需求设计UML图：

 

从上图可以看出，这个使用的工厂方法模式的系统涉及到以下角色：

 

　　抽象工厂（ExportFactory）角色：担任这个角色的是工厂方法模式的核心，任何在模式中创建对象的工厂类必须实现这个接口。在实际的系统中，这个角色也常常使用抽象类实现。

　　具体工厂（ExportHtmlFactory、ExportPdfFactory）角色：担任这个角色的是实现了抽象工厂接口的具体JAVA类。具体工厂角色含有与业务密切相关的逻辑，并且受到使用者的调用以创建导出类（如：ExportStandardHtmlFile）。

　　抽象导出（ExportFile）角色：工厂方法模式所创建的对象的超类，也就是所有导出类的共同父类或共同拥有的接口。在实际的系统中，这个角色也常常使用抽象类实现。

　　具体导出（ExportStandardHtmlFile等）角色：这个角色实现了抽象导出（ExportFile）角色所声明的接口，工厂方法模式所创建的每一个对象都是某个具体导出角色的实例。

源代码

　　首先是抽象工厂角色源代码。它声明了一个工厂方法，要求所有的具体工厂角色都实现这个工厂方法。参数type表示导出的格式是哪一种结构，如：导出HTML格式有两种结构，一种是标准结构，一种是财务需要的结构

[java]  view plain copy print ?

1. package com.bankht.factoryMethod;  
2.   
3. /** 
4.  * @author: 特种兵—AK47 
5.  * @创建时间：2012-6-19 下午02:53:10 
6.  *  
7.  * @类说明 ：抽象工厂角色 
8.  */  
9. public interface ExportFactory {  
10.     public ExportFile factory(String type);  
11. }  

具体工厂角色类源代码：

[java]  view plain copy print ?

1. package com.bankht.factoryMethod;  
2.   
3. /** 
4.  * @author: 特种兵—AK47 
5.  * @创建时间：2012-6-19 下午02:54:54 
6.  *  
7.  * @类说明 ：具体工厂角色类 
8.  */  
9. public class ExportHtmlFactory implements ExportFactory {  
10.   
11.     @Override  
12.     public ExportFile factory(String type) {  
13.         // TODO Auto-generated method stub  
14.         if ("standard".equals(type)) {  
15.   
16.             return new ExportStandardHtmlFile();  
17.   
18.         } else if ("financial".equals(type)) {  
19.   
20.             return new ExportFinancialHtmlFile();  
21.   
22.         } else {  
23.             throw new RuntimeException("没有找到对象");  
24.         }  
25.     }  
26.   
27. }  

 

[java]  view plain copy print ?

1. package com.bankht.factoryMethod;  
2.   
3. /** 
4.  * @author: 特种兵—AK47 
5.  * @创建时间：2012-6-19 下午02:55:04 
6.  *  
7.  * @类说明 ：具体工厂角色类 
8.  */  
9. public class ExportPdfFactory implements ExportFactory {  
10.   
11.     @Override  
12.     public ExportFile factory(String type) {  
13.         if ("standard".equals(type)) {  
14.   
15.             return new ExportStandardHtmlFile();  
16.   
17.         } else if ("financial".equals(type)) {  
18.   
19.             return new ExportFinancialHtmlFile();  
20.   
21.         } else {  
22.             throw new RuntimeException("没有找到对象");  
23.         }  
24.     }  
25.   
26. }  

抽象导出角色类源代码：

[java]  view plain copy print ?

1. package com.bankht.factoryMethod;  
2.   
3. /** 
4.  * @author: 特种兵—AK47 
5.  * @创建时间：2012-6-19 下午02:55:47 
6.  *  
7.  * @类说明 ：抽象导出文件类 
8.  */  
9. public interface ExportFile {  
10.     public boolean export(String data);  
11. }  

具体导出角色类源代码，通常情况下这个类会有复杂的业务逻辑。

财务：

[java]  view plain copy print ?

1. package com.bankht.factoryMethod;  
2.   
3. /** 
4.  * @author: 特种兵—AK47 
5.  * @创建时间：2012-6-19 下午02:54:54 
6.  *  
7.  * @类说明 ：导出财务版HTML文件 
8.  */  
9. public class ExportFinancialHtmlFile implements ExportFile {  
10.   
11.     @Override  
12.     public boolean export(String data) {  
13.         // TODO Auto-generated method stub  
14.         /** 
15.          * 业务逻辑 
16.          */  
17.         System.out.println("导出财务版HTML文件");  
18.         return true;  
19.     }  
20.   
21. }  

 

[java]  view plain copy print ?

1. package com.bankht.factoryMethod;  
2.   
3. /** 
4.  * @author: 特种兵—AK47 
5.  * @创建时间：2012-6-19 下午02:54:54 
6.  *  
7.  * @类说明 ：导出财务版PDF文件 
8.  */  
9. public class ExportFinancialPdfFile implements ExportFile {  
10.   
11.     @Override  
12.     public boolean export(String data) {  
13.         // TODO Auto-generated method stub  
14.         /** 
15.          * 业务逻辑 
16.          */  
17.         System.out.println("导出财务版PDF文件");  
18.         return true;  
19.     }  
20.   
21. }  

普通：

[java]  view plain copy print ?

1. package com.bankht.factoryMethod;  
2.   
3. /** 
4.  * @author: 特种兵—AK47 
5.  * @创建时间：2012-6-19 下午02:54:54 
6.  *  
7.  * @类说明 ：导出标准HTML文件 
8.  */  
9. public class ExportStandardHtmlFile implements ExportFile {  
10.   
11.     @Override  
12.     public boolean export(String data) {  
13.         // TODO Auto-generated method stub  
14.         /** 
15.          * 业务逻辑 
16.          */  
17.         System.out.println("导出标准HTML文件");  
18.         return true;  
19.     }  
20.   
21. }  

 

[java]  view plain copy print ?

1. package com.bankht.factoryMethod;  
2.   
3. /** 
4.  * @author: 特种兵—AK47 
5.  * @创建时间：2012-6-19 下午02:54:54 
6.  *  
7.  * @类说明 ：导出标准PDF文件 
8.  */  
9. public class ExportStandardPdfFile implements ExportFile {  
10.   
11.     @Override  
12.     public boolean export(String data) {  
13.         // TODO Auto-generated method stub  
14.         /** 
15.          * 业务逻辑 
16.          */  
17.         System.out.println("导出标准PDF文件");  
18.         return true;  
19.     }  
20.   
21. }  

22. 客户端角色类源代码：

    [java]  view plain copy print ?

    1. package com.bankht.factoryMethod;  
    2.   
    3. import org.junit.Test;  
    4.   
    5. /** 
    6.  * @author: 特种兵—AK47 
    7.  * @创建时间：2012-6-19 下午02:59:25 
    8.  *  
    9.  * @类说明 ：测试工厂方法模式类 
    10.  */  
    11. public class TestFactoryMethod {  
    12.   
    13.     @Test  
    14.     public void testFactoryMethod() {  
    15.         String data = "";  
    16.         ExportFactory exportFactory = new ExportHtmlFactory();  
    17.         ExportFile ef = exportFactory.factory("financial");  
    18.         ef.export(data);  
    19.     }  
    20.   
    21. }  

    首先做工厂类的虚类，然后继承，实现对应每个对象对应的工厂类，在实现的工厂类中创建对应的功能性类，进行返回

    在客户端，先new ***Factory

    再调用对应子Factory中创建功能性类的函数

    
    

    简单工厂模式最大的优势是工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类

    工厂方法类定义了一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类中
    工厂方法模式的活动序列图

    
    

    　　客户端创建ExportHtmlFactory对象，这时客户端所持有变量的静态类型为ExportFactory，而实际类型为ExportHtmlFactory。然后客户端调用ExportHtmlFactory对象的工厂方法factory()，接着后者调用ExportFinancialHtmlFile的构造子创建出导出对象。

    工厂方法模式和简单工厂模式

    　　工厂方法模式和简单工厂模式在结构上的不同很明显。工厂方法模式的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。
    　　工厂方法模式退化后可以变得很像简单工厂模式。设想如果非常确定一个系统只需要一个具体工厂类，那么不妨把抽象工厂类合并到具体工厂类中去。由于只有一个具体工厂类，所以不妨将工厂方法改为静态方法，这时候就得到了简单工厂模式。

    　　如果系统需要加入一个新的导出类型，那么所需要的就是向系统中加入一个这个导出类以及所对应的工厂类。没有必要修改客户端，也没有必要修改抽象工厂角色或者其他已有的具体工厂角色。对于增加新的导出类型而言，这个系统完全支持“开-闭原则”。
    　　

    完结

    　　一个应用系统是由多人开发的，导出的功能是你实现的，但是使用者（调用这个方法的人）可能却是其他人。这时候你应该设计的足够灵活并尽可能降低两者之间的耦合度，当你修改或增加一个新的功能时，使用者不需要修改任何地方。假如你的设计不够灵活，那么将无法面对客户多变的需求。可能一个极小的需求变更，都会使你的代码结构发生改变，并导致其他使用你所提供的接口的人都要修改他们的代码。牵一处而动全身，这就使得日后这个系统将难以维护