设计模式系列--职责链模式（Chain of Responsib

一、责任链模式介绍

责任链模式：将能够处理同一类请求的对象连成一条链，使这些对象都有机会处理请求，所提交的请求沿着链传递。从而避免请求的发送者和接受者之间的耦合关系。链上的对象逐个判断是否有能力处理该请求，如果能则就处理，如果不能，则传给链上的下一个对象。直到有一个对象处理它为止。

生活中场景：

1、打牌时，轮流出牌

2、接力赛跑

3、请假审批

4、公文审批

责任链UML图：

Chain of Responsibility Pattern UML.jpg

角色说明：

• Handler（抽象处理者）：抽象类或者接口,定义处理请求的方法以及持有下一个Handler的引用.

• ConcreteHandler1,ConcreteHandler2（具体处理者）：实现抽象处理类,对请求进行处理,如果不处理则转发给下一个处理者.

• Client (客户端):即要使用责任链模式的地方。

二、责任链模式代码实现

这里以请假的流程为例，用责任链模式来实现

首先这里定义一个请假信息的对象

//  请假的基本信息类
//  请假的基本信息类
#import <Foundation/Foundation.h>

@interface LeaveRequest : NSObject

/** 请假人 */
@property (nonatomic, strong, readonly) NSString *empName;
/** 请假天数 */
@property (nonatomic, assign, readonly) NSInteger leaveDays;
/** 请假理由 */
@property (nonatomic, strong, readonly) NSString *reason;

/**
 *  全量初始化方法
 *
 * @param empName 请假人姓名
 * @param leaveDays 请假天数
 * @param reson 请假理由
 * @return 本实例
 */
- (instancetype)initWithEmpName:(NSString *)empName
                      leaveDays:(NSInteger)leaveDays
                          reson:(NSString *)reson;

@end


#import "LeaveRequest.h"

@interface LeaveRequest()
/** 请假人 */
@property (nonatomic, strong) NSString *empName;
/** 请假天数 */
@property (nonatomic, assign) NSInteger leaveDays;
/** 请假理由 */
@property (nonatomic, strong) NSString *reason;

@end

@implementation LeaveRequest

- (instancetype)initWithEmpName:(NSString *)empName
                      leaveDays:(NSInteger)leaveDays
                          reson:(NSString *)reson {
    if (self = [super init]) {
        self.empName = empName;
        self.leaveDays = leaveDays;
        self.reason = reson;
    }
    return self;
}

@end

然后定义一个抽象类（iOS中使用接口），来处理各个请求之间的关系。也就是UML图中的Handler部分

//  抽象类（接口）：管理责任链上对象的共同行为
#import <Foundation/Foundation.h>
#import "LeaveRequest.h"

@protocol LeaveResponseInterface <NSObject>

/** 下一个请假处理者 */
@property (nonatomic, strong) id<LeaveResponseInterface> nextLeaveResponser;

/** 请求处理方法 */
- (BOOL)handleLeaveRequest:(LeaveRequest *)leaveReauest;

@end

接下来就可以开始定义处理请求的具体对象了，比如处理请假信息的：主任，经理，总经理等等。这些对象都必须继承抽象类，来处理请求。

主任对象：处理小于等于3天的假期

// 主任

#import <Foundation/Foundation.h>
#import "LeaveResponseInterface.h"

@interface Director : NSObject <LeaveResponseInterface>

/** 角色名称 */
@property (nonatomic, strong, readonly) NSString *name;

// 实现协议：LeaveResponseInterface
@property (nonatomic, strong) id<LeaveResponseInterface> nextLeaveResponser;

- (instancetype)initWithName:(NSString *)name;

// 实现协议：LeaveResponseInterface
- (BOOL)handleLeaveRequest:(LeaveRequest *)leaveReauest;

@end


#import "Director.h"

@interface Director()

@property (nonatomic, strong) NSString *name;

@end

@implementation Director

- (instancetype)initWithName:(NSString *)name {
    if (self = [super init]) {
        self.name = name;
    }
    return self;
}

- (BOOL)handleLeaveRequest:(LeaveRequest *)leaveReauest {
    if (leaveReauest.leaveDays < 3) {
        NSLog(@"请假人：%@, 天数：%ld, 理由：%@", leaveReauest.empName, leaveReauest.leaveDays, leaveReauest.reason);
        NSLog(@"审批人：%@主任，审批通过！", self.name);
        return YES;
    } else {
        // 下一个审批者进行处理
        if (self.nextLeaveResponser) {
            return [self.nextLeaveResponser handleLeaveRequest:leaveReauest];
        } else {
            return NO;
        }
    }
}

@end

以下经理和总经理类在实际开发中，不需要继承自Director而是直接实现协议。这里使用继承只是Demo的场景比较简单，便于复用代码。纯属省力之举，并不科学。

经理对象：处理大于3天，小于等于5天的假期

//  经理

#import <Foundation/Foundation.h>
#import "Director.h"

@interface Manager : Director

@end

#import "Manager.h"

@implementation Manager

- (BOOL)handleLeaveRequest:(LeaveRequest *)leaveReauest {
    if (leaveReauest.leaveDays <= 5 && leaveReauest.leaveDays >= 3) {
        NSLog(@"请假人：%@, 天数：%ld, 理由：%@", leaveReauest.empName, leaveReauest.leaveDays, leaveReauest.reason);
        NSLog(@"审批人：%@经理，审批通过!", self.name);
        return YES;
    } else {
        // 下一个审批者进行处理
        if (self.nextLeaveResponser) {
            return [self.nextLeaveResponser handleLeaveRequest:leaveReauest];
        } else {
            return NO;
        }
    }
}

@end

总经理对象：处理大于5天，小于15天的请假信息

//  总经理 

#import "Director.h"

@interface GeneralManager : Director

@end

#import "GeneralManager.h"

@implementation GeneralManager

- (BOOL)handleLeaveRequest:(LeaveRequest *)leaveReauest {
    if (leaveReauest.leaveDays > 5 && leaveReauest.leaveDays < 15) {
        NSLog(@"请假人：%@, 天数：%ld, 理由：%@", leaveReauest.empName, leaveReauest.leaveDays, leaveReauest.reason);
        NSLog(@"审批人：%@总经理，审批通过!", self.name);
        return YES;
    } else {
        // 下一个审批者进行处理
        if (self.nextLeaveResponser) {
            return [self.nextLeaveResponser handleLeaveRequest:leaveReauest];
        } else {
            return NO;
        }
    }
}

@end

重要代码都写完了，下面开始测试：

 // 构建各领导人
 Director *a = [[Director alloc] initWithName:@"张三"];
 Manager *b = [[Manager alloc] initWithName:@"李四"];
 GeneralManager *c = [[GeneralManager alloc] initWithName:@"王五"];
 // 设置责任链关系
 a.nextLeaveResponser = b;
 b.nextLeaveResponser = c;
 // 开始请假
 LeaveRequest *leaveRequest = [[LeaveRequest alloc] initWithEmpName:@"小明" leaveDays:3 reson:@"旅游"];
 [a handleLeaveRequest:leaveRequest];

控制台则打印：主任审批

请假人：小明,天数：3,理由：旅游

审批人：张三 主任，审批通过！

如果改成13天：则就是总经理审批

请假人：小明,天数：13,理由：旅游

审批人：王五 总经理，审批通过！

三、责任链模式总结

一句话定义：

当你想让多个同类对象都有机会处理某个请求的时候就可以使用责任链模式

实现方式：

1、链表方式：比如刚才的请假审批

2、非链表方式：通过集合，数组生成责任链更加实用，将链表上的各个对象都添加到集合中，然后通过反射给构建出来。

然后在容器里一个个的处理。（也就是说把测试代码中除了请假的其他代码都给用一个类来处理）

开发中常见场景：

1、iOS、Android 事件分发机制

2、Java的异常机制就是一个责任链模式，一个try可以对应多个cathc。如果某一个catch不匹配，则跳到下一个catch中

3、JavaScript语言中的事件的冒泡和捕获机制

4、Servlet开发中，过滤器的链式处理

5、Struts2中，拦截器的调用也是典型的责任链模式

责任链的好处：

1、接受者和发送者及接受者之间解耦。接受者和发送者都没有对方的明确信息，且链中的对象也并不知道链的结构，结果是责任链可简化对象的相互连接，它们仅需保持一个指向其后继者的引用，而不需要保持它所有的候选继承者，大大的降低了耦合度。

发送者不用管具体哪个对象会处理，反正该请求肯定会被处理就行了

2、可以随时增加或者修改处理一个请求的结构，增加了给对象指派职责的灵活性

责任链的弊端：

1、请求有可能遍历完链都得不到处理

2、不容易观察运行时的特征，有碍于debug

Demo 下载链接