设计模式:三种工厂模式

Posted renshuozz

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了设计模式:三种工厂模式相关的知识,希望对你有一定的参考价值。

三种工厂模式

简单工厂实现

简单工厂模式(严格来说这不算一种Gof的设计模式,更像是一种编程习惯)属于类的创建型模式,又叫做静态工厂方法模式。通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有相同的父类,应用继承将决定工厂的生产什么产品的决定权直接交到了客户手中,然后客户在输入自己的需求,得到最终的结果。

运用简单工厂模式实现生产pizza的业务场景。

/// <summary>
/// pizza创建工厂
/// </summary>
public class PizzaFactory

     public static Pizza CreatePizza(string pizzaType)
     
          switch (pizzaType)
          
               case "Cheese":
               return new CheesePizza();
               case "ApplePie":
               return new ApplePiePizza();
               default:
               return new SomeOtherPizza();
          
     

public abstract class Pizza

     public string Name  get; set; 

     public void Prepare()
     
          Console.WriteLine($"Preparing Name");
          
     

     public void Cut()
     
          Console.WriteLine($"Cutting the Name");
     

     public void Bake()
     
          Console.WriteLine($"Baking the Name");
     

     public void Box()
     
          Console.WriteLine($"Boxing the Name");
     


public class ApplePiePizza : Pizza

     public ApplePiePizza()
     
          Name = "ApplePie";
     


public class CheesePizza : Pizza

     public CheesePizza()
     
          Name = "Cheese";
     


public class SomeOtherPizza : Pizza

     public SomeOtherPizza()
     
          Name = "Other";
     

//调用
class Program

     static void Main(string[] args)
     
          Pizza pizza = PizzaFactory.CreatePizza("cheese");
          pizza.Box();
     

//输出:
//Preparing Cheese
//Cutting the Cheese
//Baking the Cheese
//Boxing the Cheese

简单工厂模式实现了生成Pizza类的代码跟客户端代码分离,在工厂类中你可以添加所需的生成Pizza的逻辑代码,但是,简单工厂并不符合“开放-封闭”原则(对扩展开放,对修改关闭),如果要加一种类型VeggiePizza,你就要修改工厂类里面的生成产品的代码,在这里你就要增加Swich-Case。对于这个问题,我们的工厂方法模式就可以解决这个问题。

工厂模式

运用工厂模式实现生产pizza的业务场景。

/// <summary>
/// 工厂接口
/// </summary>
interface IFactory

     Pizza CreatePizza();

/// <summary>
/// CheesePizza工厂方法
/// </summary>
public class CheesePizzaFactory : IFactory

     public Pizza CreatePizza()
     
          return new CheesePizza();

     

/// <summary>
/// ApplePiePizza工厂方法
/// </summary>
public class ApplePiePizzaFactory : IFactory

     public Pizza CreatePizza()
     
          return new ApplePiePizza();
     

class Program

     static void Main(string[] args)
     
          IFactory factory = new CheesePizzaFactory();
          Pizza cheesePizza = factory.CreatePizza();
          cheesePizza.Prepare();
          cheesePizza.Cut();
          cheesePizza.Bake();
          cheesePizza.Box();
          //输出:
          //Preparing Cheese
          //Cutting the Cheese
          //Baking the Cheese
          //Boxing the Cheese
     

工厂模式中我们通过对应的工厂类来生成对应的Pizza,在这里符合“开闭”原则,无论加多少Pizza类,我们都不用修改原来类中的代码,而是通过增加工厂类来实现。但是这还是有缺点的,如果产品Pizza类过多,我们就要生成很多的工厂类。假如我们要实现的产品接口不止一个,也就是有多个产品接口,不同产品接口有对应的产品族。什么是产品族呢?简单的理解就是,不同类型的Pizza会在不同的地区会有不同的准备方式,以材料(面团Dough,果酱Sauce)的不同而变幻口味等,同地区不同类型的Pizza可以组成一个产品族。对于这种情况我们可以采用抽象工厂模式。

抽象工厂模式

运用工厂模式实现生产pizza的业务场景。

/// <summary>
/// 面团
/// </summary>
public interface Dough

     void Dough();

/// <summary>
/// 纽约面团
/// </summary>
public class NYDough : Dough

     public void Dough()
     
          Console.WriteLine("NYDough");
     

/// <summary>
/// 芝加哥面团
/// </summary>
public class ChicagoDough : Dough

     public void Dough()
     
          Console.WriteLine("ChicagoDough");
     

/// <summary>
/// 果酱
/// </summary>
public interface Sauce

     void Sauce();

/// <summary>
/// 纽约果酱
/// </summary>
public class NYSauce : Sauce

     public void Sauce()
     
          Console.WriteLine("NYSauce");
     

/// <summary>
/// 芝加哥果酱
/// </summary>
public class ChicagoSauce : Sauce

     public void Sauce()
     
          Console.WriteLine("ChicagoSauce");
     

/// <summary>
/// 建造披萨原料工厂 接口
/// </summary>
public interface IPizzaIngredientFactory

     Dough CreateDough();
     Sauce CreateSauce();

/// <summary>
/// 纽约披萨工厂
/// </summary>
public class NYPizzaIngredientFactory : IPizzaIngredientFactory

     public Dough CreateDough()
                
          return new NYDough();
     
     public Sauce CreateSauce()
     
          return new NYSauce();
     

/// <summary>
/// 芝加哥披萨工厂
/// </summary>
public class ChicagoPizzaIngredientFactory : IPizzaIngredientFactory

     public Dough CreateDough()
     
          return new ChicagoDough();
     
     public Sauce CreateSauce()
     
          return new ChicagoSauce();
     

public abstract class Pizza

     public string Name  get; set; 
     /// <summary>
     /// 面团
     /// </summary>
     public Dough Dough  get; set; 
     /// <summary>
     /// 酱汁
     /// </summary>
     public Sauce Sauce  get; set; 

     public abstract void Prepare();


     public void Cut()
     
          Console.WriteLine($"Cutting the Name");
     

     public void Bake()
     
          Console.WriteLine($"Baking the Name");
     

     public void Box()
     
          Console.WriteLine($"Boxing the Name");
     

public class ApplePiePizza : Pizza

     IPizzaIngredientFactory _pizzaIngredientFactory;
     public ApplePiePizza(IPizzaIngredientFactory pizzaIngredient)
     
          this._pizzaIngredientFactory = pizzaIngredient;
          Name = "ApplePie";
     

     public override void Prepare()
     
          Console.WriteLine($"Preparing  Name");
          Dough = _pizzaIngredientFactory.CreateDough();
          Dough.Dough();
          Sauce = _pizzaIngredientFactory.CreateSauce();
          Sauce.Sauce();
     

public class CheesePizza : Pizza

     IPizzaIngredientFactory _pizzaIngredientFactory;
     public CheesePizza(IPizzaIngredientFactory pizzaIngredient)
     
          this._pizzaIngredientFactory = pizzaIngredient;
          Name = "Cheese";
     

     public override void Prepare()
     
          Console.WriteLine($"Preparing  Name");
          Dough = _pizzaIngredientFactory.CreateDough();
          Dough.Dough();
          Sauce = _pizzaIngredientFactory.CreateSauce();
          Sauce.Sauce();
     

public class SomeOtherPizza : Pizza

     public SomeOtherPizza()
     
          Name = "Other";
     

     public override void Prepare()
     
          throw new NotImplementedException();
     

// <summary>
/// 工厂接口
/// </summary>
interface IFactory

     Pizza CreatePizza(IPizzaIngredientFactory pizzaIngredientFactory);

/// <summary>
/// CheesePizza工厂方法
/// </summary>
public class CheesePizzaFactory : IFactory

     public Pizza CreatePizza(IPizzaIngredientFactory pizzaIngredientFactory)
     
          return new CheesePizza(pizzaIngredientFactory);

     


/// <summary>
/// ApplePiePizza工厂方法
/// </summary>
public class ApplePiePizzaFactory : IFactory

     public Pizza CreatePizza(IPizzaIngredientFactory pizzaIngredientFactory)
     
          return new ApplePiePizza(pizzaIngredientFactory);
     

//调用
class Program

     static void Main(string[] args)
     
          IPizzaIngredientFactory pizzaIngredientFactory = new NYPizzaIngredientFactory();
          IFactory factory = new CheesePizzaFactory();
          Pizza cheesePizza = factory.CreatePizza(pizzaIngredientFactory);
          cheesePizza.Prepare();
          cheesePizza.Cut();
          cheesePizza.Bake();
          cheesePizza.Box();
          //输出:
          //Preparing Cheese
          //NYDough
          //NYSauce
          //Cutting the Cheese
          //Baking the Cheese
          //Boxing the Cheese
     

总结

简单工厂优点

  • 实现了对象创建和使用的分离,调用者可以免除直接创建产品对象的职责,而仅仅"消费"产品。
  • 调用者无须知道所创建的具体产品类的类名,只需要知道具体产品类所对应的的参数即可。

    简单工厂缺点

  • 工厂类集中了所有产品的创建逻辑,职责过重,一旦不能正常工作,整个系统都要受影响。
  • 系统扩展困难,一旦添加新产品就不得不修改工厂逻辑,在产品类型较多时,有可能会造成工厂逻辑过于复杂,不利于系统的扩展和维护。

工厂优点

  • 工厂方法用于创建客户所需要的产品,还向客户隐藏了哪种具体产品类将被实例化这一细节。因此,用户只需要关心所需产品对应的工厂,无须关心创建细节。
  • 在系统中加入新产品时,无需修改抽象工厂和抽象产品提供的接口,也无须修改客户端,还无须修改其他的具体工厂和具体产品,而只要加入一个具体工厂和具体产品就可以了。因此,系统的可扩展性得到了保证,符合开闭原则。

    工厂缺点

  • 在添加新产品时,需要编写新的具体产品类,还要提供与之对应的具体工厂类,系统中类的个数将成对增加,一定程度上增加了系统的复杂度。
  • 由于考虑到系统的可扩展性,需要引入抽象层,且在实现时可能需要用到反射等技术,增加了系统的实现难度。

抽象工厂优点

  • 隔离了具体类的生成,使得客户并不需要知道什么被创建。因为这种隔离,因此更换一个具体工厂就变得相对容易。
  • 当一个产品族中的多个对象被设计称一起工作时,它能够保证客户端始终只使用同一个产品族中的对象。
  • 增加新的产品族很方便,无需修改已有系统,符合开闭原则。

    抽象工厂缺点

  • 增加新的产品等级结构因为需要对原有系统进行较大的修改,甚至需要修改抽象层代码,这必然会带来较大的不便,在这个角度,它违背了开闭(对扩展开放,对修改封闭)原则。

下载源码

以上是关于设计模式:三种工厂模式的主要内容,如果未能解决你的问题,请参考以下文章

设计模式:三种工厂模式

三种工厂模式(转)

高级特性 三种工厂模式

二十三种设计模式之:工厂方法模式

工厂模式的三种形式

设计模式之工厂模式