设计模式之创建模式篇

设计模式是一种在软件设计中经常使用的、经过验证的解决方案，可以帮助开发者解决在设计和实现软件时常见的问题。在众多设计模式中，创建模式（Creational Patterns）是一类特别关注对象创建的模式。这些模式可以简化对象的创建过程，提高代码的灵活性和可维护性。本文将介绍几种常见的创建模式：单例模式（Singleton）、工厂模式（Factory）、抽象工厂模式（Abstract Factory）、建造者模式（Builder）和原型模式（Prototype）。

+-------------------+-------------------+-------------------+-------------------+-------------------+
|      模式         |      单例模式     |     工厂模式      |   抽象工厂模式     |     建造者模式     |     原型模式      |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+
|      目的         | 确保一个类只有   | 提供创建对象的     | 提供创建一系列相   | 将复杂对象的构建   | 通过复制现有对象   |
|                   | 一个实例          | 接口              | 关或依赖对象的接   | 与表示分离         | 来创建新对象       |
|                   |                   |                   | 口                |                   |                   |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+
|      使用场景     | 全局配置、日志记   | 创建对象的逻辑    | 创建多个产品族的   | 构建复杂的对象，   | 创建成本较高的对   |
|                   | 录、数据库连接    | 分散在多个子类中   | 对象需要统一处理   | 且需要不同的表示   | 象，避免重复的初   |
|                   |                   |                   |                   |                   | 始化过程           |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+
|      优点         | 确保单个实例，    | 封装对象创建过   | 提高系统结构的可   | 灵活地构建复杂对   | 避免重复的初始化   |
|                   | 简化全局访问点     | 程，减少依赖       | 拓性和可维护性     | 象，提高代码的可   | 过程，提高性能       |
|                   |                   |                   |                   | 维护性和灵活性     |                   |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+
|      缺点         | 单例模式可能导   | 工厂模式需要为   | 抽象工厂模式复杂   | 建造者模式可能导   | 原型模式需要实现   |
|                   | 致全局状态的    | 每个产品类型创   | 度较高，实施困难   | 致更多的类的创   | `clone` 方法，且   |
|                   | 管理问题          | 建具体的工厂类       |                   | 建                | 依赖于具体实现       |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+

1. 单例模式（Singleton）

单例模式确保一个类只有一个实例，并提供一个全局访问点。这种模式在全局配置、日志记录、数据库连接等场景中非常有用。

代码示例

class Singleton:
    _instance = None

    @staticmethod
    def get_instance():
        if Singleton._instance is None:
            Singleton._instance = Singleton()
        return Singleton._instance

    def __init__(self):
        if Singleton._instance is not None:
            raise Exception("This is a singleton class. Use get_instance() to get the single instance.")
        self.value = None

# 使用单例模式
s1 = Singleton.get_instance()
s1.value = "Singleton Value"

s2 = Singleton.get_instance()
print(s2.value)  # 输出: Singleton Value

2. 工厂模式（Factory）

工厂模式提供了一种创建对象的接口，但由子类决定实例化哪个类。工厂模式将对象的创建和使用分离，提高了代码的灵活性。

代码示例

from abc import ABC, abstractmethod

# 抽象产品类
class Product(ABC):
    @abstractmethod
    def operation(self):
        pass

# 具体产品类
class ConcreteProductA(Product):
    def operation(self):
        return "ConcreteProductA"

class ConcreteProductB(Product):
    def operation(self):
        return "ConcreteProductB"

# 工厂类
class Factory:
    def create_product(self, type):
        if type == "A":
            return ConcreteProductA()
        elif type == "B":
            return ConcreteProductB()
        else:
            raise ValueError("Invalid product type")

# 使用工厂模式
factory = Factory()
product_a = factory.create_product("A")
print(product_a.operation())  # 输出: ConcreteProductA

product_b = factory.create_product("B")
print(product_b.operation())  # 输出: ConcreteProductB

3. 抽象工厂模式（Abstract Factory）

抽象工厂模式提供了一种创建一系列相关或依赖对象的接口，而无需指定它们具体的类。这种模式适用于多个产品族（Product Families）的场合。

代码示例

from abc import ABC, abstractmethod

# 抽象产品类
class AbstractProductA(ABC):
    @abstractmethod
    def operation_a(self):
        pass

class AbstractProductB(ABC):
    @abstractmethod
    def operation_b(self):
        pass

# 具体产品类
class ConcreteProductA1(AbstractProductA):
    def operation_a(self):
        return "ConcreteProductA1"

class ConcreteProductA2(AbstractProductA):
    def operation_a(self):
        return "ConcreteProductA2"

class ConcreteProductB1(AbstractProductB):
    def operation_b(self):
        return "ConcreteProductB1"

class ConcreteProductB2(AbstractProductB):
    def operation_b(self):
        return "ConcreteProductB2"

# 抽象工厂类
class AbstractFactory(ABC):
    @abstractmethod
    def create_product_a(self):
        pass

    @abstractmethod
    def create_product_b(self):
        pass

# 具体工厂类
class ConcreteFactory1(AbstractFactory):
    def create_product_a(self):
        return ConcreteProductA1()

    def create_product_b(self):
        return ConcreteProductB1()

class ConcreteFactory2(AbstractFactory):
    def create_product_a(self):
        return ConcreteProductA2()

    def create_product_b(self):
        return ConcreteProductB2()

# 使用抽象工厂模式
factory1 = ConcreteFactory1()
product_a1 = factory1.create_product_a()
product_b1 = factory1.create_product_b()
print(product_a1.operation_a())  # 输出: ConcreteProductA1
print(product_b1.operation_b())  # 输出: ConcreteProductB1

factory2 = ConcreteFactory2()
product_a2 = factory2.create_product_a()
product_b2 = factory2.create_product_b()
print(product_a2.operation_a())  # 输出: ConcreteProductA2
print(product_b2.operation_b())  # 输出: ConcreteProductB2

4. 建造者模式（Builder）

建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。这种模式适用于构建复杂对象的场合。

代码示例

from abc import ABC, abstractmethod

# 复杂产品类
class Product:
    def __init__(self):
        self.parts = []

    def add(self, part):
        self.parts.append(part)

    def show(self):
        print("Product Parts:")
        for part in self.parts:
            print(part)

# 抽象建造者类
class Builder(ABC):
    @abstractmethod
    def build_part_a(self):
        pass

    @abstractmethod
    def build_part_b(self):
        pass

    @abstractmethod
    def get_result(self):
        pass

# 具体建造者类
class ConcreteBuilder1(Builder):
    def __init__(self):
        self.product = Product()

    def build_part_a(self):
        self.product.add("Part A1")

    def build_part_b(self):
        self.product.add("Part B1")

    def get_result(self):
        return self.product

class ConcreteBuilder2(Builder):
    def __init__(self):
        self.product = Product()

    def build_part_a(self):
        self.product.add("Part A2")

    def build_part_b(self):
        self.product.add("Part B2")

    def get_result(self):
        return self.product

# 导演类
class Director:
    def build(self, builder):
        builder.build_part_a()
        builder.build_part_b()

# 使用建造者模式
director = Director()
builder1 = ConcreteBuilder1()
builder2 = ConcreteBuilder2()

director.build(builder1)
product1 = builder1.get_result()
product1.show()
# 输出:
# Product Parts:
# Part A1
# Part B1

director.build(builder2)
product2 = builder2.get_result()
product2.show()
# 输出:
# Product Parts:
# Part A2
# Part B2

5. 原型模式（Prototype）

原型模式通过复制一个现有对象来创建新对象，而不是通过调用构造函数。这种模式适用于创建成本较高的对象，并且希望避免重复的初始化过程。

代码示例

import copy

# 原型类
class Prototype:
    def clone(self):
        pass

# 具体原型类
class ConcretePrototype1(Prototype):
    def __init__(self, name):
        self.name = name

    def clone(self):
        return copy.deepcopy(self)

    def __str__(self):
        return f"ConcretePrototype1: {self.name}"

class ConcretePrototype2(Prototype):
    def __init__(self, name):
        self.name = name

    def clone(self):
        return copy.deepcopy(self)

    def __str__(self):
        return f"ConcretePrototype2: {self.name}"

# 使用原型模式
prototype1 = ConcretePrototype1("Prototype1")
new_prototype1 = prototype1.clone()
print(new_prototype1)  # 输出: ConcretePrototype1: Prototype1

prototype2 = ConcretePrototype2("Prototype2")
new_prototype2 = prototype2.clone()
print(new_prototype2)  # 输出: ConcretePrototype2: Prototype2