命令模式和备忘录模式的对比

首先先简单的分析下我们下面要讲解的案例当中的角色有哪些，对于命令模式和备忘录模式都有分开来进行讲解

命令模式

• 角色一：接受者 -> Receiver

• 角色二：命令接口 ->CommandProtocol

• 角色三：具体命令 继承命令接口，去实现相应的方法 ->ConcreteCommand

• 角色四：请求者 -> Invoker ，其中这个就是调用者可以是我们客户端

备忘录模式

• 角色一：管理者->负责创建一个备忘录，可以记录或者恢复内部状态

• 角色二：备忘录角色，用于存储角色一的内部状态，并且可以防止角色一以外的对象访问角色二也就是我们的备忘录角色

下面就简单的介绍下银行增加账户和删除账户的金钱变化的案例，主要体会思想

首先如果我们是使用的是基于命令模式的话，案例的内部结构如下所示

银行实体类

import Foundation

//银行实体类
class BankEntry:NSObject
{
    //银行数据(时间、用户名...)
    //唯一标识
    let id:Int
    //数量(账户金额)
    let amount:Float

    init(id:Int,amount:Float) {
        self.id = id
        self.amount = amount
    }
}

命令模式当中的接受者对象也就是银行类，我们增加用户就是对这个银行类进行操作，也就是说这里面是去实现了具体的业务逻辑的比如说增加用户和删除用户

import Foundation

class Bank:NSObject
{
    //具体的业务逻辑
    //账户->ID对应(字典)
    private var entrys = [Int:BankEntry]()
    //当前账户ID下标(数量)
    private var nextId = 1
    //总金额(统计总金额)
    private var total:Float = 0

    //添加用户
      func addEntry(entry:BankEntry)->Void {

        self.entrys[entry.id] = entry
        total += entry.amount
        nextId += 1
    }
    //撤销用户
   func undoEntry(entry:BankEntry)
    {
        let removeObj = self.entrys.removeValue(forKey: entry.id)

        if removeObj != nil
        {
            //去减少相应的银行里面的金额
            self.total -= (removeObj?.amount)!
        }
    }

    func printEntrys()
    {
        print("金额\(self.total)")
    }

}

下面就是命令接口类，主要做逻辑思维

import Foundation

protocol BankCommandProtocol
{
    func execute(entry:BankEntry)
}

下面就是将增加用户的操作给封装成一个命令类

import Foundation

class BankUserAddCommand:BankCommandProtocol
{

    private var bank:Bank
    init(_ bank:Bank) {

        self.bank = bank

    }
    //撤销用户的命令
    func execute(entry: BankEntry) {

    self.bank.addEntry(entry: entry)
    }
}

下面就是将用户撤销的命令去做一个封装成命令

import Foundation

class BankUserUndoCommand:BankCommandProtocol
{
    func execute(entry: BankEntry) {
        self.bank.undoEntry(entry: entry)
    }

    private var bank:Bank

    init(_ bank:Bank) {
        self.bank = bank
    }

}

下面就是基于备忘录模式的案例

下面是备忘录对象BankMemo

import Foundation

class BankMemo:NSObject
{
    //存储实体类
    var entrys = [BankEntry]()

    //当前账户下标(数量)
    private var nextId = 1

    //总的金额
    private var total:Float = 0

    //我们需要通过BankOriginator去创建对象，我们也需要通过BankOriginator去做备忘录
    init(org:BankOriginator) {

        //在这里面先去存储其中的所有的数据
       for item in org.entrys.values
       {
        self.entrys.append(item)
        }
        self.nextId = org.nextId
        self.total = org.total
    }

    //然后去进行备忘录设置
    func apply(org:BankOriginator)
    {
        org.total = self.total
        org.nextId = self.nextId
        //将我存储到的所有的Bank类给它
        for item in self.entrys
        {
            org.entrys[item.id] = item
        }
    }
}

创建备忘录对象的管理器

import Foundation

class BankOriginator:NSObject
{
    //账户->ID对应字典
  var entrys = [Int:BankEntry]()

    //当前账户下标(数量)
   var nextId = 1

    //总的金额
    var total:Float = 0

    //添加账户的方法
    func addEntry(id:Int,amount:Float)
    {
        let entry = BankEntry(id: id, amount: amount)
        self.entrys[entry.id] = entry
        total += amount
        nextId += 1
    }

    //创建备忘录对象
    func createMemo() -> BankMemo
    {
        return BankMemo(org: self)
    }
    //这里就是去调用备忘录对象的方法进行恢复状态
    func applyMemo(memo:BankMemo)
    {
        //备忘录对象的apply方法
        memo.apply(org: self)
    }

    //打印出总值
    func printEntry()
    {
         print("金额为：\(self.total)")
    }

}

下面就是具体的应用过程基于备忘录模式的应用

        //备忘录对象的管理对象
        let org = BankOriginator()
        //添加实体对象
        org.addEntry(id: 1, amount: 3000)
        org.addEntry(id: 2, amount: 2000)
        //创建备忘录对象 
        let memo = org.createMemo()
        org.addEntry(id: 3, amount: 2000)
        org.addEntry(id: 4, amount: 2000)
        org.printEntry()
        //添加备忘录(处理，如果已经恢复，那么就没有必要恢复了)
        org.applyMemo(memo: memo)
        org.printEntry()

下面是总体的金额显示全部存储为9000，然后我们创建的备忘录对象可以恢复，然后到我们创建备忘录对象的父就是恢复到5000了

对于命令模式的处理如下所示

let bank = Bank()
//创建增加用户命令对象
let bankaddCmd = BankUserAddCommand(bank)
//创建撤销用户命令对象
let bankundoCmd = BankUserUndoCommand(bank)
//创建实例用户
let bankentry1 = BankEntry(id: 1, amount: 2000)

let bankentry2 = BankEntry(id: 2, amount: 3000)
//执行添加用户的命令
bankaddCmd.execute(entry: bankentry1)
bankaddCmd.execute(entry: bankentry2)

//然后打印出结果
bank.printEntrys()

bankundoCmd.execute(entry: bankentry1)

bank.printEntrys()
//执行撤销的操作
bankundoCmd.execute(entry: bankentry2)

bank.printEntrys()

备忘录模式是能操作整个过程的，我们随时可以进行恢复，如果是命令模式的话，我们要去操作的就是只有一步一步的进行撤销操作的