Swift设计模式----责任链模式

责任链模式是一种行为设计模式， 允许你将请求沿着处理者链进行发送。 收到请求后， 每个处理者均可对请求进行处理， 或将其传递给链上的下个处理者。

其实iOS事件响应链就是一种责任链模式，当用户点击屏幕后产生一个事件，这个事件会在视图数里传递，直到找到能处理这个事件的响应者。

这里举个例子，假期批假流程，小组长只能批1天，部门经理5天，CEO10天，超过十天直接辞职。首先定义一个假期类：

class Vacation: NSObject {
    
    init(name: String, days: Float, reason: String) {
        self.name = name
        self.days = days
        self.reason = reason

        super.init()
    }
    
    //请假人
    var name = ""
    
    //假期天数
    var days:Float = 0
    
    //请假原因，事假、婚假、陪产假、病假等
    var reason: String = ""
    
    override var description: String{
        get{
            return "请假人\(name),假期时间\(days), 假期原因\(reason)"
        }
    }

}

然后我们定义一个管理者的超类，超类里必须有一个next指向下一个管理者，然后还要有个处理当前事件的方法:

class Ruler: NSObject {
    
    //上一级
    var nextRuler: Ruler?

    //处理假期
    func processVacation(vacation: Vacation){
        
        //如果能处理就处理，不能处理就转发上一级
        if vacation.days <= self.limitDays() {
            
            self.process(vacation: vacation)
            
        }else{
            if let next = self.nextRuler {
                
                next.processVacation(vacation: vacation)
                
            }else{
                
                print("请假天数太多，直接辞职吧！")
            }
        }
    }
    
    //具体处理过程
    func process(vacation: Vacation){
        
        print("处理了假期\(vacation)")
    }
    
    //能处理的假期天数
    func limitDays() -> Float {
        return 0
    }

    
}

最后，我们要定义不同的管理者，来处理相应的事件：

class TeamLeaderRuler: Ruler {
    
    override func process(vacation: Vacation) {
        print("小组长处理了假期\(vacation)")
    }
    
    override func limitDays() -> Float {
        return 1
    }
}

class ManagerRuler: Ruler {
    
    override func process(vacation: Vacation) {
        print("部门经理处理了假期\(vacation)")
    }
    
    override func limitDays() -> Float {
        return 5
    }
}

class CEORuler: Ruler {
    
    override func process(vacation: Vacation) {
        print("总经理处理了假期\(vacation)")
    }
    
    override func limitDays() -> Float {
        return 10
    }
}

这三个管理者是具体的事件处理者，外部调用时需要手动分配层级：

        //创建管理者，并且分配层级
        let teamLeader = TeamLeaderRuler()
        let manager = ManagerRuler()
        let ceo = CEORuler()
        
        teamLeader.nextRuler = manager
        manager.nextRuler = ceo

        
        let va1 = Vacation.init(name: "张三", days: 1, reason: "病假")
        let va2 = Vacation.init(name: "李三", days: 5, reason: "事假")
        let va3 = Vacation.init(name: "王三", days: 10, reason: "婚假")
        let va4 = Vacation.init(name: "钱三", days: 15, reason: "陪产假假")
        
        teamLeader.processVacation(vacation: va1)
        teamLeader.processVacation(vacation: va2)
        teamLeader.processVacation(vacation: va3)
        teamLeader.processVacation(vacation: va4)

打印结果:

小组长处理了假期请假人张三,假期时间1.0, 假期原因病假
部门经理处理了假期请假人李三,假期时间5.0, 假期原因事假
总经理处理了假期请假人王三,假期时间10.0, 假期原因婚假
请假天数太多，直接辞职吧！

责任链模式的有点就是单一职责，每个类就处理自己的事情，并且符合开闭原则，想要增加一个董事长类，只需要再继承一下，然后添加到责任链里就可以了。