使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链发送该请求，直到有一个对象处理它为止。
责任链模式的好处是：接收者和发送者都没有对方的明确信息，且链中的对象自己也不知道链的结构。结果是它们仅需保持一个指向其后继者的引用，而不需保持它所有的候选接收者的引用。
类图
实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| public class Request {
private int type;
private String name;
public Request(int type, String name) {
this.type = type;
this.name = name;
}
public int getType() {
return type;
}
public String getName() {
return name;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
| public abstract class Handler {
protected Handler successor;
public Handler(Handler successor) {
this.successor = successor;
}
public abstract void handleRequest(Request request);
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| public class ConcreteHandler1 extends Handler {
public ConcreteHandler1(Handler successor) {
super(successor);
}
@Override
public void handleRequest(Request request) {
if (request.getType() == 1) {
System.out.println(request.getName() + " is handled by ConcreteHandler1");
return;
}
if (successor != null) {
successor.handleRequest(request);
}
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| public class ConcreteHandler2 extends Handler {
public ConcreteHandler2(Handler successor) {
super(successor);
}
@Override
public void handleRequest(Request request) {
if (request.getType() == 2) {
System.out.println(request.getName() + " is handled by ConcreteHandler2");
return;
}
if (successor != null) {
successor.handleRequest(request);
}
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
| public class Client {
public static void main(String[] args) {
Handler superiorHandler = new ConcreteHandler1(null);
Handler juniorHandler = new ConcreteHandler2(superiorHandler);
Request request1 = new Request(1, "request1");
juniorHandler.handleRequest(request1);
Request request2 = new Request(2, "request2");
juniorHandler.handleRequest(request2);
}
}
|