饺子馆(冬至)中的设计模式——工厂模式

引言

今天是冬至,去饺子馆吃饺子,看他们店里面的水饺种类挺多,在等待中,在想是不是可以用设计模式模拟一下,生产饺子的过程,正好最近也在看工厂模式,也就现学现卖了。当然,实现的方式很多,只是一个例子而已。祝大家冬至,多多吃水饺.....

对象创建的问题?

我们应该面向接口编程而不是面向实现编程,因为面向实现编程会使得我们的设计更脆弱,缺乏灵活性。但是我们每次使用new时,是不是正在违背这一设计原则呢?

当我们拥有一组相关的具体类时,是不是常常被迫写出类似下面的代码?

 Duck duck;
 
 if(picnic){
 
 duck=new MallardDuck();
 
 }else if(hunting){
 
 duck=new DecogDuck();
 
 }else if(inBathTub){
 
 duck=new RubberDuck();
 
 }

(以上为伪代码,只为说明问题)

向上面的实例化过程,知道运行时我们才知道需要实例化哪个类。

这样做的后果是如果应用要做变化或扩展,往往要修改这段代码。这使得维护困难,并容易引入错误。

问题在哪儿?

出现上面那种问题,是不是new的问题呢?

从技术上来说,new并没有任何问题。new只是面向对象语言的最基本部分,真正的问题在于“变化”。

如果对接口编程,我们可以实现与许多“变化”的隔离,因为通过多态机制,我们的代码对于实现接口的新类依然适用。但是使用具体类麻烦就来了,因为增加新的具体类时相应的代码可能就必须修改?

怎么办?

面向对象的设计原则:识别变化的部分,并将与不变化的部分相分离。

书中Pizza店案例分析

PizzaStore类中的一段代码-订做pizza

修改后的代码

由于市场竞争,其他pizza店推出了新产品,我们也得增加!例如VeggiePizza。 GreekPizza最近不受欢迎,把它从菜单中取消。

于是。。。

分析:变与不变的部分

分离

我们将专管制作pizza的对象叫做Pizza工厂

Pizza工厂---SimplePizzaFactory

思考一下?

这看来好像我们只是把问题从一个对象推给了另一个对象!这样做有什么好处?

SimplePizzaFactory可以有许多个客户,这样,当实现改变时我们只需要修改SimplePizzaFactory,而不需修改众多的客户。 提高了聚合度,PizzaStore的职责是使用pizza对象, SimplePizzaFactory的职责是决定创建什么样的pizza对象。

用工厂重写PizzaStore类

 public class PizzaStore {
    SimplePizzaFactory factory;
    public PizzaStore(SimplePizzaFactory factory) {
        this.factory = factory;
    }
    public Pizza orderPizza(String type) {
         Pizza pizza;
         pizza=factory.createPizza(type);
         pizza.prepare();
         pizza.bake();
         pizza.cut();
         pizza.box();
         return pizza;
    }
    //other methods here
 }

简单工厂模式

饺子馆中的简单工厂实现

水饺要实现的接口

   /// <summary>
     /// 水饺要实现的接口
     /// </summary>
     public interface IDumpling
     {
         string DumplingName { get; }
         /// <summary>
         /// 水饺的准备阶段方法
         /// </summary>
         void Prepare();
         /// <summary>
         /// 煮
         /// </summary>
         void Boild();
         /// <summary>
         /// 展示订单
         /// </summary>
         void Show();
     }

具体的水饺类

  /// <summary>
     /// 猪肉大葱水饺类
     /// </summary>
     public class PorkAndScallionDumpling:IDumpling
     {
 
         public string DumplingName
         {
             get { return "猪肉大葱水饺"; }
         }
 
         public void Prepare()
         {
             Console.WriteLine("准备猪肉茴香水饺25个");
         }
 
         public void Boild()
         {
             Console.WriteLine("正在煮......请稍等.....");
         }
 
         public void Show()
         {
             Console.WriteLine("您的{0},准备好了。", this.DumplingName);
         }
     }
 /// <summary>
     /// 猪肉茴香水饺类
     /// </summary>
     public class PorkAndFennelDumpling : IDumpling
     {
         public string DumplingName
         {
             get { return "猪肉茴香水饺"; }
         }
 
         public void Prepare()
         {
             Console.WriteLine("准备猪肉茴香水饺25个");
         }
 
         public void Boild()
         {
             Console.WriteLine("正在煮......请稍等.....");
         }
 
         public void Show()
         {
             Console.WriteLine("您的{0},准备好了。", this.DumplingName);
         }
     }

工厂类

   /// <summary>
     /// 水饺的生产工厂
     /// </summary>
     public static class SimpleDumplingFactory
     {
         public static IDumpling CreateDumpling(string dumplingName)
         {
             IDumpling dumpling = null;
             switch (dumplingName)
             {
                 case "猪肉大葱":
                     dumpling = new PorkAndScallionDumpling();
                     break;
                 case "猪肉茴香":
                     dumpling = new PorkAndFennelDumpling();
                     break;
             }
             return dumpling;
         }
     }

控制台代码

     class Program
     {
         static void Main(string[] args)
         {
             IDumpling dumpling = SimpleDumplingFactory.CreateDumpling("猪肉茴香");
             dumpling.Prepare();
             dumpling.Boild();
             dumpling.Show();
             Console.Read();
         }
     }

结果

授权pizza店

我们的pizza店非常成功,许多人都想开设我们的授权加盟店。为保证质量,我们希望他们使用我们经过时间考验的代码。 但是,不同地区的加盟pizza店可能希望供应不同口味的pizza。怎么解决这个问题呢?

解决方法之一:建立不同的工厂

 //建立不同的工厂:如NYPizzaFactory、 ChicagoPizzaFactory、 CaliforniaPizzaFactory,在PizzaStore中包含相应工厂的实例。其代码类似于:
 //该pizza店提供纽约风味的pizza
 NYPizzaFactory nyFactory=new NYPizzaFactory();//建立一个生产纽约风味pizza的工厂
 PizzaStore nyStore=new PizzaStore(nyFactory);//建立一个pizza店,引用纽约风味pizza的工厂
 nyStore.orderPizza(“Veggie”);//生产的是纽约风味的pizza
 
 //该pizza店提供芝加哥风味的pizza
 ChicagoPizzaFactory chicagoFactory=new ChicagoPizzaFactory();
 PizzaStore chicagoStore=new PizzaStore(chicagoFactory);
 chicagoStore.orderPizza(“Veggie”);

抽象工厂模式

这么多工厂,可以再增加抽象层 另一种解决方法-工厂方法模式

思路:改写的PizzaStore,将createPizza()方法放回到PizzaStore,但是声明为抽象方法,然后,为每一种地方风味创建一个PizzaStore的子类。

改造后的PizzaStore的代码

 public abstract class PizzaStore {
    
    public Pizza orderPizza(String type) {
       Pizza pizza = createPizza(type);//在PizzaStore内调用自身的一个方法来制造pizza,而不是使用一个factory对象
 
       pizza.prepare();
       pizza.bake();
       pizza.cut();
       pizza.box();
       return pizza;
      }
     abstract Pizza createPizza(String type);//factory对象成了这里的一个抽象方法
 
 }

下面我们需要PizzaStore的各种子类(对应不同的地区风味)

让子类做决定

声明工厂方法

abstract Pizza createPizza(String type);
abstract Product factoryMethod(String type);

工厂方法是抽象的,在一个超类中定义。必须由子类来实现。 工厂方法返回一个产品,该产品通常在其所在类的方法中定义。(如orderPizza()) 工厂方法通常提供参数,用以选择一个产品的不同品种。 工厂方法将客户(超类中的方法,如PizzaStore中的orderPizza())与具体的产品相隔离。

工厂方法怎么工作?

假定张三喜欢纽约风味的pizza,李四喜欢芝加哥风味的pizza。 需要相应Pizza店的实例 调用orderPizza()订购想要的pizza品种 createPizza()被调用,并返回pizza到orderPizza()方法。 尽管不知道是什么pizza,但orderPizza()仍知道对它进行后续处理。

工厂方法模式中的类

创建者类 The Creator classes

产品类 The Product classes

工厂方法模式的定义

定义一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法模式让一个类的实例化延迟到其子类。

工厂方法模式的结构

总结:Factory Method模式

意图 定义一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法模式让一个类的实例化延迟到其子类。 别名 虚拟构造器

Factory Method—参与者

Product(document)定义工厂方法所创建对象的接口。 ConcreteProduct(mydocument)实现product接口。 Creator(application)声明工厂方法,可以调用工厂方法以创建一个product对象 ConcreteCreator (MyApplication)重新定义工厂方法,以返回一个ConcreteProduct实例

(篇幅有点长,关于工厂方法模式的实例就不再列举了,感兴趣的可以自己实现一下)

参考书:

《First Head 设计模式》