本文详细介绍了职责链设计模式的功能、结构及实现方法，通过C++和Java代码示例展示了如何构建请求处理链，使请求能在链中的多个处理者间传递直至被处理。
1.1 Chainof Responsibility
1.1.1 功能
ü 将可能处理一个请求的对象链接成一个链，并将请求在这个链上传递，直到有对象处理该请求；
ü 由于传递过程是在每个请求中进行的，因此使得多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。
1.1.2 结构图、对象图
•H a n d l e r（如He l p H a n d l e r）
— 定义一个处理请求的接口。
— （可选） 实现后继链。
• C o n c r e t e H a n d l e r（如P r in t B u t t o n和Pr i n t D i a l o g）
— 处理它所负责的请求。
— 可访问它的后继者。
— 如果可处理该请求，就处理之；否则将该请求转发给它的后继者。
• C l i e n t
— 向链上的具体处理者( C o n c r e t e H a n d l e r )对象提交请求。
典型的对象结构可能如下图所示 :
Chain of Responsibility模式中ConcreteHandler将自己的后继对象（向下传递消息的对
象）记录在自己的后继表中，当一个请求到来时，ConcreteHandler会先检查看自己有没有匹配的处理程序，如果有就自己处理，否则传递给它的后继。
3.1.3 C++代码示例
//Handle.h
#ifndef _HANDLE_H_
#define _HANDLE_H_
class Handle
{
public:
virtual ~Handle();
virtual void HandleRequest() = 0;
void SetSuccessor(Handle* succ);
Handle* GetSuccessor();
protected:
Handle();
Handle(Handle* succ);
private:
Handle* _succ;
};
class ConcreteHandleA :publicHandle
{
public:
ConcreteHandleA();
~ConcreteHandleA();
ConcreteHandleA(Handle* succ);
void HandleRequest();
protected:
private:
};
class ConcreteHandleB :publicHandle
{
public:
ConcreteHandleB();
~ConcreteHandleB();
ConcreteHandleB(Handle* succ);
void HandleRequest();
protected:
private:
};
#endif //~_HANDLE_H_
//Handle.cpp
#include "Handler.h"
#include <iostream>
using namespace std;
Handle::Handle()
{
_succ = 0;
}
Handle::~Handle()
{
delete _succ;
}
Handle::Handle(Handle*succ)
{
this->_succ = succ;
}
void Handle::SetSuccessor(Handle*succ)
{
_succ = succ;
}
Handle* Handle::GetSuccessor()
{
return _succ;
}
void Handle::HandleRequest()
{
}
ConcreteHandleA::ConcreteHandleA()
{
}
ConcreteHandleA::ConcreteHandleA(Handle*
succ) :Handle(succ)
{
}
ConcreteHandleA::~ConcreteHandleA()
{
}
void ConcreteHandleA::HandleRequest()
{
if (this->GetSuccessor() != 0)
{
cout << "ConcreteHandleA 我把处理权给后继节点....."<<endl;
this->GetSuccessor()->HandleRequest();
}
else
{
cout << "ConcreteHandleA 没有后继了，我必须自己处理...."<<endl;
}
}
ConcreteHandleB::ConcreteHandleB()
{
}
ConcreteHandleB::ConcreteHandleB(Handle*succ) :Handle(succ)
{
}
ConcreteHandleB::~ConcreteHandleB()
{
}
void ConcreteHandleB::HandleRequest()
{
if (this->GetSuccessor() != 0)
{
cout << "ConcreteHandleB 我把处理权给后继节点....."<<endl;
this->GetSuccessor()->HandleRequest();
}
else
{
cout << "ConcreteHandleB 没有后继了，我必须自己处理...."<<endl;
}
}
//main.cpp
#include "Handler.h"
#include <iostream>
using namespace std;
int main(int argc, char*argv[])
{
Handle* h1 = new ConcreteHandleA();
Handle* h2 = new ConcreteHandleB();
h1->SetSuccessor(h2);
h1->HandleRequest();
return 0;
}
1.1.3 Java代码示例
在网上看的一篇文章，他的处理方法与上面的C++代码（严格按照GoF的例子实现）有些不同，他将建立责任链的过程提到了客户端代码中，换来的好处是可以随意的定义传输链。
在大学里面当班干部，时常要向上级申请各方面的东西。譬如申请全班外出秋游，普通同学将申请表交给班长，班长签字之后交给辅导员，辅导员批准之后上交到主任办公室…就是这样，一个请求（这里是一份申请表）有时候需要经过好几个级别的处理者（这里是辅导员、主任）的审查才能够最终被确定可行与否。
在这里表现出来的是一个职责链，即不同的处理者对同一个请求可能担负着不同的处理方式、权限，但是我们希望这个请求必须到达最终拍板的处理者（否则秋游就没戏了）。这种关系就很适合使用职责链模式了。
类图结构如下：
代码实现如下：
1. // 全局变量，接口类型
2. /**
3. * 使用Java中的interface定义全局变量，可根据具体需要在
4. * 具体的包中使用静态导入相关的全局变量，语法如下：
5. * import static package01.package02.*;
6. */
7. interface Levels {
8. public static final int LEVEL_01 = 1;
9. public static final int LEVEL_02 = 2;
10. public static final int LEVEL_03 = 3;
11. }
1. // 抽象请求类
2. abstract class AbstractRequest {
3. private String content = null;
4.
5. public AbstractRequest(String content) {
6. this.content = content;
7. }
8.
9. public String getContent() {
10. return this.content;
11. }
12.
13. // 获得请求的级别
14. public abstract int getRequestLevel();
15. }
1. // 具体请求类01
2. class Request01 extends AbstractRequest {
3. public Request01(String content) {
4. super(content);
5. }
6.
7. @Override
8. public int getRequestLevel() {
9. return Levels.LEVEL_01;
10. }
11. }
12.
13. // 具体请求类02
14. class Request02 extends AbstractRequest {
15. public Request02(String content) {
16. super(content);
17. }
18.
19. @Override
20. public int getRequestLevel() {
21. return Levels.LEVEL_02;
22. }
23. }
24.
25. // 具体请求类03
26. class Request03 extends AbstractRequest {
27. public Request03(String content) {
28. super(content);
29. }
30.
31. @Override
32. public int getRequestLevel() {
33. return Levels.LEVEL_03;
34. }
35. }
1. // 抽象处理者类，
2. abstract class AbstractHandler {
3. // 责任链的下一个节点，即处理者
4. private AbstractHandler nextHandler = null;
5.
6. // 捕获具体请求并进行处理，或是将请求传递到责任链的下一级别
7. public final void handleRequest(AbstractRequest request) {
8.
9. // 若该请求与当前处理者的级别层次相对应，则由自己进行处理
10. if (this.getHandlerLevel() == request.getRequestLevel()) {
11. this.handle(request);
12. } else {
13. // 当前处理者不能胜任，则传递至职责链的下一节点
14. if (this.nextHandler != null) {
15. System.out.println("当前 处理者-0" + this.getHandlerLevel()
16. + " 不足以处理 请求-0" + request.getRequestLevel());
17.
18. // 这里使用了递归调用
19. this.nextHandler.handleRequest(request);
20. } else {
21. System.out.println("职责链上的所有处理者都不能胜任该请求...");
22. }
23. }
24. }
25.
26. // 设置责任链中的下一个处理者
27. public void setNextHandler(AbstractHandler nextHandler) {
28. this.nextHandler = nextHandler;
29. }
30.
31. // 获取当前处理者的级别
32. protected abstract int getHandlerLevel();
33.
34. // 定义链中每个处理者具体的处理方式
35. protected abstract void handle(AbstractRequest request);
36. }
1. // 具体处理者-01
2. class Handler01 extends AbstractHandler {
3. @Override
4. protected int getHandlerLevel() {
5. return Levels.LEVEL_01;
6. }
7.
8. @Override
9. protected void handle(AbstractRequest request) {
10. System.out.println("处理者-01 处理 " + request.getContent() + "\n");
11. }
12. }
13.
14. // 具体处理者-02
15. class Handler02 extends AbstractHandler {
16. @Override
17. protected int getHandlerLevel() {
18. return Levels.LEVEL_02;
19. }
20.
21. @Override
22. protected void handle(AbstractRequest request) {
23. System.out.println("处理者-02 处理 " + request.getContent()+ "\n");
24. }
25. }
26.
27. // 具体处理者-03
28. class Handler03 extends AbstractHandler {
29. @Override
30. protected int getHandlerLevel() {
31. return Levels.LEVEL_03;
32. }
33.
34. @Override
35. protected void handle(AbstractRequest request) {
36. System.out.println("处理者-03 处理 " + request.getContent()+ "\n");
37. }
38. }
1. // 测试类
2. public class Client {
3. public static void main(String[] args) {
4. // 创建指责链的所有节点
5. AbstractHandler handler01 = new Handler01();
6. AbstractHandler handler02 = new Handler02();
7. AbstractHandler handler03 = new Handler03();
8.
9. // 进行链的组装，即头尾相连，一层套一层
10. handler01.setNextHandler(handler02);
11. handler02.setNextHandler(handler03);
12.
13. // 创建请求并提交到指责链中进行处理
14. AbstractRequest request01 = new Request01("请求-01");
15. AbstractRequest request02 = new Request02("请求-02");
16. AbstractRequest request03 = new Request03("请求-03");
17.
18. // 每次提交都是从链头开始遍历
19. handler01.handleRequest(request01);
20. handler01.handleRequest(request02);
21. handler01.handleRequest(request03);
22. }
23. }
测试结果：
1. 处理者-01 处理 请求-01
2.
3. 当前 处理者-01 不足以处理 请求-02
4. 处理者-02 处理 请求-02
5.
6. 当前 处理者-01 不足以处理 请求-03
7. 当前 处理者-02 不足以处理 请求-03
8. 处理者-03 处理 请求-03
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
