使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。
类图
代码示例
1. class Level {
2. private int level = 0;
3. public Level(int level){
4. this.level = level;
5. };
6.
7. public boolean above(Level level){
8. if(this.level >= level.level){
9. return true;
10. }
11. return false;
12. }
13. }
14.
15. class Request {
16. Level level;
17. public Request(Level level){
18. this.level = level;
19. }
20.
21. public Level getLevel(){
22. return level;
23. }
24. }
25.
26. class Response {
27.
28. }
Handler:
1. abstract class Handler {
2. private Handler nextHandler;
3. public final Response handleRequest(Request request){
4. Response response = null;
5.
6. if(this.getHandlerLevel().above(request.getLevel())){
7. response = this.response(request);
8. }else{
9. if(this.nextHandler != null){
10. this.nextHandler.handleRequest(request);
11. }else{
12. System.out.println("-----没有合适的处理器-----");
13. }
14. }
15. return response;
16. }
17. public void setNextHandler(Handler handler){
18. this.nextHandler = handler;
19. }
20. protected abstract Level getHandlerLevel();
21. public abstract Response response(Request request);
22. }
ConcreteHandler:
1. class ConcreteHandler1 extends Handler {
2. protected Level getHandlerLevel() {
3. return new Level(1);
4. }
5. public Response response(Request request) {
6. System.out.println("-----请求由处理器1进行处理-----");
7. return null;
8. }
9. }
10.
11. class ConcreteHandler2 extends Handler {
12. protected Level getHandlerLevel() {
13. return new Level(3);
14. }
15. public Response response(Request request) {
16. System.out.println("-----请求由处理器2进行处理-----");
17. return null;
18. }
19. }
20.
21. class ConcreteHandler3 extends Handler {
22. protected Level getHandlerLevel() {
23. return new Level(5);
24. }
25. public Response response(Request request) {
26. System.out.println("-----请求由处理器3进行处理-----");
27. return null;
28. }
29. }
client:
1. public class Client {
2. public static void main(String[] args){
3. Handler handler1 = new ConcreteHandler1();
4. Handler handler2 = new ConcreteHandler2();
5. Handler handler3 = new ConcreteHandler3();
6.
7. handler1.setNextHandler(handler2);
8. handler2.setNextHandler(handler3);
9.
10. Response response = handler1.handleRequest(new Request(new Level(4)));
11. }
} 责任链模式结构
责任连模式的类图非常简单，它由一个抽象地处理类和它的一组实现类组成：
- 抽象处理类：抽象处理类中主要包含一个指向下一处理类的成员变量nextHandler和一个处理请求的方法handRequest，handRequest方法的主要主要思想是，如果满足处理的条件，则有本处理类来进行处理，否则由nextHandler来处理。
- 具体处理类：具体处理类主要是对具体的处理逻辑和处理的适用条件进行实现。
责任链模式优缺点
责任链模式与if…else…相比，他的耦合性要低一些，因为它把条件判定都分散到了各个处理类中，并且这些处理类的优先处理顺序可以随意设定。
责任链模式也有缺点，这与if…else…语句的缺点是一样的，那就是在找到正确的处理类之前，所有的判定条件都要被执行一遍，当责任链比较长时，性能问题比较严重。
责任链模式使用场景
就像开始的例子那样，假如使用if…else…语句来组织一个责任链时感到力不从心，代码看上去很糟糕时，就可以使用责任链模式来进行重构。
总结
责任链模式其实就是一个灵活版的if…else…语句，它就是将这些判定条件的语句放到了各个处理类中，这样做的优点是比较灵活了，但同样也带来了风险，比如设置处理类前后关系时，一定要特别仔细，搞对处理类前后逻辑的条件判断关系，并且注意不要在链中出现循环引用的问题。