Java设计模式之工厂模式

Java设计模式：工厂（Factory）模式

1.问题分析

• 首先，给出一个不够合理的披萨店设计

  public class OldStore {
      Pizza orderPizza(){
          Pizza pizza = new Pizza();
          pizza.prepare(); 
          pizza.bake(); 
          pizza.cut();
          pizza.box(); 
          return pizza; 
      }
  }

• 如果我们需要更多不同种类的pizza，那么我们就要增加代码来确定pizza的类型，然后才能制造pizza，那么，披萨店的设计代码就可能变成下面这样：

  public class OldStore {
      Pizza orderPizza(String type){
          Pizza pizza = new Pizza();
          //-----不停变化的部分-----
          if(type.equals("cheese")){
              pizza = new ChessePizza();
          } else if (type.equals(”greek”)) { 
              pizza = new GreekPizza(); 
          } else if (type.equals(”other”)) { 
              //other type
          }
          //----------------------
          pizza.prepare(); 
          pizza.bake(); 
          pizza.cut();
          pizza.box(); 
          return pizza; 
      }
  }

我们可以发现，如果要增加不同的种类，那么，我们就必须去修改oderPizza()方法里的代码，这样，oderPizza()无法对修改关闭，所以我们需要进一步使用封装。下面给出三种类型的工厂模式。

---

2.简单工厂

• 如果需要让oderPizza()方法对修改关闭，我们应该如何设计呢？那便是将不停变化的部分，即确定披萨类型的部分抽离出来，放到另一个类里，如SimplePizzaFactory，OldStore类只需要负责从SimplePizzaFactory里获取披萨，然后进行后续操作即可。

  public class SimplePizzaFactroy {
      public Pizza createPizza(String type) { 
          Pizza pizza = null;
          if (type.equals(”cheese”)) { 
              pizza = new CheesePizza();
          } else if (type.equals(”greek”)) { 
              pizza = new GreekPizza();
          } else if (type.equals(”other”)) { 
              // other type. 
          }
          return pizza;
      }
  }

• 对应的，将OldStore重做为PizzaStore类，代码如下：

  public class PizzaStore { 
      SimplePizzaFactory factory; //加入一个对SimplePizzaFactory的引用
      //构造需要一个工厂作为参数 
      public PizzaStore(SimplePizzaFactory factory) { 
          this.factory = factory; 
      }
      public Pizza orderPizza(String type) { 
          Pizza pizza;
          //该方法通过简单传入订单类型来使用工厂创建披萨
          pizza = factory.createPizza(type); // new操作符被换为工厂对象创建方法
          pizza.prepare(); 
          pizza.bake(); 
          pizza.cut();
          pizza.box(); 
          return pizza; 
      }
  }

---

3.工厂方法

• 加盟披萨店 要求披萨店的各个加盟店能够提供不同风味的披萨，并复用代码，以使得披萨的 流程能够一致不变。利用 SimplePizzaFactory 的一般实现如下：

  NYPizzaFactory nyFactory = new NYPizzaFactory();
  PizzaStore nyStore = new PizzaStore(nyFactory);
  nyStore.orderPizza(”Veggie”) ;
  ChicagoPizzaFactory chicagoFactory = new ChicagoPizzaFactory(); 
  PizzaStore nyStore = new PizzaStore(chicagoFactory); 
  nyStore.orderPizza(”Veggie”) ;

  即以SimplePizzaFactory为父类，派生不同的工厂类。当我们希望能够建立一个框架，把加盟店和创建披萨捆绑在一起，保持披萨的质量控制，同时使得代码具有一定的弹性。我们应该怎么做呢？

• 给披萨店使用的框架采用如下框架可以使得披萨制作活动局限于 PizzaStore 类，而同时又能 让这些加盟店依然可以自由的制作该区域的风味。

  public abstract class PizzaStore {
      public Pizza OrderPizza(String type) { 
          Pizza pizza;
          // createPizza()方法从工厂对象中回到PizzaStore
          pizza = createPizza(type);
          pizza.prepare(); 
          pizza.bake(); 
          pizza.cut();
          pizza.box(); 
          return pizza; 
      }       
      // PizzaStore里的工厂方法是抽象的 
      abstract Pizza createPizza(String type); 
  }

  我们可以看到，我们将原本放在工厂中实现的创建pizza操作，放回到了PizzaStore里，我们现在只需要以PizzaStore为父类，让每个区域的不同pizza店继承，各自实现createPizza()方法就行。createPizza() 方法是个抽象方法，所有任何具体的加盟店必须实现这个方法，从而个性化加盟 店的披萨风味。例如，NYPPizzaStore的实现。

  public class NYPizzaStore extends PizzaStore {
      @Override 
      Pizza createPizza(String type) {
          if (type.equals(”cheese”)) {
              return new NYStyleCheesePizza(); 
          } else if (type.equals(”veggie”)) {
              return new NYStyleVeggiePizza(); 
          } else if (type.equals(”other”)) { 
              // other type. 
          } else 
              return null; 
      }
  }

• 原来是在简单工厂中是由一个对象负责所有具体类的实例化，现在通过对 PizzaStore 作改变，使得由一群子类来负责实例化。 工厂方法用来处理对象的创建，并将这样的行为封装在子类中，这样客户程序中关于超类的 代码就和子类对象创建代码解耦。
• 工厂方法是抽象
• 工厂方法必须返回一个产品，超类中定义的方法，通常会用到工厂方法的返回值

• 工厂方法将客户（即超类中的代码，如 orderPizza()）和实际创建具体产品的代码分隔开。

---

4.抽象工厂

• 工厂方法模式从设计角度考虑存在一定的问题：类的创建依赖工厂类。也就是说，如果想要 拓展程序，必须对工厂类进行修改，这违背了闭包原则。 所以，可以使用抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的 工厂类就可以了，不需要修改之前的代码。参考示例的4.3类图，该示例包含一个消息发送者接口 (Sender) 和一个抽象工厂接口（Provider）。

  相关代码如下：

  File: Sender.java

  package ouc.cs.course.java.test.abstractfactory;
  public interface Sender { 
      public void Send(); 
  }

  File: Provider.java

  package ouc.cs.course.java.test.abstractfactory;
  public interface Provider { 
      public Sender produce(); 
  }

  File: MailSender.java

  package ouc.cs.course.java.test.abstractfactory;
  public class MailSender implements Sender {
      public void Send() {
          System.out.println(”this is mailsender!”); 
      }
  }

  File: SmsSender.java

  package ouc.cs.course.java.test.abstractfactory;
  public class SmsSender implements Sender {
      public void Send() {
          System.out.println(”this is smssender!”); 
      }
  }

  File: SendMailFactory.java

  package ouc.cs.course.java.test.abstractfactory;
  public class SendMailFactory implements Provider {
      @Override
      public Sender produce() { 
          return new MailSender(); 
      }
  }

  File: SendSmsFactory.java

  package ouc.cs.course.java.test.abstractfactory;
  public class SendSmsFactory implements Provider {
      @Override
      public Sender produce() { 
          return new SmsSender(); 
      }
  }

  File: Test.java

  package test.abstractfactory;
  import ouc.cs.course.java.test.abstractfactory.Provider; 
  import ouc.cs.course.java.test.abstractfactory.SendMailFactory; 
  import ouc.cs.course.java.test.abstractfactory.Sender;
  
  public class Test { 
      public static void main(String[] args) { 
          Provider provider = new SendMailFactory(); 
          Sender sender = provider.produce(); 
          sender.Send(); 
      }
  }

  当你想要扩展产品种类时，只需要增加对应的工厂类和产品类即可，比如我要增加一个QQSender类，只需要新建一个QQSender类实现Sender接口和SendQQFactory类实现Provider接口即可扩展产品种类。