你的位置:首页 > ASP.net教程

[ASP.net教程]设计模式——工厂模式


常说的工厂模式一般认为有三种:简单工厂、工厂方法模式、抽象工厂模式。其中简单工厂严格上来说不是一种设计模式,而被认为是一种好的编码习惯/风格。

 

简单工厂

简单工厂的本质就是封装变化的代码,使客户代码将要面临的改变变少。而且被封装的代码也有了更好的复用性,比如服务多个客户端或者被继承/包装等工具来扩展。

下面以肾5和肾6为对象来说明

//define product(iphone) interfacepublic interface IPhone{  public void model();  }//iphone5public class Phone5 implements IPhone{  public void model(){    System.out.printf("it is ipone5");  }}//iphone6public class Phone6 implements IPhone{  public void model(){    System.out.printf("it is ipone6");  }}//Client: An apple storepublic class AppleStore{  public IPhone sellPhone(String model){    if(model.equals("5")){      return new Phone5();    } else if(model.equals("6")){      return new Phone6();    }   }}//change it with SimpleFactory//Client: An apple storepublic class AppleStore{  private PhoneFactory factory;  public IPhone sellPhone(String model){    return factory.createPhone(model);  }}public class PhoneFactory{  public IPhone createPhone(String model){    if(model.equals("5")){      return new Phone5();    } else if(model.equals("6")){      return new Phone6();    }   }}

      从上面使用简单工厂的前后我们可以看出,简单工厂仅仅就是把if else那部分易变的代码,因为会不断的有新产品退出或者有旧的产品不再出售,进行了封装。但是这样的改变带来的优点也是很明显的。比如前面提到的服务多个客户端,假如还有一个仓库管理系统也可以利用这个PhoneFactory来创建iphone,而不用重新写一份if else的代码;再比如,假设在美国卖的是64GB版本,在中国卖的都是128GB版本,那么可以保持客户端的代码不变,只要修改一下我们提供的接口类PhoneFactory即可达到相同信号但是不同产品的目的。也可以给AppleStore添加setFactory方法来设置不同版本的Factory以达到动态设定的效果。

      从"对修改关闭"的原则上来看,简单工厂也能使代码更贴近这种原则。采用简单工厂之后,需要修改的只是自己控制的工厂代码,而对于客户代码则不需要修改,遵循了“对修改关闭”原则。

      也有把createPhone写成静态方法的,这样的做法就可以不用创建工厂实例,但缺点就是不能通过继承来改变工厂。

工厂模式

      工厂方法模式:定义一个创建对象的接口,但由子类决定要实例化的类是哪一个,把类的实例化推迟到工厂子类中。

      下面我们看一个具体的实例,使用工厂方法模式来重写上面的卖手机模型。

 1 //change it with FactoryMode 2 //Client: An apple store 3 public class AppleStore{ 4   private PhoneFactory factory; 5  6   public AppleStore(PhoneFactory factoy){ 7     this.factory = factory; 8   } 9 10   public IPhone sellPhone(String model){11     return factory.createPhone(model);12   }13 }14 15 //factory interface16 public abstract class PhoneFactory{17   public final IPhone createPhone(String model){18     return wrap(assemble(model));19   }20 21   public final void wrap(IPhone phone){22     System.out.printf("wrap this phone");23     return phone;24   }25 26   abstract IPhone assemble(String model);27 }28   29 // fatory of USA30 public class PhoneFactoryA extends PhoneFactory{31   public IPhone assemble(String model){32     if(model.equals("5")){33       return new Phone5ForA();34     } else if(model.equals("6")){35       return new Phone6ForA();36     } 37   }38 }39 40 //factory of CHN41 public class PhoneFactoryC extends PhoneFactory{42   public IPhone assemble(String model){43     if(model.equals("5")){44       return new Phone5ForC();45     } else if(model.equals("6")){46       return new Phone6ForC();47     } 48   }49 }50 51 52 //applestore in usa53 AppleStore usaStore = new AppleStore(new PhoneFactoryA());54 //applestore in CHN55 AppleStore chnStore = new AppleStore(new PhoneFactoryC());

      上面的工厂方法模型中,我们首先创建了一个工厂接口,然后分别实现了其子类USA工厂和CHN工厂,以分别制造适应不同国家的版本。Phone5ForA等对应的是不同国家的不同版本的类,代码中没有写出来。如果又要开一个HK店,那么只要实现一个HKPhoneFactoy子类即可。

      上面比较重要的一点是:写了两个final方法:创建手机和包装手机,然后从代码可以看出来,手机组装好后,必须经过wrap(包装)才可以从store中售出。我们知道final方法不可以被重写,也就是说,上面的流程:“组装-包装-出售”是不可以在子类中被更改的,这样的话,就可以防止不良工厂卖出没有包装盒的手机,即就对子类的一些行为进行了控制,这也是工厂方法模式中很重要的一点。

      工厂方法最重要的特点的就是创建工厂接口,使得能够针对接口编程,而不是针对实现编程,简单工厂就是针对实现编程。使用针对接口编程可以带来更大的弹性。工厂方法接口的子类与简单工厂中的工厂十分相似,从功能上看也是一致的,都实现了封装变化部分的效果。但是从大局上看,简单工厂仅仅就是实现封装变化部分的效果,而工厂方法模式则是搭建了一个很有弹性的框架。

 

抽象工厂模式

抽象工厂定义:提供一个接口,用于创建相关或依赖对象的家族,而不需要明确指定具体类。

继续上面的例子。我们知道手机是由多个零件组装起来的,比如CPU,屏幕等,对于上面的Phone5和Phone6,组装他们的时候都需要CPU和屏幕,但是各自的具体零件型号又不相同,这时,就该我们的抽象工厂方法上场了。

//define product(iphone) interfacepublic interface IPhone{  protected IComponentFactory componentFactory;  public void model();  }//iphone5public class Phone5 implements IPhone{  public Phone5(){    componentFactory = new ComponentFactory5();  }  public void model(){    System.out.printf("it is ipone5");  }}//iphone6public class Phone6 implements IPhone{  public Phone6(){    componentFactory = new ComponentFactory6();  }  public void model(){    System.out.printf("it is ipone6");  }}//ComponentFactory interfacepublic interface IComponentFactory{  protected CPU cpu;  protected Screen screen;}//ComponentFactory5public class ComponentFactory5 implements IComponentFactory{  public ComponentFactory5(){    cpu = CPUFactory.createCPU(5);    screen = ScreenFactory.createScreen(5);}//ComponentFactory6public class ComponentFactory6 implements IComponentFactory{  public ComponentFactory6(){    cpu = CPUFactory.createCPU(6);    screen = ScreenFactory.createScreen(6);}//cpupublic interface CPU{}public class CPU5 implements CPU{}public class CPU6 implements CPU{}public class CPUFactory{  public static CPU createCPU(int model){    if(model == 5){       return new CPU5();    } else if (model == 6){       return new CPU6();    }}//screenpublic interface Screen{}public class Screen5 implements Screen{}public class Screen6 implements Screen{}public class ScreenFactory{  public static Screen createScreen(int model){    if(model == 5){       return new Screen5();    } else if (model == 6){       return new Screen6();    }}

      在上面的代码中,组装Phone5和Phone6都需要CPU和Screen零件,于是他们都有一个零件工厂IComponentFactory(抽象工厂接口),各自的零件工厂都指定了自己需要什么样子的零件。而零件工厂创建零件的时候,则都是分别调用的具体零件工厂CPUFactory和ScreenFactory来创建具体的零件,也即本抽象工厂的实现中也应用到了前面提到的工厂方法模型。从这里也可以发现:抽象工厂他们不真正的制造具体的对象,他们仅仅指定我们需要什么要的对象,就好比抽象工厂方法就是一张装配清单(比如大部分手机厂干的就是这个活),而工厂方法则是负责制造这个装配清单上的具体零件(比如高通、联发科等就是干的制造CPU的活),这也许是抽象工厂之所以被叫做抽象的原因。更进一步的我们可以发现,抽象工厂其实可以理解为组装工厂,它的模型就是通过组合不同的Component来实现的;而工厂方法模式则是通过继承,把具体实现交给子类来实现的。

      在上面的抽象工厂代码中,Phone类不需要关心CPU和Screen具体是怎么创建的(这些具体的创建都是CPUFactory和ScreenFactory),而只知道我需要哪种CPU和Screen,这样就把Phone从具体的CPU和Screen类解耦了。