python——常用结构性设计模式

pumpkin84514

于 2024-08-20 00:01:11 发布

阅读量1k

点赞数 10

分类专栏： python相关文章标签： python 设计模式开发语言

本文链接：https://blog.csdn.net/pumpkin84514/article/details/141337656

版权

python相关专栏收录该内容

91 篇文章 0 订阅

订阅专栏

结构性设计模式（Structural Design Patterns） 主要用于组织和管理类与对象之间的关系，帮助构建灵活的、可扩展的结构。这类模式关注的是如何将不同的类或对象组合在一起，使得系统能够高效、灵活地响应变化。它们通过简化复杂系统、提高模块复用性、以及减少耦合来优化系统结构。

常见的结构性设计模式

适配器模式（Adapter Pattern）
装饰器模式（Decorator Pattern）
代理模式（Proxy Pattern）
外观模式（Facade Pattern）
组合模式（Composite Pattern）
桥接模式（Bridge Pattern）

其中，适配器模式是最常用的一种结构性模式，特别适用于在系统中整合不兼容的类或接口。

1. 适配器模式（Adapter Pattern）

原理

适配器模式的主要思想是将一个类的接口转换为客户端期望的另一种接口。通过适配器，原本由于接口不兼容而不能工作的类可以在一起工作。适配器充当类或对象之间的转换器，使得它们能够无缝协作。

适配器模式的核心思想

适配不兼容的接口：解决两个或多个不兼容接口之间的冲突。
类适配器：使用继承来匹配接口。
对象适配器：使用组合（持有一个对象）来实现接口匹配。

使用场景

集成第三方库：当你使用第三方库时，接口可能与当前代码不匹配，适配器模式可以在不修改第三方库代码的情况下进行集成。
遗留系统整合：当一个新系统需要与老系统整合，而接口不匹配时，适配器模式可以帮助解决这个问题。
不同接口的数据兼容：适配器可以将不同接口的数据结构进行转换，使其在同一系统中使用。

2. Python 中的适配器模式实现

在 Python 中，适配器模式通常通过类继承或对象组合来实现，允许你封装现有的类，并提供新的接口。

示例：使用对象适配器解决接口不兼容问题

假设我们有一个老系统 OldSystem，它的方法名与新的系统期望的方法名不兼容。为了让它与新系统协作，我们可以使用适配器模式。

问题描述

# 旧系统中的类
class OldSystem:
    def old_method(self):
        return "Old system output"

# 新系统期望的接口
class NewSystem:
    def expected_method(self):
        pass

在这个场景中，我们需要将 OldSystem 的 old_method 适配到 NewSystem 的 expected_method。

解决方案：使用适配器模式

我们创建一个适配器类，将 OldSystem 的 old_method 适配为 NewSystem 期望的 expected_method。

# 适配器类
class Adapter(NewSystem):
    def __init__(self, old_system: OldSystem):
        self.old_system = old_system

    # 实现新接口的期望方法
    def expected_method(self):
        return self.old_system.old_method()

# 使用适配器
old_system_instance = OldSystem()
adapter = Adapter(old_system_instance)

# 通过适配器调用新系统期望的方法
print(adapter.expected_method())  # 输出 "Old system output"

解释：

适配器类（Adapter）：继承 NewSystem，使得它符合新系统的接口，同时通过组合（self.old_system）保存对 OldSystem 实例的引用。
适配逻辑：expected_method() 实际上是调用了 old_method()，从而解决了接口不兼容的问题。

3. 使用场景扩展

场景 1：整合第三方库

当我们使用第三方库时，接口可能与现有的业务逻辑不兼容。适配器模式可以帮助我们将第三方库的接口与我们期望的接口进行转换，而不需要修改第三方代码。

# 第三方库中的类
class ExternalAPI:
    def external_method(self):
        return "Data from external API"

# 我们期望的接口
class TargetInterface:
    def target_method(self):
        pass

# 适配器类
class ExternalAPIAdapter(TargetInterface):
    def __init__(self, external_api: ExternalAPI):
        self.external_api = external_api

    def target_method(self):
        return self.external_api.external_method()

# 使用适配器
external_api_instance = ExternalAPI()
adapter = ExternalAPIAdapter(external_api_instance)

# 调用我们期望的方法
print(adapter.target_method())  # 输出 "Data from external API"

场景 2：整合遗留系统

当我们面对遗留系统时，新系统可能会与遗留系统中的类和方法不兼容。通过适配器模式，我们可以将新系统中的调用转换为遗留系统中的调用，而不需要修改旧代码。

场景 3：跨平台或多版本兼容

在跨平台开发或多版本兼容场景中，不同平台或版本的接口可能不同。适配器模式可以帮助统一接口，使得系统在不同平台或版本之间保持一致性。

4. 使用 `@property` 和 `@setter` 进行接口适配

有时适配模式也可以结合 @property 和 @setter 进行更加灵活的属性访问。假设我们有一个类，其中数据的存取方式不同，而我们希望通过统一的接口访问不同数据源。

示例：使用 `@property` 实现接口适配

class LegacySystem:
    def get_value(self):
        return 42

    def set_value(self, value):
        print(f"Setting value to {value}")

# 适配器类
class PropertyAdapter:
    def __init__(self, legacy_system: LegacySystem):
        self.legacy_system = legacy_system

    # 使用 property 将旧接口转换为新的访问方式
    @property
    def value(self):
        return self.legacy_system.get_value()

    @value.setter
    def value(self, value):
        self.legacy_system.set_value(value)

# 使用适配器
legacy_system = LegacySystem()
adapter = PropertyAdapter(legacy_system)

# 通过属性访问和设置值
print(adapter.value)  # 输出 42
adapter.value = 100  # 输出 "Setting value to 100"

解释：

@property 和 @setter：通过 @property，我们将 get_value() 和 set_value() 方法包装为属性访问方式，使得代码更加直观，且符合现代设计习惯。
适配场景：适用于需要统一接口访问的场景，特别是当接口涉及数据存取时，@property 可以提供更加简洁的 API。