创建型设计模式之工厂方法模式:灵活创建对象的艺术-CSDN博客

本文链接：https://blog.csdn.net/O_____V_____O/article/details/148041499

文章目录

引言

在软件开发中，创建对象是一项基本但关键的活动。随着项目的发展，创建对象的逻辑可能变得越来越复杂，这时我们需要更灵活、可扩展的方式来处理对象创建。工厂方法模式就是一种常用的解决方案，它属于创建型设计模式的一种，能够将对象的创建与使用分离，提高代码的灵活性和可维护性。

本文将深入探讨工厂方法模式的定义、实现方式、应用场景以及优缺点，并通过C#代码示例来演示其实际应用。

工厂方法模式定义

工厂方法模式（Factory Method Pattern）的定义是：定义一个创建对象的接口，但让实现这个接口的子类来决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。

工厂方法模式解决的核心问题是：

将对象的创建与使用分离
允许系统能够独立于它所创建的对象的方式
支持系统对创建对象过程的扩展

工厂方法模式的UML类图

以下是工厂方法模式的UML类图：

工厂方法模式的组成部分

工厂方法模式由以下几个核心组件组成：

产品接口（Product）：
- 定义工厂方法创建的对象的接口
- 所有具体产品都必须实现这个接口
具体产品（Concrete Product）：
- 实现产品接口的具体类
- 由对应的具体工厂创建
创建者/工厂接口（Creator）：
- 声明工厂方法，返回产品接口类型的对象
- 可能包含一些默认实现或调用工厂方法的业务逻辑
具体创建者/具体工厂（Concrete Creator）：
- 实现工厂接口，重写工厂方法创建并返回具体产品
- 每个具体工厂负责创建对应的具体产品

工厂方法模式的实现方式

以下通过C#代码示例展示工厂方法模式的几种常见实现方式。

基本实现

首先，让我们看看工厂方法模式的基本实现方式：

/// <summary>
/// 产品接口 - 定义产品的共同特性和行为
/// </summary>
public interface IVehicle
{
    void Drive();
}

/// <summary>
/// 具体产品类 - 汽车
/// </summary>
public class Car : IVehicle
{
    public void Drive()
    {
        Console.WriteLine("驾驶汽车：以四个轮子在公路上行驶");
    }
}

/// <summary>
/// 具体产品类 - 摩托车
/// </summary>
public class Motorcycle : IVehicle
{
    public void Drive()
    {
        Console.WriteLine("驾驶摩托车：以两个轮子在公路上行驶");
    }
}

/// <summary>
/// 创建者/工厂接口 - 定义创建产品的方法
/// </summary>
public abstract class VehicleFactory
{
    // 工厂方法 - 创建并返回一个车辆对象
    public abstract IVehicle CreateVehicle();
    
    // 工厂接口中的业务逻辑，使用工厂方法创建的产品
    public void DeliverVehicle()
    {
        // 通过工厂方法创建产品
        IVehicle vehicle = CreateVehicle();
        
        // 使用产品
        Console.WriteLine("准备交付一辆新车...");
        vehicle.Drive();
        Console.WriteLine("车辆交付完成！");
    }
}

/// <summary>
/// 具体创建者/工厂类 - 汽车工厂
/// </summary>
public class CarFactory : VehicleFactory
{
    public override IVehicle CreateVehicle()
    {
        // 创建并返回汽车对象
        return new Car();
    }
}

/// <summary>
/// 具体创建者/工厂类 - 摩托车工厂
/// </summary>
public class MotorcycleFactory : VehicleFactory
{
    public override IVehicle CreateVehicle()
    {
        // 创建并返回摩托车对象
        return new Motorcycle();
    }
}

/// <summary>
/// 客户端代码
/// </summary>
public class Client
{
    public void Main()
    {
        Console.WriteLine("使用汽车工厂：");
        VehicleFactory carFactory = new CarFactory();
        carFactory.DeliverVehicle();
        
        Console.WriteLine("\n使用摩托车工厂：");
        VehicleFactory motorcycleFactory = new MotorcycleFactory();
        motorcycleFactory.DeliverVehicle();
    }
}

// 执行客户端代码
new Client().Main();

/* 输出结果：
使用汽车工厂：
准备交付一辆新车...
驾驶汽车：以四个轮子在公路上行驶
车辆交付完成！

使用摩托车工厂：
准备交付一辆新车...
驾驶摩托车：以两个轮子在公路上行驶
车辆交付完成！
*/

在这个基本实现中：

IVehicle 是产品接口，定义了所有车辆都应具有的功能
Car 和 Motorcycle 是具体产品，实现了产品接口
VehicleFactory 是抽象工厂类，声明了工厂方法和使用产品的业务逻辑
CarFactory 和 MotorcycleFactory 是具体工厂类，负责创建对应的具体产品

参数化工厂方法

有时，我们可能希望根据参数来决定创建哪种具体产品，这是工厂方法模式的一种变体：

/// <summary>
/// 产品接口
/// </summary>
public interface IButton
{
    void Render();
    void OnClick();
}

/// <summary>
/// 具体产品 - Windows按钮
/// </summary>
public class WindowsButton : IButton
{
    public void Render()
    {
        Console.WriteLine("渲染Windows风格的按钮");
    }
    
    public void OnClick()
    {
        Console.WriteLine("触发Windows按钮的点击事件");
    }
}

/// <summary>
/// 具体产品 - HTML按钮
/// </summary>
public class HTMLButton : IButton
{
    public void Render()
    {
        Console.WriteLine("渲染HTML风格的按钮");
    }
    
    public void OnClick()
    {
        Console.WriteLine("触发HTML按钮的点击事件");
    }
}

/// <summary>
/// 使用参数化工厂方法的工厂
/// </summary>
public class ButtonFactory
{
    /// <summary>
    /// 按钮类型枚举
    /// </summary>
    public enum ButtonType
    {
        Windows,
        HTML
    }
    
    /// <summary>
    /// 参数化工厂方法 - 根据类型参数创建对应的按钮
    /// </summary>
    public IButton CreateButton(ButtonType type)
    {
        switch (type)
        {
            case ButtonType.Windows:
                return new WindowsButton();
            case ButtonType.HTML:
                return new HTMLButton();
            default:
                throw new ArgumentException("未知的按钮类型", nameof(type));
        }
    }
}

/// <summary>
/// 客户端代码
/// </summary>
public class Dialog
{
    private readonly ButtonFactory _buttonFactory = new ButtonFactory();
    
    public void Initialize(ButtonFactory.ButtonType buttonType)
    {
        IButton button = _buttonFactory.CreateButton(buttonType);
        button.Render();
        button.OnClick();
    }
}

// 使用示例
var dialog = new Dialog();
Console.WriteLine("创建Windows按钮：");
dialog.Initialize(ButtonFactory.ButtonType.Windows);

Console.WriteLine("\n创建HTML按钮：");
dialog.Initialize(ButtonFactory.ButtonType.HTML);

/* 输出结果：
创建Windows按钮：
渲染Windows风格的按钮
触发Windows按钮的点击事件

创建HTML按钮：
渲染HTML风格的按钮
触发HTML按钮的点击事件
*/

在这个参数化工厂方法实现中：

工厂方法接受一个参数（按钮类型），根据这个参数创建不同的具体产品
这种方式简化了客户端代码，客户端只需与一个工厂类交互
添加新产品时需要修改工厂类代码，一定程度上违反了开闭原则

泛型工厂方法

在C#中，我们可以利用泛型和反射来实现更灵活的工厂方法：

/// <summary>
/// 产品基类或接口
/// </summary>
public interface IProduct
{
    void Operation();
}

/// <summary>
/// 具体产品类A
/// </summary>
public class ConcreteProductA : IProduct
{
    public void Operation()
    {
        Console.WriteLine("执行具体产品A的操作");
    }
}

/// <summary>
/// 具体产品类B
/// </summary>
public class ConcreteProductB : IProduct
{
    public void Operation()
    {
        Console.WriteLine("执行具体产品B的操作");
    }
}

/// <summary>
/// 泛型工厂 - 通过泛型参数确定要创建的产品类型
/// </summary>
public class GenericFactory
{
    /// <summary>
    /// 泛型工厂方法 - 创建指定类型的产品实例
    /// </summary>
    /// <typeparam name="T">要创建的产品类型，必须实现IProduct接口</typeparam>
    /// <returns>创建的产品实例</returns>
    public T CreateProduct<T>() where T : IProduct, new()
    {
        // 使用new约束创建T类型的实例
        return new T();
    }
}

// 使用示例
var factory = new GenericFactory();

// 创建具体产品A
IProduct productA = factory.CreateProduct<ConcreteProductA>();
productA.Operation();

// 创建具体产品B
IProduct productB = factory.CreateProduct<ConcreteProductB>();
productB.Operation();

/* 输出结果：
执行具体产品A的操作
执行具体产品B的操作
*/

在这个泛型工厂方法实现中：

使用泛型参数来指定要创建的产品类型
利用C#的new()约束确保泛型类型可以被实例化
这种方式非常灵活，添加新产品不需要修改工厂代码
但客户端代码需要知道具体产品类型，增加了客户端的耦合度

依赖注入与工厂方法的结合

在现代C#开发中，工厂方法经常与依赖注入框架结合使用：

using Microsoft.Extensions.DependencyInjection;
using System;

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

/// <summary>
/// 具体产品 - 控制台日志记录器
/// </summary>
public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($"[控制台日志] {DateTime.Now}: {message}");
    }
}

/// <summary>
/// 具体产品 - 文件日志记录器
/// </summary>
public class FileLogger : ILogger
{
    private readonly string _filePath;
    
    public FileLogger(string filePath)
    {
        _filePath = filePath;
    }
    
    public void Log(string message)
    {
        // 在实际应用中，这里应该将日志写入文件
        Console.WriteLine($"[文件日志({_filePath})] {DateTime.Now}: {message}");
    }
}

/// <summary>
/// 日志记录器工厂接口
/// </summary>
public interface ILoggerFactory
{
    ILogger CreateLogger();
}

/// <summary>
/// 具体工厂 - 控制台日志记录器工厂
/// </summary>
public class ConsoleLoggerFactory : ILoggerFactory
{
    public ILogger CreateLogger()
    {
        return new ConsoleLogger();
    }
}

/// <summary>
/// 具体工厂 - 文件日志记录器工厂
/// </summary>
public class FileLoggerFactory : ILoggerFactory
{
    private readonly string _filePath;
    
    public FileLoggerFactory(string filePath)
    {
        _filePath = filePath;
    }
    
    public ILogger CreateLogger()
    {
        return new FileLogger(_filePath);
    }
}

/// <summary>
/// 使用日志记录器的服务
/// </summary>
public class LoggingService
{
    private readonly ILoggerFactory _loggerFactory;
    
    // 通过依赖注入接收日志记录器工厂
    public LoggingService(ILoggerFactory loggerFactory)
    {
        _loggerFactory = loggerFactory;
    }
    
    public void DoWork()
    {
        // 使用工厂创建日志记录器
        ILogger logger = _loggerFactory.CreateLogger();
        logger.Log("执行某些工作...");
        // 其他业务逻辑...
    }
}

// 设置依赖注入
var services = new ServiceCollection();

// 注册为单例的文件日志记录器工厂
services.AddSingleton<ILoggerFactory>(new FileLoggerFactory("app.log"));

// 注册LoggingService
services.AddTransient<LoggingService>();

// 构建服务提供者
var serviceProvider = services.BuildServiceProvider();

// 从DI容器获取LoggingService
var loggingService = serviceProvider.GetService<LoggingService>();

// 使用服务
loggingService.DoWork();

/* 输出结果：
[文件日志(app.log)] 2023-10-15 14:30:25: 执行某些工作...
*/

在这个结合依赖注入的实现中：

工厂接口和具体工厂被注册到DI容器中
服务通过构造函数注入接收工厂实例
这种方式使系统更加灵活和可测试
可以在运行时轻松更换不同的工厂实现

工厂方法模式的应用场景

工厂方法模式适用于以下场景：

框架与库开发
- 框架需要创建多种不同类型的对象，但不能预知具体类型
- 例如：ORM框架创建不同数据库连接、UI框架创建不同风格的控件
复杂对象创建
- 对象创建过程涉及复杂的业务规则或配置
- 例如：基于用户权限或系统配置创建不同功能的对象
系统扩展性要求高
- 系统需要能够方便地添加新的产品类型，而不修改现有代码
- 例如：插件系统、模块化应用程序
测试驱动开发
- 需要在测试中轻松替换实际对象为测试对象
- 例如：替换真实的API调用为模拟对象
常见应用举例
- 数据库连接管理：根据配置创建不同类型的数据库连接
- UI组件库：根据平台或主题创建不同风格的组件
- 支付处理系统：根据支付方式创建不同的支付处理器
- 文档生成器：根据格式要求创建PDF、Word、HTML等不同格式的文档生成器
- 日志系统：创建不同目标（控制台、文件、网络）的日志记录器