設計模式(Swift) - 3.觀察者模式、建造者模式

時間 2019-11-29

標籤設計模式 swift 觀察者建造者欄目 Swift 简体版

原文原文鏈接

上一篇設計模式(Swift) - 2.單例模式、備忘錄模式和策略模式中講了三種常見的設計模式.git

單例模式: 限制了類的實例化,一個類只能實例化一個對象,全部對單例對象的引用都是指向了同一個對象.
備忘錄模式: 咱們能夠把某個對象保存在本地,並在適當的時候恢復出來,app開發中最多見的應用就是用戶數據的本地緩存.
策略模式: 經過封裝業務分支來屏蔽業務細節,只給出相關的策略接口做爲切換.

1. 觀察者模式(Observer Pattern)

1. 觀察者模式概述

觀察者模式: 一個對象的變化,可以被另外一個對象知道. 本文除了介紹基於Runtime的KVO實現及其原理,還會本身動手去現實一套觀察者模式,畢竟在swift中使用Runtime並不被推薦. github

被觀察對象(subject): 用來被監聽的可觀察對象.
觀察者(observer): 用來監聽被觀察對象.

2. 基於OC Runtime的觀察者模式實現

1. 實現一個繼承自NSObject的可觀察對象

// @objcMembers 爲了給類中每一個屬性添加 @objc 關鍵詞,
@objcMembers public class KVOUser: NSObject {
    dynamic var name: String

    public init(name: String) {
        self.name = name
    }
}
複製代碼

@objcMembers 爲了給類中每一個屬性添加 @objc 關鍵詞,在swift4中繼承NSObject的子類的屬性不會暴露給OC的Runtime,因此只能手動添加express

swift自己是門靜態語言,添加@objc 關鍵詞是爲了讓屬性具備動態特性,能夠動態的生成set和get方法,由於KVO就須要去操做set方法.編程

// 注意kvoObserver的生命週期
    var kvoObserver: NSKeyValueObservation?
    let kvoUser = KVOUser(name: "Dariel")

    // 監聽kvoUser name屬性的變化
    kvoObserver = kvoUser.observe(\.name, options: [.initial, .new]) {
            (user, change) in
            print("User's name is \(user.name)")
    }
複製代碼

第一個參數是路徑,這邊是簡略寫法.name, swift會本身轉成全路徑; options是 NSKeyValueObservingOptions, 這邊傳入的表示初始化的值和新的值swift

2. 使用繼承自NSObject的可觀察對象

override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
      kvoUser.name = "John"
}
複製代碼

在任何地方改變kvoUser對象的name屬性,kvoObserver的observe方法都會回調.設計模式

3. OC Runtime的觀察者模式實現原理

那麼KVO是怎樣實現對對象屬性的監聽的呢? 當給一個對象添加KVO以後,OC會經過Runtime將這個對象的isa指針指向(未設定KVO的對象的isa指針指向該對象的類對象)本身定義的一個原類的子類類對象(NSKVONotifying_xxx),這個子類類對象的isa指針指向原來對象的類對象,並調用這個類對象中的set方法,而後去通知監聽器哪些值發生了改變. api

在Swift4中,並無在語言層級上支持KVO,若是要使用須要導入Foundation和被觀察對象必須繼承自NSObject,這種實現方式顯然不夠優雅.緩存

4. 實現一個不基於Runtime的觀察者模式

KVO的觀察者模式本質上仍是經過拿到屬性的set方法去搞事情,基於這樣的原理咱們能夠本身實現.直接貼代碼,新建一個Observable的swift文件app

public class Observable<Type> {
    
    // MARK: - Callback
    fileprivate class Callback {
        fileprivate weak var observer: AnyObject?
        fileprivate let options: [ObservableOptions]
        fileprivate let closure: (Type, ObservableOptions) -> Void
        
        fileprivate init(
            observer: AnyObject,
            options: [ObservableOptions],
            closure: @escaping (Type, ObservableOptions) -> Void) {
            
            self.observer = observer
            self.options = options
            self.closure = closure
        }
    }
    
    // MARK: - Properties
    public var value: Type {
        didSet {
            removeNilObserverCallbacks()
            notifyCallbacks(value: oldValue, option: .old)
            notifyCallbacks(value: value, option: .new)
        }
    }
    
    private func removeNilObserverCallbacks() {
        callbacks = callbacks.filter { $0.observer != nil }
    }
    
    private func notifyCallbacks(value: Type, option: ObservableOptions) {
        let callbacksToNotify = callbacks.filter { $0.options.contains(option) }
        callbacksToNotify.forEach { $0.closure(value, option) }
    }
    
    // MARK: - Object Lifecycle
    public init(_ value: Type) {
        self.value = value
    }
    
    // MARK: - Managing Observers
    private var callbacks: [Callback] = []
    
    
    /// 添加觀察者
    ///
    /// - Parameters:
    /// - observer: 觀察者
    /// - removeIfExists: 若是觀察者存在須要移除
    /// - options: 被觀察者
    /// - closure: 回調
    public func addObserver( _ observer: AnyObject, removeIfExists: Bool = true, options: [ObservableOptions] = [.new], closure: @escaping (Type, ObservableOptions) -> Void) {
        
        if removeIfExists {
            removeObserver(observer)
        }
        
        let callback = Callback(observer: observer, options: options, closure: closure)
        callbacks.append(callback)
        
        if options.contains(.initial) {
            closure(value, .initial)
        }
    }
    
    public func removeObserver(_ observer: AnyObject) {
        callbacks = callbacks.filter { $0.observer !== observer }
    }
}

// MARK: - ObservableOptions
public struct ObservableOptions: OptionSet {
    
    public static let initial = ObservableOptions(rawValue: 1 << 0)
    public static let old = ObservableOptions(rawValue: 1 << 1)
    public static let new = ObservableOptions(rawValue: 1 << 2)
    
    public var rawValue: Int
    
    public init(rawValue: Int) {
        self.rawValue = rawValue
    }
}

複製代碼

使用:ide

public class User {
    // 被觀察的屬性須要是Observable類型
    public let name: Observable<String>
    public init(name: String) {
        self.name = Observable(name)
    }
}
// 用來管理觀察者
public class Observer {}

var observer: Observer? // 當observer置爲nil的時候,可觀察對象會自動釋放.
let user = User(name: "Made")
observer = Observer()
user.name.addObserver(observer!, options: [.new]) { name, change in     
    print("name:\(name), change:\(change)")                        
}

override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {        
    user.name.value = "Amel"
}
複製代碼

注意: 在使用過程當中,若是改變value, addObserver方法不調用,頗有多是Observer對象已經被釋放掉了.

5. 觀察者模式的使用場景

觀察者模式通常用在MVC模式中,控制器須要監聽某個模型屬性的改變,而模型不須要知道控制器的類型,所以多個控制器能夠監聽一個模型對象.

2. 建造者模式(Buidler Pattern)

1. 建造者模式概述

建造者模式能夠一步步分解複雜業務場景的實現過程.

管理者(Dircetor): 一般用來管理建造者,通常是個Controller
建造者(Builder): 一般是個類,用來管理Product的建立和數據輸入
產品(Product): 比較複雜的對象,能夠是類或者結構體,一般是個模型

1. 建造者模式舉例

1. Product

// MARK: - Product
public struct Person {
    public let area: Area
    public let character: Character
    public let hobby: Hobby
}
extension Person: CustomStringConvertible {
    public var description: String {
        return area.rawValue
    }
}
public enum Area: String { // 來自區域
    case ShangHai
    case ShenZhen
    case HangZhou
    case Toronto
}
public struct Character: OptionSet { // 性格
    
    public static let independent = Character(rawValue: 1 << 1) // 2
    public static let ambitious = Character(rawValue: 1 << 2) // 4
    public static let outgoing = Character(rawValue: 1 << 3) // 8
    public static let unselfish = Character(rawValue: 1 << 4) // 16
    public static let expressivity = Character(rawValue: 1 << 5) // 32

    public let rawValue: Int
    public init(rawValue: Int) {
        self.rawValue = rawValue
    }
}
public struct Hobby: OptionSet { // 愛好
    
    public static let mountaineering = Hobby(rawValue: 1 << 1)
    public static let boating = Hobby(rawValue: 1 << 2)
    public static let climbing = Hobby(rawValue: 1 << 3)
    public static let running = Hobby(rawValue: 1 << 4)
    public static let camping = Hobby(rawValue: 1 << 5)
    
    public let rawValue: Int
    public init(rawValue: Int) {
        self.rawValue = rawValue
    }
}
複製代碼

Person中定義了三個屬性,area地區,character性格,hobby愛好,其中地區只能是一個值,性格和愛好能夠支持多個值.Character和Hobby能夠經過傳入一個值,設置多個值.

2. Builder

// MARK: - Builder
public class PersonStatistics {
    public private(set) var area: Area = .HangZhou
    public private(set) var characters: Character = []
    public private(set) var hobbys: Hobby = []
    
    private var outOfAreas: [Area] = [.Toronto]
    
    public func addCharacter(_ character: Character) {
        characters.insert(character)
    }
    
    public func removeCharacter(_ character: Character) {
        characters.remove(character)
    }
    
    public func addHobby(_ hobby: Hobby) {
        hobbys.insert(hobby)
    }
    
    public func removeHobby(_ hobby: Hobby) {
        hobbys.remove(hobby)
    }
    
    public func setArea(_ area: Area) throws {
        guard isAvailable(area) else { throw Error.OutOfArea }
        self.area = area
    }
    
    public func build() -> Person {
        return Person(area: area, character: characters, hobby: hobbys)
    }
    
    public func isAvailable(_ area: Area) -> Bool {
        return !outOfAreas.contains(area)
    }
    
    public enum Error: Swift.Error {
        case OutOfArea
    }
}
複製代碼

經過builder統一對Product進行管理,設置完數據以後再去建立Person對象.

3. Director

public class ManagerStatistics {

    public func createLiLeiData() throws -> Person {
        let builder = PersonStatistics()
        try builder.setArea(.HangZhou)
        builder.addCharacter(.ambitious)
        builder.addHobby([.climbing, .boating, .camping])
        return builder.build()
    }
    
    public func createLucyData() throws -> Person {
        let builder = PersonStatistics()
        try builder.setArea(.Toronto)
        builder.addCharacter([.ambitious, .independent, .outgoing])
        builder.addHobby([.boating, .climbing, .camping])
        return builder.build()
    }
}
複製代碼

經過Director去設置builder中的數據.

let manager = ManagerStatistics()
        
 if let Lucy = try? manager.createLucyData() {
     print(Lucy.description)
     print(Lucy.character)
     print(Lucy.hobby)
 }else {
     print("Out of area here")
 }
        
 if let Lilei = try? manager.createLiLeiData() {
     print(Lilei.description)
     print(Lilei.character)
     print(Lilei.hobby)
 }
複製代碼