深入解析Swift中的结构型设计模式-优快云博客

本文链接：https://blog.youkuaiyun.com/gitblog_00119/article/details/148377486

深入解析Swift中的结构型设计模式

Design-Patterns-In-Swift 📖 Design Patterns implemented in Swift 5.0 项目地址: https://gitcode.com/gh_mirrors/de/Design-Patterns-In-Swift

前言

设计模式是软件开发中解决常见问题的可重用方案。结构型模式特别关注类和对象的组合方式，帮助我们构建灵活且可维护的系统。本文将详细介绍Swift语言中实现的各种结构型设计模式，通过实际代码示例帮助开发者理解其应用场景和实现方式。

适配器模式（Adapter）

适配器模式就像现实世界中的电源转换器，它让不兼容的接口能够协同工作。在Swift中，我们通常通过创建适配器类或结构体来实现这一模式。

核心思想：

将不兼容的接口转换为客户端期望的接口
通过包装现有类提供新的接口
避免修改现有代码的情况下实现集成

示例分析：

struct NewDeathStarSuperlaserTarget: NewDeathStarSuperLaserAiming {
    private let target: OldDeathStarSuperlaserTarget
    
    var angleV: Double { return Double(target.angleVertical) }
    var angleH: Double { return Double(target.angleHorizontal) }
    
    init(_ target: OldDeathStarSuperlaserTarget) {
        self.target = target
    }
}

这个适配器将旧的OldDeathStarSuperlaserTarget转换为符合NewDeathStarSuperLaserAiming协议的新接口，同时保持了原有功能。

桥接模式（Bridge）

桥接模式分离抽象和实现，使它们可以独立变化，特别适用于需要在多个维度上扩展的系统。

关键特点：

解耦抽象和实现
独立扩展性
运行时绑定实现

示例解析：

protocol Switch {
    var appliance: Appliance { get set }
    func turnOn()
}

protocol Appliance {
    func run()
}

这里Switch是抽象部分，Appliance是实现部分。我们可以轻松添加新的电器类型或新的开关类型而不影响另一方。

组合模式（Composite）

组合模式让我们能用树形结构处理对象的部分-整体层次关系，统一对待单个对象和组合对象。

实现要点：

定义组件接口
实现叶子节点
实现组合容器

代码示例：

final class Whiteboard: Shape {
    private lazy var shapes = [Shape]()
    
    func draw(fillColor: String) {
        for shape in self.shapes {
            shape.draw(fillColor: fillColor)
        }
    }
}

Whiteboard作为组合对象，可以包含其他Shape对象（包括其他Whiteboard），形成递归结构。

装饰器模式（Decorator）

装饰器模式动态地给对象添加职责，比继承更灵活。

优势：

运行时添加功能
避免子类膨胀
保持单一职责原则

咖啡装饰示例：

struct Milk: BeverageHaving {
    let beverage: BeverageDataHaving
    
    var cost: Double { return beverage.cost + 0.5 }
    var ingredients: [String] { return beverage.ingredients + ["Milk"] }
}

每个装饰器都包装一个基础对象，在调用前后添加自己的行为，形成装饰链。

外观模式（Facade）

外观模式为复杂子系统提供简化接口，降低使用复杂度。

典型应用：

简化复杂API
减少客户端与子系统的耦合
提供统一入口点

UserDefaults封装：

final class Defaults {
    private let defaults: UserDefaults
    
    subscript(key: String) -> String? {
        get { return defaults.string(forKey: key) }
        set { defaults.set(newValue, forKey: key) }
    }
}

这个外观类隐藏了UserDefaults的复杂性，提供了更简洁的键值存取接口。

享元模式（Flyweight）

享元模式通过共享减少内存使用，适合大量相似对象场景。

实现关键：

分离内在状态和外在状态
使用工厂管理共享对象
客户端维护外在状态

咖啡店示例：

final class Menu: CoffeeSearching {
    private var coffeeAvailable: [String: SpecialityCoffee] = [:]
    
    func search(origin: String) -> SpecialityCoffee? {
        if coffeeAvailable.index(forKey: origin) == nil {
            coffeeAvailable[origin] = SpecialityCoffee(origin: origin)
        }
        return coffeeAvailable[origin]
    }
}

Menu作为享元工厂，确保每种咖啡只创建一个实例，多个订单共享相同的咖啡对象。

代理模式（Proxy）

代理模式为其他对象提供代理以控制对这个对象的访问，有多种变体：

保护代理

控制对敏感资源的访问，如示例中的CurrentComputer代理HAL9000的开门功能。

虚拟代理

延迟昂贵对象的创建，如HEVSuitHumanInterface仅在需要时才创建实际的HEVSuit。

保护代理示例：

final class CurrentComputer: DoorOpening {
    private var computer: HAL9000!
    
    func authenticate(password: String) -> Bool {
        guard password == "pass" else { return false }
        computer = HAL9000()
        return true
    }
    
    func open(doors: String) -> String {
        guard computer != nil else { return "Access Denied" }
        return computer.open(doors: doors)
    }
}