设计模式一网打尽

设计模式是提升开发者架构能力和项目可维护性的重要“内功”。尤其对于移动端开发，无论是Swift（iOS）还是Kotlin（Android），掌握并活用设计模式，能让你的App开发效率、代码质量、团队协作能力都大幅提升。本文以详细原理、实战代码和移动端场景，为你全面梳理23种GoF经典设计模式。每种模式都配合Swift和Kotlin代码实例，帮助你真正“会用”。

一、创建型模式（5种）

1. 单例模式（Singleton）

核心思想：
保证某个类只有一个实例，且能被全局访问。通常用于全局配置、缓存、管理器等场景。

Swift示例

class NetworkManager {
    static let shared = NetworkManager()
    private init() {}
    
    func fetch(url: String, completion: (Data?) -> Void) {
        // 网络请求逻辑
    }
}

Kotlin示例

object NetworkManager {
    fun fetch(url: String, callback: (String?) -> Unit) {
        // 网络请求逻辑
    }
}

应用场景扩展：
如App配置中心、图片缓存池、数据库连接池等，只需单例就能保证全局唯一、资源复用，避免多次初始化带来的问题。

2. 工厂方法模式（Factory Method）

核心思想：
定义一个创建对象的接口，但让子类决定实例化哪一个类，工厂方法将对象的实例化推迟到子类。

Swift示例

protocol Button {
    func render()
}
class iOSButton: Button {
    func render() { print("Render iOS Button") }
}
class AndroidButton: Button {
    func render() { print("Render Android Button") }
}
protocol ButtonFactory {
    func createButton() -> Button
}
class iOSButtonFactory: ButtonFactory {
    func createButton() -> Button { iOSButton() }
}
class AndroidButtonFactory: ButtonFactory {
    func createButton() -> Button { AndroidButton() }
}

Kotlin示例

interface Button { fun render() }
class AndroidButton : Button { override fun render() { println("Render Android Button") } }
class IOSButton : Button { override fun render() { println("Render iOS Button") } }

interface ButtonFactory { fun createButton(): Button }
class AndroidButtonFactory : ButtonFactory { override fun createButton() = AndroidButton() }
class IOSButtonFactory : ButtonFactory { override fun createButton() = IOSButton() }

应用场景扩展：
UI控件、主题风格适配、数据解析器工厂等场景，可以通过工厂方法灵活生产“同一族但实现不同”的对象。

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

核心思想：
提供一个接口，创建一系列相关或依赖的对象，无需指定具体类。

Swift示例

protocol UIComponentFactory {
    func createButton() -> Button
    func createTextField() -> TextField
}
class LightThemeFactory: UIComponentFactory {
    func createButton() -> Button { LightButton() }
    func createTextField() -> TextField { LightTextField() }
}
class DarkThemeFactory: UIComponentFactory {
    func createButton() -> Button { DarkButton() }
    func createTextField() -> TextField { DarkTextField() }
}

Kotlin示例

interface UIComponentFactory {
    fun createButton(): Button
    fun createTextField(): TextField
}
class LightThemeFactory : UIComponentFactory {
    override fun createButton() = LightButton()
    override fun createTextField() = LightTextField()
}
class DarkThemeFactory : UIComponentFactory {
    override fun createButton() = DarkButton()
    override fun createTextField() = DarkTextField()
}

应用场景扩展：
多主题UI组件族、跨平台开发、SDK与业务模块解耦场景，极大提升“产品族”的灵活切换与扩展能力。

4. 建造者模式（Builder）

核心思想：
将复杂对象的构建与其表示分离，同样的构建过程可以创建不同的表现。

Swift示例

class AlertBuilder {
    private var title: String?
    private var message: String?
    private var actions: [UIAlertAction] = []
    
    func setTitle(_ t: String) -> AlertBuilder { title = t; return self }
    func setMessage(_ m: String) -> AlertBuilder { message = m; return self }
    func addAction(_ a: UIAlertAction) -> AlertBuilder { actions.append(a); return self }
    
    func build() -> UIAlertController {
        let alert = UIAlertController(title: title, message: message, preferredStyle: .alert)
        actions.forEach { alert.addAction($0) }
        return alert
    }
}

Kotlin示例

class AlertDialogBuilder {
    private var title: String? = null
    private var message: String? = null
    private val actions = mutableListOf<DialogAction>()
    
    fun setTitle(t: String) = apply { title = t }
    fun setMessage(m: String) = apply { message = m }
    fun addAction(a: DialogAction) = apply { actions.add(a) }
    fun build(): AlertDialog = AlertDialog(title, message, actions)
}

应用场景扩展：
复杂UI组件（Alert、Form）、HTTP请求参数链式配置、游戏关卡对象构建等，建造者让代码更易读、灵活扩展。

5. 原型模式（Prototype）

核心思想：
通过复制现有对象来创建新对象，避免复杂初始化过程。

Swift示例

class UserProfile: NSCopying {
    var name: String
    var avatar: UIImage
    init(name: String, avatar: UIImage) { self.name = name; self.avatar = avatar }
    func copy(with zone: NSZone? = nil) -> Any {
        return UserProfile(name: self.name, avatar: self.avatar)
    }
}

Kotlin示例

data class UserProfile(val name: String, val avatar: Bitmap) : Cloneable {
    public override fun clone(): UserProfile = copy()
}

应用场景扩展：
如自定义View、表单模板、游戏地图、缓存数据对象等，需要快速复制已有配置和状态。

二、结构型模式（7种）

6. 适配器模式（Adapter）

核心思想：
将一个类的接口转换成客户端期望的另一个接口，实现兼容和复用。

Swift示例

protocol JSONParser { func parse(json: String) -> [String: Any] }
class ThirdPartyParser { func parseData(_ data: Data) -> [String: Any] { ... } }
class ThirdPartyParserAdapter: JSONParser {
    private let parser: ThirdPartyParser
    init(parser: ThirdPartyParser) { self.parser = parser }
    func parse(json: String) -> [String: Any] {
        let data = json.data(using: .utf8)!
        return parser.parseData(data)
    }
}

Kotlin示例

interface JsonParser { fun parse(json: String): Map<String, Any> }
class ThirdPartyParser { fun parseData(data: ByteArray): Map<String, Any> = TODO() }
class ThirdPartyParserAdapter(val parser: ThirdPartyParser) : JsonParser {
    override fun parse(json: String): Map<String, Any> =
        parser.parseData(json.toByteArray())
}

应用场景扩展：
适配第三方库、新旧API兼容、跨平台组件接入等。

7. 桥接模式（Bridge）

核心思想：
将抽象与实现分离，两者可以独立变化，组合灵活。

Swift示例

protocol Renderer { func render(text: String) }
class OpenGLRenderer: Renderer { func render(text: String) { print("OpenGL:\(text)") } }
class MetalRenderer: Renderer { func render(text: String) { print("Metal:\(text)") } }
class TextLabel {
    let renderer: Renderer
    init(renderer: Renderer) { self.renderer = renderer }
    func draw(text: String) { renderer.render(text: text) }
}

Kotlin示例

interface Renderer { fun render(text: String) }
class SkiaRenderer : Renderer { override fun render(text: String) = println("Skia:$text") }
class VulkanRenderer : Renderer { override fun render(text: String) = println("Vulkan:$text") }
class TextLabel(val renderer: Renderer) {
    fun draw(text: String) = renderer.render(text)
}

应用场景扩展：
UI主题与控件解耦、平台渲染引擎切换、多样输入设备支持等。

8. 装饰器模式（Decorator）

核心思想：
动态为对象添加额外功能，扩展不影响原始类结构。

Swift示例

protocol ImageLoader { func load(url: String) -> UIImage }
class DefaultLoader: ImageLoader { func load(url: String) -> UIImage { ... } }
class CacheDecorator: ImageLoader {
    private let loader: ImageLoader
    private var cache = [String: UIImage]()
    init(loader: ImageLoader) { self.loader = loader }
    func load(url: String) -> UIImage {
        if let img = cache[url] { return img }
        let img = loader.load(url: url)
        cache[url] = img
        return img
    }
}

Kotlin示例

interface ImageLoader { fun load(url: String): Bitmap }
class DefaultLoader : ImageLoader { override fun load(url: String): Bitmap = TODO() }
class CacheDecorator(val loader: ImageLoader) : ImageLoader {
    val cache = mutableMapOf<String, Bitmap>()
    override fun load(url: String): Bitmap =
        cache[url] ?: loader.load(url).also { cache[url] = it }
}

应用场景扩展：
图片加载、日志、权限、监控功能的动态增强。

9. 组合模式（Composite）

核心思想：
将对象组织成树形结构，统一对单个对象和组合对象操作。

Swift示例

protocol UIComponent { func render() }
class Button: UIComponent { func render() { print("Render Button") } }
class Panel: UIComponent {
    private var children = [UIComponent]()
    func add(_ child: UIComponent) { children.append(child) }
    func render() { children.forEach { $0.render() } }
}

Kotlin示例

interface UIComponent { fun render() }
class Button : UIComponent { override fun render() { println("Render Button") } }
class Panel : UIComponent {
    private val children = mutableListOf<UIComponent>()
    fun add(child: UIComponent) { children.add(child) }
    override fun render() = children.forEach { it.render() }
}

应用场景扩展：
表单、菜单、目录树、UI容器等。

10. 门面模式（Facade）

核心思想：
为复杂子系统提供统一入口，简化调用，解耦客户端和子系统。

Swift示例

class MediaPlayerFacade {
    let decoder = Decoder()
    let renderer = Renderer()
    func play(file: String) {
        decoder.decode(file)
        renderer.render()
    }
}

Kotlin示例

class MediaPlayerFacade(
    val decoder: Decoder = Decoder(),
    val renderer: Renderer = Renderer()
) {
    fun play(file: String) {
        decoder.decode(file)
        renderer.render()
    }
}

应用场景扩展：
一键登录、三方支付、网络模块等复杂功能对外提供简易API。

11. 享元模式（Flyweight）

核心思想：
共享大量细粒度对象，减少内存消耗。

Swift示例

class IconFactory {
    private var icons = [String: UIImage]()
    func getIcon(name: String) -> UIImage {
        if let icon = icons[name] { return icon }
        let icon = UIImage(named: name)!
        icons[name] = icon
        return icon
    }
}

Kotlin示例

object IconFactory {
    private val icons = mutableMapOf<String, Bitmap>()
    fun getIcon(name: String): Bitmap =
        icons.getOrPut(name) { loadBitmapFromAssets(name) }
}

应用场景扩展：
地图标记、表情包、列表大数据渲染等。

12. 代理模式（Proxy）

核心思想：
通过代理控制对对象的访问、懒加载、安全性或远程调用等。

Swift示例

protocol Image { func display() }
class RealImage: Image {
    let filename: String
    init(filename: String) { self.filename = filename }
    func display() { print("Displaying \(filename)") }
}
class ImageProxy: Image {
    private let filename: String
    private var realImage: RealImage?
    init(filename: String) { self.filename = filename }
    func display() {
        if realImage == nil { realImage = RealImage(filename: filename) }
        realImage!.display()
    }
}

Kotlin示例

interface Image { fun display() }
class RealImage(val filename: String) : Image {
    override fun display() { println("Displaying $filename") }
}
class ImageProxy(val filename: String) : Image {
    private var realImage: RealImage? = null
    override fun display() {
        if (realImage == null) realImage = RealImage(filename)
        realImage!!.display()
    }
}

应用场景扩展：
图片/资源懒加载、安全控制、远程代理服务等。

三、行为型模式（11种）

13. 模板方法模式（Template Method）

核心思想：
父类定义算法骨架，部分步骤由子类实现，保证流程一致、扩展灵活。

Swift示例

class DataSyncTemplate {
    final func sync() {
        fetchData()
        processData()
        saveData()
    }
    func fetchData() { /* 默认实现 */ }
    func processData() { /* 需子类重写 */ }
    func saveData() { /* 默认实现 */ }
}
class UserDataSync: DataSyncTemplate {
    override func processData() { print("User Data Processing...") }
}

Kotlin示例

abstract class DataSyncTemplate {
    fun sync() {
        fetchData()
        processData()
        saveData()
    }
    open fun fetchData() {}
    abstract fun processData()
    open fun saveData() {}
}
class UserDataSync : DataSyncTemplate() {
    override fun processData() { println("User Data Processing...") }
}

应用场景扩展：
数据同步、UI基类、SDK回调模板等。

14. 命令模式（Command）

核心思想：
将请求封装为对象，支持操作记录、撤销、重做、任务队列。

Swift示例

protocol Command { func execute() }
class AddTextCommand: Command {
    let editor: TextEditor; let text: String
    init(editor: TextEditor, text: String) { self.editor = editor; self.text = text }
    func execute() { editor.add(text: text) }
}
class CommandManager {
    private var history: [Command] = []
    func execute(_ command: Command) {
        command.execute()
        history.append(command)
    }
}

Kotlin示例

interface Command { fun execute() }
class AddTextCommand(val editor: TextEditor, val text: String) : Command {
    override fun execute() { editor.add(text) }
}
class CommandManager {
    private val history = mutableListOf<Command>()
    fun execute(command: Command) {
        command.execute()
        history.add(command)
    }
}

应用场景扩展：
撤销重做、批量处理、异步任务队列等。

15. 责任链模式（Chain of Responsibility）

核心思想：
将请求沿责任链传递，直到有处理者处理为止。

Swift示例

protocol Handler {
    var next: Handler? { get set }
    func handle(request: String)
}
class AuthHandler: Handler {
    var next: Handler?
    func handle(request: String) {
        if request == "auth" { print("Auth Passed") }
        else { next?.handle(request: request) }
    }
}

Kotlin示例

interface Handler {
    var next: Handler?
    fun handle(request: String)
}
class AuthHandler : Handler {
    override var next: Handler? = null
    override fun handle(request: String) {
        if (request == "auth") println("Auth Passed")
        else next?.handle(request)
    }
}

应用场景扩展：
网络拦截链、事件分发、权限过滤。

16. 状态模式（State）

核心思想：
对象行为随内部状态改变而变化，状态切换有独立类。

Swift示例

protocol State { func handle() }
class PlayingState: State { func handle() { print("Playing") } }
class PausedState: State { func handle() { print("Paused") } }
class Player {
    private var state: State = PlayingState()
    func setState(_ s: State) { state = s }
    func play() { state.handle() }
}

Kotlin示例

interface State { fun handle() }
class PlayingState : State { override fun handle() = println("Playing") }
class PausedState : State { override fun handle() = println("Paused") }
class Player(var state: State = PlayingState()) {
    fun setState(s: State) { state = s }
    fun play() { state.handle() }
}

应用场景扩展：
UI多状态切换、登录认证、流程引擎等。

17. 策略模式（Strategy）

核心思想：
定义一组算法，将其封装成可互换的策略对象，调用方动态选择。

Swift示例

protocol CompressionStrategy { func compress(_ files: [String]) -> Data }
class ZipCompression: CompressionStrategy {
    func compress(_ files: [String]) -> Data { print("Zip"); return Data() }
}
class RarCompression: CompressionStrategy {
    func compress(_ files: [String]) -> Data { print("Rar"); return Data() }
}
class Compressor {
    var strategy: CompressionStrategy
    init(strategy: CompressionStrategy) { self.strategy = strategy }
    func compress(files: [String]) -> Data { strategy.compress(files) }
}

Kotlin示例

interface CompressionStrategy { fun compress(files: List<String>): ByteArray }
class ZipCompression : CompressionStrategy {
    override fun compress(files: List<String>) = ByteArray(0).also { println("Zip") }
}
class RarCompression : CompressionStrategy {
    override fun compress(files: List<String>) = ByteArray(0).also { println("Rar") }
}
class Compressor(var strategy: CompressionStrategy) {
    fun compress(files: List<String>) = strategy.compress(files)
}

应用场景扩展：
缓存淘汰策略、图片加载策略、动画切换策略等。

18. 观察者模式（Observer）

核心思想：
对象间一对多依赖，被观察对象变化自动通知所有观察者。

Swift示例

protocol Observer: AnyObject { func update(_ value: Int) }
class Subject {
    private var observers = [Observer]()
    private var value = 0
    func addObserver(_ o: Observer) { observers.append(o) }
    func setValue(_ v: Int) {
        value = v
        observers.forEach { $0.update(value) }
    }
}

Kotlin示例

interface Observer { fun update(value: Int) }
class Subject {
    private val observers = mutableListOf<Observer>()
    private var value = 0
    fun addObserver(o: Observer) { observers.add(o) }
    fun setValue(v: Int) {
        value = v
        observers.forEach { it.update(value) }
    }
}

应用场景扩展：
通知中心、LiveData、EventBus、UI主题切换等。

19. 中介者模式（Mediator）

核心思想：
对象间通信由中介者统一管理，简化对象间的直接依赖。

Swift示例

class ChatRoom {
    func send(message: String, from: User, to: User) {
        print("\(from.name) -> \(to.name): \(message)")
    }
}
class User {
    let name: String
    let chatRoom: ChatRoom
    init(name: String, chatRoom: ChatRoom) { self.name = name; self.chatRoom = chatRoom }
    func send(message: String, to: User) { chatRoom.send(message: message, from: self, to: to) }
}

Kotlin示例

class ChatRoom {
    fun send(message: String, from: User, to: User) {
        println("${from.name} -> ${to.name}: $message")
    }
}
class User(val name: String, val chatRoom: ChatRoom) {
    fun send(message: String, to: User) { chatRoom.send(message, this, to) }
}

应用场景扩展：
表单控件联动、消息事件中心、游戏系统事件协调等。

20. 迭代器模式（Iterator）

核心思想：
为集合对象提供一种遍历方式，而不用暴露内部实现细节。

Swift示例

class MyList<T>: Sequence {
    private var items = [T]()
    func add(_ item: T) { items.append(item) }
    func makeIterator() -> IndexingIterator<[T]> {
        return items.makeIterator()
    }
}

Kotlin示例

class MyList<T> : Iterable<T> {
    private val items = mutableListOf<T>()
    fun add(item: T) { items.add(item) }
    override fun iterator(): Iterator<T> = items.iterator()
}

应用场景扩展：
自定义数据结构、分页加载等。

21. 备忘录模式（Memento）

核心思想：
保存对象状态，可在后续恢复，实现撤销/重做功能。

Swift示例

class TextEditor {
    private var text = ""
    private var history = [String]()
    func type(_ t: String) {
        history.append(text)
        text += t
    }
    func undo() {
        text = history.popLast() ?? ""
    }
}

Kotlin示例

class TextEditor {
    private var text = ""
    private val history = mutableListOf<String>()
    fun type(t: String) {
        history.add(text)
        text += t
    }
    fun undo() {
        text = if (history.isNotEmpty()) history.removeAt(history.size - 1) else ""
    }
}

应用场景扩展：
富文本编辑器、绘图应用的撤销/恢复、配置快照等。

22. 解释器模式（Interpreter）

核心思想：
为语言/表达式定义语法规则并解析执行。

Swift示例

protocol Expression { func interpret() -> Int }
class Number: Expression {
    private let value: Int
    init(_ value: Int) { self.value = value }
    func interpret() -> Int { value }
}
class Add: Expression {
    private let left, right: Expression
    init(_ left: Expression, _ right: Expression) { self.left = left; self.right = right }
    func interpret() -> Int { left.interpret() + right.interpret() }
}

Kotlin示例

interface Expression { fun interpret(): Int }
class Number(val value: Int) : Expression {
    override fun interpret() = value
}
class Add(val left: Expression, val right: Expression) : Expression {
    override fun interpret() = left.interpret() + right.interpret()
}

应用场景扩展：
自定义规则引擎、公式解析、埋点表达式、本地DSL解析等。

23. 访问者模式（Visitor）

核心思想：
为一组对象添加新操作，无需改变对象结构。

Swift示例

protocol File { func accept(_ visitor: FileVisitor) }
class TextFile: File { func accept(_ visitor: FileVisitor) { visitor.visit(self) } }
class ImageFile: File { func accept(_ visitor: FileVisitor) { visitor.visit(self) } }
protocol FileVisitor {
    func visit(_ file: TextFile)
    func visit(_ file: ImageFile)
}
class FilePrintVisitor: FileVisitor {
    func visit(_ file: TextFile) { print("TextFile") }
    func visit(_ file: ImageFile) { print("ImageFile") }
}

Kotlin示例

interface File { fun accept(visitor: FileVisitor) }
class TextFile : File { override fun accept(visitor: FileVisitor) = visitor.visit(this) }
class ImageFile : File { override fun accept(visitor: FileVisitor) = visitor.visit(this) }
interface FileVisitor {
    fun visit(file: TextFile)
    fun visit(file: ImageFile)
}
class FilePrintVisitor : FileVisitor {
    override fun visit(file: TextFile) = println("TextFile")
    override fun visit(file: ImageFile) = println("ImageFile")
}

应用场景扩展：
复杂数据结构批量操作、UI树遍历、性能分析、导出统计等。

四、结语：模式不是教条，而是工程进化的钥匙

设计模式让代码结构更清晰、协作更高效、演进更可控。学会用“场景+思想+代码”三位一体的方式理解它们，不盲目套用、而是在合适的场景下激活内在威力。