设计模式-抽象工厂

这篇博文主要用来介绍抽象工厂设计模式，也是对自己学习设计模式的一个简单总结。

设计模式主要是用来解决特定条件下某种类型问题的方法，因为在实际编程过程中，某种情况的问题会反复出现，人们便对这些问题进行总结，提出解决这一类问题的方法。抽象工厂也不例外，它的提出主要也是用来解决产生实例的问题。从工厂方法的介绍中了解到，工厂方法一般对有共同抽象父类的产品生产非常适用；并且在产品类型增加时，会导致系统类数量急剧增加，不断导致代码量加大，也加大了系统后续维护的难度。抽象工厂是在原有基础上进一步抽象得到的。

我们首先来看看抽象工厂一般的结构图：

图.1 结构图

从上面图可以清晰知道抽象工厂的结构图。

抽象工厂，是抽象工厂模式的核心，具体工厂的父类，是该模式的核心。客户通过创建其某种类型的子类来决定其生产的产品种类。

抽象产品，在抽象工厂模式中可能有多个抽象产品，它们之间并没有相互依存或者继承的关系，可以按照抽象产品来将系统中的具体产品划分为某个系列。同继承于相同的子类分属于一个系列中。

处在相似结构位置的子类划分为一个产品族，图.1 结构图中，具体产品A1和具体产品B1便属于一个产品族，同理，具体产品A2和具体产品B2也属于一个产品族。

图.2  横轴为产品系列，纵轴为产品族

每一个产品系列有一个共同的父类，每个系列中的具体产品属于不同的产品族。每一个产品族对应着一个具体的工厂。因为每个产品族中至少有一个产品，因此具体的工厂至少有生产该产品的工厂方法。

下面给出示例代码，首先是抽象产品和具体产品的代码

1: public interface PC {
2:     public void start();
3:     public void shutdown();
4:     public void reboot();
5: }
6: public class Desktop implements PC {
7:  
8: public void start() {
9: System.out.println("Desktop start");
10: }
11: public void shutdown() {
12: System.out.println("Desktop shutdown");
13: }
14: public void reboot() {
15: System.out.println("Desktop reboot");
16: }
17: }
18: public class Notebook implements PC {
19:  
20: public void start() {
21: System.out.println("Notebook start");
22: }
23: public void shutdown() {
24: System.out.println("Notebook shutdown");
25: }
26: public void reboot() {
27: System.out.println("Notebook reboot"); 28: } 29: public void moveAway(){ 30: System.out.println("Notebook move away"); 31: } 32: } 33: public class Pad implements PC { 34:   35: public void start() { 36: System.out.println("Pad start"); 37: } 38: public void shutdown() { 39: System.out.println("Pad shutdown"); 40: } 41: public void reboot() { 42: System.out.println("Pad reboot"); 43: } 44: } 45:  

另外一种产品系列代码如下：

1: public interface ScreenProtector { 2:   3: abstract public void makeProtector(); 4: } 5: public class DesktopScreenProtector implements ScreenProtector { 6:   7: public DesktopScreenProtector(){ 8: } 9: public void makeProtector(){ 10: System.out.println("make Desktop Screen protector!"); 11: return; 12: } 13: } 14: public class NotebookScreenProtector implements ScreenProtector { 15:   16: public NotebookScreenProtector(){ 17: } 18: public void makeProtector(){ 19: System.out.println("make Notebook Screen protector!"); 20: return; 21: } 22: } 23: public class PadScreenProtector implements ScreenProtector { 24:   25: public PadScreenProtector(){ 26: } 27: public void makeProtector(){ 28: System.out.println("make Pad Screen protector!"); 29: return; 30: } 31: } 32:  

下面给出抽象工厂及具体工厂的示例代码:

1: public interface AbstractFacorty { 2:   3: abstract public PC producePC(); 4: abstract public ScreenProtector produceScreenProtector(); 5: } 6: public class ConcreteFactoryA implements AbstractFacorty { 7:   8: public PC producePC() { 9: return new Desktop(); 10: } 11: public ScreenProtector produceScreenProtector() { 12: return new DesktopScreenProtector(); 13: } 14: } 15: public class ConcreteFactoryB implements AbstractFacorty { 16:   17: public PC producePC() { 18: return new Notebook(); 19: } 20: public ScreenProtector produceScreenProtector() { 21: return new NotebookScreenProtector(); 22: } 23: } 24: public class ConcreteFactoryC implements AbstractFacorty { 25:   26: public PC producePC() { 27: return new Pad(); 28: } 29: public ScreenProtector produceScreenProtector() { 30: return new PadScreenProtector(); 31: } 32: } 33:  

客户端的代码直接产生需要产品对应的具体工厂，然后由具体工厂来生产所需产品，代码如下：

1: public class Customer { 2:   3: public static void main(String[] args){ 4: AbstractFacorty factory = null; 5: PC pc = null; 6: ScreenProtector sp = null; 7: factory = new ConcreteFactoryA(); 8: pc = factory.producePC(); 9: sp = factory.produceScreenProtector(); 10:   11: factory = new ConcreteFactoryB(); 12: pc = factory.producePC(); 13: sp = factory.produceScreenProtector(); 14: } 15: }

从具体工厂方法中可以清晰的看到，每个具体工厂都有两个工厂方法，分别用来穿件产品族中的不同产品。当系统中产品结构比较复杂时，显然利用抽象工厂比利用工厂方法要高效(工厂方法主要是应对两层结构)。用抽象工厂模式，将抽象工厂及具体工厂跟产品等级结构对应，可以很好的实现系统功能。

抽象工厂是对工厂方法的进一步抽象得到的设计模式，可以说抽象工厂一般应用于较工厂方法更复杂的系统环境中。抽象工厂一般适用于系统有多个产品族，而且产品族中的产品都有可能被使用。在一般情况下，系统只需要调用一种类型的具体工厂，创建一个产品族，使用该产品族中的具体产品。在同一个系列的产品都拥有相同的接口，系统针对接口编程，而不依赖于产品的具体创建。

系统扩展性分析

• 系统增加产品族时，需要在每个产品系列抽闲产品下新增具体产品，具体产品从各自的父类继承；在抽象工厂下，创建一个新的子类工厂，实现其工厂方法，分别用来创建新增的具体产品。在这种情况下，系统原有代码不会改变，只需要新增加代码即可。对扩展开放，对修改关闭。
• 系统增加产品系列时，因为每个具体工厂都需要完成创建每个产品族中的具体产品，新增加的每个具体产品都被分配到不同的具体工厂负责完成创建，因此，需要对每个具体工厂做修改，添加生产新产品的工厂方法。系统抽象工厂类也需要新增加抽象的工厂方法，子类共同的部分最好移到父类中。在这点上，系统并不满足“开－闭”原则，对修改不闭合，需要修改系统原有代码。

Technorati Tags: ,,