《设计模式》15.责任链模式（行为型）

每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

应用场景：

1. 过滤器 Filter
2. 拦截器 Interceptor
3. Tomcat 编解码

处理句柄接口，定义一个handleRequest方法

public interface Handler {
    double handleRequest(double op1, double op2);
}

公共的表达式处理句柄，实现一个表达式计算的功能，实现了handleRequest接口方法，定义抽象方法operate在每个具体操作中实现

public abstract class ExpressionHandler implements Handler {
    private double optNum2;
    private Handler nextHandler;
    public ExpressionHandler(){}

    public ExpressionHandler(double optNum2) {
        this.optNum2 = optNum2;
    }

    public ExpressionHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public ExpressionHandler(double optNum2, Handler nextHandler) {
        this.optNum2 = optNum2;
        this.nextHandler = nextHandler;
    }

    public double getOptNum2() {
        return optNum2;
    }

    public void setOptNum2(double optNum2) {
        this.optNum2 = optNum2;
    }

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    protected abstract double operate(double optNum1, double optNum2);

    @Override
    public double handleRequest(double optNum1, double optNum2) {
        double result = operate(optNum1, optNum2);
        if (nextHandler != null) {
            double nextOptNum2 = ((ExpressionHandler) nextHandler).getOptNum2();
            result = nextHandler.handleRequest(result, nextOptNum2);
        }
        return result;
    }
}

加操作句柄实现

public class AddHandler extends ExpressionHandler {
    public AddHandler() {
        super();
    }

    public AddHandler(double optNum2) {
        super(optNum2);
    }

    public AddHandler(Handler nextHandler) {
        super(nextHandler);
    }

    public AddHandler(double optNum2, Handler nextHandler) {
        super(optNum2, nextHandler);
    }

    @Override
    protected double operate(double optNum1, double optNum2) {
        double result = optNum1 + optNum2;
        System.out.println(optNum1 + " + " + optNum2 + " = " + result);
        return result;
    }
}

减操作句柄实现

public class SubtractHandler extends ExpressionHandler {
    public SubtractHandler() {
        super();
    }

    public SubtractHandler(double optNum2) {
        super(optNum2);
    }

    public SubtractHandler(Handler nextHandler) {
        super(nextHandler);
    }

    public SubtractHandler(double optNum2, Handler nextHandler) {
        super(optNum2, nextHandler);
    }

    @Override
    protected double operate(double optNum1, double optNum2) {
        double result = optNum1 - optNum2;
        System.out.println(optNum1 + " - " + optNum2 + " = " + result);
        return result;
    }
}

乘操作句柄实现

public class MultiplyHandler extends ExpressionHandler {
    public MultiplyHandler() {
        super();
    }

    public MultiplyHandler(double optNum2) {
        super(optNum2);
    }

    public MultiplyHandler(Handler nextHandler) {
        super(nextHandler);
    }

    public MultiplyHandler(double optNum2, Handler nextHandler) {
        super(optNum2, nextHandler);
    }

    @Override
    protected double operate(double optNum1, double optNum2) {
        double result = optNum1 * optNum2;
        System.out.println(optNum1 + " * " + optNum2 + " = " + result);
        return result;
    }
}

除操作句柄实现

public class DivideHandler extends ExpressionHandler {
    public DivideHandler() {
        super();
    }

    public DivideHandler(double optNum2) {
        super(optNum2);
    }

    public DivideHandler(Handler nextHandler) {
        super(nextHandler);
    }

    public DivideHandler(double optNum2, Handler nextHandler) {
        super(optNum2, nextHandler);
    }

    @Override
    protected double operate(double optNum1, double optNum2) {
        double result = optNum1 / optNum2;
        System.out.println(optNum1 + " / " + optNum2 + " = " + result);
        return result;
    }
}

测试类

public class ResponsibilityChainTester {
    public static void main(String args[]) {
        //((10+8)*2-3)/4=8.25
        Handler divide = new DivideHandler(4);
        ExpressionHandler subtract = new SubtractHandler();
        subtract.setOptNum2(3);
        subtract.setNextHandler(divide);
        Handler multiply = new MultiplyHandler(2, subtract);
        Handler add = new AddHandler(multiply);

        double result = add.handleRequest(10, 8);
        System.out.println("((10+8)*2-3)/4=" + result);
    }
}

10.0 + 8.0 = 18.0
18.0 * 2.0 = 36.0
36.0 - 3.0 = 33.0
33.0 / 4.0 = 8.25
((10+8)*2-3)/4=8.25

补充：
日志责任链的处理实现，需要根据具体的日志级别判定当前句柄是否处理：

   public void handleRequest(int level, String message){
      if(this.level <= level){
         output(message);
      }
      
      if(nextHandler !=null){
         nextHandler.handleRequest(level, message);
      }
   }