转载

设计模式(Swift) - 2.单例模式、备忘录模式和策略模式

上一篇设计模式(Swift) - 1.MVC和代理中涉及到了三点,类图,MVC和代理模式.

类图用来清晰直观的表达设计模式.
作为Cocoa框架的核心结构模式,MVC怎样处理视图、模型、控制器之间的关系.
将我想做的事委托给有能力的人的代理模式.

1. 单例模式(Singleton Pattern)

1.单例概述

单例限制了类的实例化,一个类只能实例化一个对象,所有对单例对象的引用都是指向了同一个对象.

设计模式(Swift) - 2.单例模式、备忘录模式和策略模式

2.单例的使用

// 定义一个单例
final public class MySingleton {
    static let shared = MySingleton()
    private init() {}  // 私有化构造方法(如果有需要也可以去掉)
}

// 使用
let s1 = MySingleton.shared
let s2 = MySingleton.shared
// let s3 = MySingleton()  // 报错
dc.address(o: s1)   // 0x000060400000e5e0
dc.address(o: s2)   // 0x000060400000e5e0

相比OC,swift中单例的实现简化了不少,swift中可以使用let这种方式来保证线程安全.

3.单例使用的优缺点

优点:

1.由于单例能保证一个对象存在,我们可以对某些操作进行统一管理,比如,app开发中用户信息的保存和读取,如后台开发中服务器配置信息的管理操作.这样可以有效的避免不必要的对象的创建和销毁,提高开发效率.

缺点:

1. 单例模式本质上延长了对象的声明周期,如果强引用了比较大的对象,不可避免的会造成内存问题,所以在适当的时候需要进行重置单例的操作.

2. 由于单例是全局共享,也就意味着整个项目中都可以对单例进行操作,使得出现问题比较难定位.

2. 备忘录模式(Memento Pattern)

1.备忘录模式概述

通过备忘录模式我们可以把某个对象保存在本地,并在适当的时候恢复出来.

设计模式(Swift) - 2.单例模式、备忘录模式和策略模式

备忘录模式总体来说分为三部分:

发起人(Originator): 负责创建一个备忘录对象，用以保存当前的状态，并可使用备忘录恢复内部状态。
Memento(备忘录): 负责存储Originator对象,在swift中由Codable实现.
Caretaker(管理者): 负责备忘录的保存与恢复工作.

Swift tips: Codable
Codable是swift4推出来的新特性,所有基本类型都实现了 Codable 协议,只要自定义的对象遵守了该协议,就可以保存和恢复所需要的对象.
本质上Codable,就是Decodable和Encodable的集合.
具体拓展可以看这里Swift 4 踩坑之 Codable 协议

public typealias Codable = Decodable & Encodable

2.备忘录模式举例

个人用户信息的本地化存储,包括用户token啊之类的.

1.个人信息操作的业务逻辑:

// MARK: - Originator(发起人)
public class UserInfo: Codable {

    static let shared = UserInfo()
    private init() {}

    public var isLogin: Bool = false

    public var account: String?
    public var age: Int?

    var description: String {
        return "account:/(account ?? "为空"), age:/(age ?? 0)"
    }

}

// MARK: - 备忘录(Memento): 负责存储Originator对象,swift中由Codable实现


// MARK: - 管理者(CareTaker)
public class UserInfoTaker {

    public static let UserInforKey = "UserInfoKey"

    private static let decoder = JSONDecoder()
    private static let encoder = JSONEncoder()
    private static let userDefaults = UserDefaults.standard

    public static func save(_ p: UserInfo) throws {

        let data = try encoder.encode(p)
        userDefaults.set(data, forKey: UserInforKey)
    }

    public static func load() throws -> UserInfo {

        guard let data = userDefaults.data(forKey: UserInforKey),
            let userInfo = try? decoder.decode(UserInfo.self, from: data)
            else {
                throw Error.UserInfoNotFound
        }

        // decode生成的对象不是单例对象,需要转换成单例对象
        // 如果你有更好的实现方式欢迎交流
        let userInfoS = UserInfo.shared
        userInfoS.account = userInfo.account
        userInfoS.age = userInfo.age
        userInfoS.isLogin = userInfo.isLogin

        return userInfoS
    }

    public enum Error: String, Swift.Error {
        case UserInfoNotFound
    }
}

2.个人信息操作:

    let userInfo = UserInfo.shared
    userInfo.isLogin = true
    userInfo.account = "132154"
    userInfo.age = 16

    // 保存
    do {
        try UserInfoTaker.save(userInfo)
    }catch {
        print(error)
    }

    // 读取
    do {
        let newUserInfo = try UserInfoTaker.load()

        dc.log(newUserInfo.description) // account:132154, age:16
        dc.address(o: newUserInfo) // 0x000060000009a400

    }catch {
        print(error)
    }

    dc.log(userInfo.description) // account:132154, age:16
    dc.address(o: userInfo) // 0x000060000009a400

备忘录的最大好处就是可以恢复到特定的状态,但每次的读写操作需要消耗一定的系统资源,所以在某些场景下可以将单例模式和备忘录模式结合来统一管理操作数据.

3. 策略模式(Strategy Pattern)

1.策略模式概述

在日常开发中,我们经常会碰到逻辑分支,我们一般会用 if else或者switch去处理,但其实还有更好的方式: 策略模式.

策略模式抽象并封装业务细节,只给出相关的策略接口作为切换.

设计模式(Swift) - 2.单例模式、备忘录模式和策略模式

策略模式总体来说分为三部分:

策略模式的使用者: 为了统一直观的使用策略模式,我们通常会用一个switch语句再做一层封装.
策略协议: 抽象出策略对象需要实现的属性,方法.
策略对象: 具体的业务逻辑实现者.

2.策略模式举例

实现一个商场打折的例子,分为三种情况,原价购买,按照一个折扣购买,满多少返现多少(满100减20).

可以先思考下再看代码.

1.实现商场打折的业务逻辑:

// 策略协议
protocol DiscountStrategy {
    // 支付价格
    func payment(money: Double) -> Double
}


// 原价购买
class DiscountNormal: DiscountStrategy {
    func payment(money: Double) -> Double {
        return money
    }
}

// 打折
class DiscountRebate: DiscountStrategy {
    private let rebate: Double // 折扣

    init(rebate: Double) {
        self.rebate = rebate
    }
    func payment(money: Double) -> Double {
        return money * rebate/10.0
    }
}

// 返现
class DiscountReturn: DiscountStrategy {
    private let moneyCondition: Double // 满
    private let moneyReturn: Double // 返

    init(moneyCondition: Double, moneyReturn: Double) {
        self.moneyCondition = moneyCondition
        self.moneyReturn = moneyReturn
    }

    func payment(money: Double) -> Double {
        return money - (Double(Int(money/moneyCondition)) * moneyReturn)
    }
}

// 策略枚举
enum PayMentStyle {
    case normal
    case rebate(rebate: Double)
    case `return`(moneyCondition: Double, moneyReturn: Double)
}

// 策略管理
class DiscountContext {
    var discountStrategy: DiscountStrategy?

    init(style: PayMentStyle) {
        switch style { // 对应的三种方式
        case .normal:
            discountStrategy = DiscountNormal()

        case .rebate(rebate: let money):
            discountStrategy = DiscountRebate(rebate: money)

        case .return(moneyCondition: let condition, moneyReturn: let `return`):
            discountStrategy = DiscountReturn(moneyCondition: condition, moneyReturn: `return`)

        }
    }

    func getResult(money: Double) -> Double {
       return discountStrategy?.payment(money: money) ?? 0
    }
}

2.使用:

 let money: Double = 800

 let normalPrice = DiscountContext(style: .normal).getResult(money: money)
 let rebatePrice = DiscountContext(style: .rebate(rebate: 8)).getResult(money: money)
 let returnPrice = DiscountContext(style: .return(moneyCondition: 100, moneyReturn: 20)).getResult(money: money)

 print("正常价格:/(normalPrice)") // 正常价格:800.0
 print("打八折:/(rebatePrice)") // 打八折:640.0
 print("满100返20:/(returnPrice)") // 满100返20:640.0