设计模式 1 工厂方法模式

设计模式 1

• 创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式
• 结构型模式（7）：适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式
• 行为型模式（11）：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式

简单工厂模式（Simple Factory Pattern）

1 定义

简单工厂模式，也称为静态工厂方法模式，并不属于GoF（Gang of Four）设计模式之一。它提供了一个创建对象的简单接口，通过传递不同的参数来决定创建哪种类的实例。

2 结构

简单工厂模式包含以下角色：

• 工厂类（Factory）: 提供一个静态方法，根据传入的参数来创建不同类型的对象。
• 产品（Product）: 定义创建对象的接口或抽象类。
• 具体产品（ConcreteProduct）: 实现产品接口的具体类。

UML 类图

+-------------------+
|      Factory      |
+-------------------+
| + CreateProduct() |
+-------------------+
          |
          v
+-------------------+
|    Product        |
+-------------------+
         / \
        /   \
+--------+ +---------+
|ProductA| |ProductB |
+--------+ +---------+

3 示例代码

// 产品接口
public interface IProduct
{
    void Display();
}

// 具体产品A
public class ProductA : IProduct
{
    public void Display()
    {
        Console.WriteLine("Product A");
    }
}

// 具体产品B
public class ProductB : IProduct
{
    public void Display()
    {
        Console.WriteLine("Product B");
    }
}

// 简单工厂
public class SimpleFactory
{
    public static IProduct CreateProduct(string type)
    {
        if (type == "A")
        {
            return new ProductA();
        }
        else if (type == "B")
        {
            return new ProductB();
        }
        else
        {
            throw new ArgumentException("Invalid type");
        }
    }
}

// 客户端代码
class Program
{
    static void Main(string[] args)
    {
        IProduct product = SimpleFactory.CreateProduct("A");
        product.Display();
    }
}

4 特点

• 优点:
  • 简单易懂，适合创建少量对象的情况。
  • 统一了对象的创建过程，便于管理和修改。
• 缺点:
  • 不符合开放-关闭原则：每增加一种新类型的产品，都需要修改工厂类。
  • 工厂类过于集中，扩展性较差，随着产品种类的增加，工厂类会变得臃肿。
  • 只适用于创建单一产品族的情况。

5 适用场景

• 当一个系统中需要创建的对象较少，并且不需要对创建逻辑进行高度的扩展或修改时。
• 当客户端只需指定创建对象的类型，而不关心具体的创建过程时。

工厂方法模式（Factory Method Pattern）

1 定义

工厂方法模式定义了一个用于创建对象的接口，但由子类决定实例化哪一个类。通过这种方式，工厂方法将对象的创建推迟到子类。

2 结构

工厂方法模式包含以下角色：

• 抽象产品（Product）: 定义工厂方法所创建对象的接口或抽象类。
• 具体产品（ConcreteProduct）: 实现 Product 接口或继承 Product 抽象类的具体类。
• 抽象创建者（Creator）: 声明工厂方法，该方法返回一个 Product 类型的对象。也可以包含一些默认实现。
• 具体创建者（ConcreteCreator）: 实现工厂方法，返回具体产品的实例。

UML 类图

      +---------------------+
      |     Creator         |
      +---------------------+
      | + FactoryMethod()   |
      +---------------------+
               |
               |
               v
      +---------------------+
      | ConcreteCreator      |
      +---------------------+
      | + FactoryMethod()    |
      +---------------------+
               |
               |
               v
      +---------------------+
      | ConcreteProduct      |
      +---------------------+
      | Implements Product   |
      +---------------------+

3 示例代码

假设我们要创建不同类型的日志记录器（如控制台日志记录器和文件日志记录器），可以使用工厂方法模式。

// 产品接口
public interface ILogger
{
    void Log(string message);
}

// 具体产品1：控制台日志记录器
public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine("Console Logger: " + message);
    }
}

// 具体产品2：文件日志记录器
public class FileLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine("File Logger: " + message);
    }
}

// 抽象创建者
public abstract class LoggerFactory
{
    public abstract ILogger CreateLogger();

    public void WriteLog(string message)
    {
        var logger = CreateLogger();
        logger.Log(message);
    }
}

// 具体创建者1
public class ConsoleLoggerFactory : LoggerFactory
{
    public override ILogger CreateLogger()
    {
        return new ConsoleLogger();
    }
}

// 具体创建者2
public class FileLoggerFactory : LoggerFactory
{
    public override ILogger CreateLogger()
    {
        return new FileLogger();
    }
}

// 客户端代码
class Program
{
    static void Main(string[] args)
    {
        LoggerFactory loggerFactory = new ConsoleLoggerFactory();
        loggerFactory.WriteLog("This is a console log.");

        loggerFactory = new FileLoggerFactory();
        loggerFactory.WriteLog("This is a file log.");
    }
}

4 特点

• 优点:
  • 遵循单一职责原则：将对象的创建和使用分离。
  • 遵循开放-关闭原则：通过子类来扩展新的产品类型，而无需修改现有代码。
• 缺点:
  • 随着产品种类的增加，会引入多个具体创建者，导致代码量增加。
  • 每新增一种产品，需要新增一个具体的创建者类，增加了系统的复杂性。

5 适用场景

• 当系统需要将创建对象的过程与其使用过程分开时。
• 当一个类不应决定它所创建的对象的具体类型时，可以使用工厂方法模式。