责任链模式

概念

责任链模式（Chain of Responsibility Pattern）是一种常见的行为模式，它的目的是使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系。

将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

责任链模式的重点是在“链”上，由一条链去处理相似的请求，在链中决定谁来处理这个请求，并返回相应的结果。

责任链模式的类图如下图所示：

责任链模式涉及以下两个角色：

代码案例：

定义抽象处理者（Handler）角色类：

package com.shixun.design.responsibility;

abstract class Handler {
    private Handler successor;

    public abstract void handleRequest();

    public Handler getSuccessor() {
        return successor;
    }

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

定义具体处理者（Concrete Handler）角色类：

package com.shixun.design.responsibility;

public class ConcreteHandler extends Handler {

    // 处理请求
    @Override
    public void handleRequest() {
        if (getSuccessor() != null) {
            System.out.println("请求传递给" + getSuccessor());
            getSuccessor().handleRequest();
        } else {
            System.out.println("请求处理");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

定义测试类：

package com.shixun.design.responsibility;

public class Test {
    public static void main(String[] args) {
        Handler handler = new ConcreteHandler();
        ConcreteHandler concreteHandler = new ConcreteHandler();
        handler.setSuccessor(concreteHandler);
        handler.handleRequest();
    }
}
1
2
3
4
5
6
7
8
9
10

可以看到先传给具体处理者去处理

优缺点

优点

责任链模式的优点如下：

• 责任链模式将请求和处理分开，请求者不知道是谁处理的，处理者可以不用知道请求的全貌。
• 提高系统的灵活性。

缺点

责任链模式的缺点如下：

• 降低程序的性能，每个请求都是从链头遍历到链尾，当链比较长的时候，性能会大幅下降。
• 不易于调试，由于采用了类似递归的方式，调试的时候逻辑比较复杂。

应用场景

责任链模式的应用场景如下：

• 一个请求需要一系列的处理工作，例如：err多级处理链
• 业务流的处理，例如，文件审批
• 对系统进行补充扩展。

应用案例：多级处理

创建抽象的记录器类，这里相当于抽象处理者（Handler）角色，在这个类里对请求进行抽象，并定义一个方法以设定和返回对下一个处理者的引用。

public abstract class AbstractLogger {
   public static int INFO = 1;
   public static int DEBUG = 2;
   public static int ERROR = 3;
 
   protected int level;
 
   //责任链中的下一个元素
   protected AbstractLogger nextLogger;
 
   public void setNextLogger(AbstractLogger nextLogger){
      this.nextLogger = nextLogger;
   }
 
   public void logMessage(int level, String message){
      if(this.level <= level){
         write(message);
      }
      if(nextLogger !=null){
         nextLogger.logMessage(level, message);
      }
   }
 
   abstract protected void write(String message);
   
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

定义三个级别的具体处理者（Concrete Handler），接到请求后，可以选择将请求处理掉，或者将请求传给下一个处理者。

package com.shixun.design.responsibility.item;

public class ErrorLogger extends AbstractLogger {

    public ErrorLogger(int level){
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("Error Console::Logger: " + message);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

package com.shixun.design.responsibility.item;

public class FileLogger extends AbstractLogger {

    public FileLogger(int level){
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("File::Logger: " + message);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

package com.shixun.design.responsibility.item;

public class ConsoleLogger extends AbstractLogger {

    public ConsoleLogger(int level){
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("Standard Console::Logger: " + message);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

定义测试类：

package com.shixun.design.responsibility.item;

public class Test {
    /**
     * 构建责任链：errorLogger->fileLogger->consoleLogger
     *
     * @return
     */
    private static AbstractLogger getChainOfLoggers() {
        AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
        AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG);
        AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);

        errorLogger.setNextLogger(fileLogger);
        fileLogger.setNextLogger(consoleLogger);

        return errorLogger;
    }

    public static void main(String[] args) {
        AbstractLogger loggerChain = getChainOfLoggers();

        loggerChain.logMessage(AbstractLogger.INFO, "This is an information.");
        System.out.println("===================================================");
        loggerChain.logMessage(AbstractLogger.DEBUG, "This is a debug level information.");
        System.out.println("===================================================");
        loggerChain.logMessage(AbstractLogger.ERROR, "This is an error information.");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

运行结果如下所示：