Python 设计模式：享元模式

1. 什么是享元模式？

享元模式是一种结构型设计模式，旨在通过共享对象来减少内存使用和提高性能。它特别适用于需要大量相似对象的场景，通过共享相同的对象来避免重复创建，从而节省内存和提高效率。

享元模式的核心思想是将对象的状态分为两部分：

1. 内部状态（Intrinsic State）：对象的共享部分，通常是不可变的，多个对象可以共享这些状态。
2. 外部状态（Extrinsic State）：对象的非共享部分，通常是可变的，依赖于具体的上下文或环境。

享元模式通常包含以下几个组成部分：

• 享元接口（Flyweight Interface）：定义享元对象的接口，通常包含一个方法来接受外部状态。
• 具体享元（Concrete Flyweight）：实现享元接口，存储内部状态，并可以接受外部状态。
• 享元工厂（Flyweight Factory）：负责创建和管理享元对象，确保共享相同的享元实例。

class Shape:
    def draw(self, color):
        pass


class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius  # 内部状态（共享部分）

    def draw(self, color):
        print(f"Drawing a {color} circle with radius {self.radius}")


class ShapeFactory:
    def __init__(self):
        self.shapes = {}  # 存储共享的圆形对象

    def get_circle(self, radius):
        if radius not in self.shapes:
            self.shapes[radius] = Circle(radius)  # 创建新的圆形对象
        return self.shapes[radius]  # 返回共享的圆形对象


if __name__ == "__main__":
    factory = ShapeFactory()

    # 创建并共享相同半径的圆
    circle1 = factory.get_circle(5)
    circle1.draw("red")  # 外部状态（颜色）

    circle2 = factory.get_circle(5)
    circle2.draw("blue")  # 外部状态（颜色）

    circle3 = factory.get_circle(10)
    circle3.draw("green")  # 外部状态（颜色）

    # 验证 circle1 和 circle2 是同一个对象
    print(f"circle1 is circle2: {circle1 is circle2}")  # 输出: True

• 内部状态（Intrinsic State）：在这个示例中，Circle 类的 radius 属性是内部状态，它是共享的，多个 Circle 对象可以共享相同的半径。
• 外部状态（Extrinsic State）：在 draw 方法中，颜色参数是外部状态，它是可变的，依赖于具体的上下文或环境。

1. 享元接口：Shape 类定义了享元对象的接口，包含一个 draw 方法。

2. 具体享元类：

   • Circle 类实现了 Shape 接口，存储内部状态（半径）并实现 draw 方法。
   • radius 是内部状态（Intrinsic State），它是共享的，多个 Circle 对象可以共享相同的半径。

3. 享元工厂：

   • ShapeFactory 类负责创建和管理享元对象。它使用一个字典来存储已经创建的圆形对象，确保相同半径的圆形对象被共享。
   • 当请求一个圆形时，如果该半径的圆形已经存在，则返回共享的对象；否则，创建一个新的对象并存储。

4. 客户端代码：

   • 在客户端代码中，创建 ShapeFactory 实例并请求圆形对象。
   • circle1 和 circle2 共享相同的半径（5），但可以使用不同的颜色（外部状态）进行绘制。
   • 通过 circle1 is circle2 的比较，可以验证这两个对象实际上是同一个对象。

享元模式在软件设计中具有多种优点：

• 节省内存：通过共享对象，减少了内存的使用。对于大量相似对象的场景，享元模式可以显著降低内存占用。

ShapeFactory 类负责管理 Circle 对象的创建。每当请求一个圆形时，如果该半径的圆形已经存在，则返回共享的对象；否则，创建一个新的对象并存储。通过这种方式，如果多个圆形对象具有相同的半径，它们将共享同一个 Circle 实例，而不是为每个对象创建一个新的实例。这显著减少了内存的使用。

class ShapeFactory:
    def __init__(self):
        self.shapes = {}  # 存储共享的圆形对象

    def get_circle(self, radius):
        if radius not in self.shapes:
            self.shapes[radius] = Circle(radius)  # 创建新的圆形对象
        return self.shapes[radius]  # 返回共享的圆形对象

• 提高性能：减少了对象的创建和销毁，提高了性能。共享对象的使用可以减少系统的负担，提升响应速度。

创建和管理 Circle 对象的逻辑被集中在 ShapeFactory 中。由于相同半径的圆形对象只会被创建一次，后续的请求将直接返回已存在的对象。这里，circle1 和 circle2 实际上是同一个对象。通过避免重复创建相同的对象，享元模式减少了系统的负担，从而提高了性能。

circle1 = factory.get_circle(5)
circle2 = factory.get_circle(5)

• 灵活性：可以根据需要动态地添加新的享元对象，而不影响现有对象的状态。

在 ShapeFactory 中，新的 Circle 对象可以根据需要被创建并存储。每当请求一个新的半径时，工厂会检查是否已经存在相应的对象。这种设计允许系统在运行时灵活地添加新的享元对象，而不需要修改现有的对象或逻辑。这种灵活性使得系统能够适应变化的需求。

def get_circle(self, radius):
    if radius not in self.shapes:
        self.shapes[radius] = Circle(radius)  # 创建新的圆形对象
    return self.shapes[radius]  # 返回共享的圆形对象

2. 示例1：音频播放器中的享元模式

# 享元接口
class Audio:
    def play(self):
        pass


# 具体享元类
class MP3(Audio):
    def __init__(self, file_path):
        self.file_path = file_path  # 内部状态（共享部分）

    def play(self):
        print(f"Playing audio from: {self.file_path}")


# 享元工厂
class AudioFactory:
    def __init__(self):
        self.audios = {}  # 存储共享的音频对象

    def get_audio(self, file_path):
        if file_path not in self.audios:
            self.audios[file_path] = MP3(file_path)  # 创建新的音频对象
        return self.audios[file_path]  # 返回共享的音频对象


# 客户端代码
if __name__ == "__main__":
    factory = AudioFactory()

    # 创建并共享相同文件路径的音频对象
    audio1 = factory.get_audio("song1.mp3")
    audio1.play()  # 播放音频

    audio2 = factory.get_audio("song1.mp3")
    audio2.play()  # 播放相同的音频

    audio3 = factory.get_audio("song2.mp3")
    audio3.play()  # 播放不同的音频

    # 验证 audio1 和 audio2 是同一个对象
    print(f"audio1 is audio2: {audio1 is audio2}")  # 输出: True

Playing audio from: song1.mp3
Playing audio from: song1.mp3
Playing audio from: song2.mp3
audio1 is audio2: True

1. 享元接口：Audio 类定义了音频对象的接口，包含一个 play 方法。

2. 具体享元类：

   • MP3 类实现了 Audio 接口，存储内部状态（文件路径）并实现 play 方法。
   • file_path 是内部状态（Intrinsic State），它是共享的，多个 MP3 对象可以共享相同的文件路径。

3. 享元工厂：

   • AudioFactory 类负责创建和管理享元对象。它使用一个字典来存储已经创建的音频对象，确保相同文件路径的音频对象被共享。
   • 当请求一个音频时，如果该文件路径的音频已经存在，则返回共享的对象；否则，创建一个新的对象并存储。

4. 客户端代码：

   • 在客户端代码中，创建 AudioFactory 实例并请求音频对象。
   • audio1 和 audio2 共享相同的文件路径（song1.mp3），但可以独立播放。
   • 通过 audio1 is audio2 的比较，可以验证这两个对象实际上是同一个对象。