责任链模式China of Responsibility

职责链模式：使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系，使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

例如：在大学里面当班干部，时常要向上级申请各方面的东西。譬如申请全班外出秋游，普通同学将申请表交给班长，班长签字之后交给辅导员，辅导员批准之后上交到主任办公室…就是这样，一个请求（这里是一份申请表）有时候需要经过好几个级别的处理者（这里是辅导员、主任）的审查才能够最终被确定可行与否。即不同的处理者对同一个请求可能担负着不同的处理方式、权限，但是我们希望这个请求必须到达最终拍板的处理者（否则秋游就没戏了）。这种关系就很适合使用职责链模式了。

适用场景：

1、有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定；

2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求；

3、处理一个请求的对象集合应被动态指定。

职责链模式的优缺点：

1.当客户提交一个请求时，请求是沿链传递直至有一个ConcreteHandler对象负责处理它。

2.接收者和发送者都没有对方的明确信息，且链中的对象自己也并不知道链的结构。结果是职责链可简化对象的相互连接，它们仅需保持一个指向其后续者的引用，而不需保持它所有的候选接受者的引用。

3.可随时地增加或修改处理一个请求的结构。增加了给对象指派职责的灵活性。

4.需事先考虑全面，一个请求极有可能到了链的末端都得不到处理，或者因为没有正确配置而得不到处理。

package com.qinsoft.design;

/**
 * 职责链模式:行为型
 */
public class ChainOfResponsibility {
    public static void main(String[] args) 
    {
        // 创建指责链的所有节点
        AbstractHandler handler01 = new Handler01();
        AbstractHandler handler02 = new Handler02();

        // 进行链的组装，即头尾相连，一层套一层
        handler01.setNextHandler(handler02);

        // 创建请求并提交到指责链中进行处理
        AbstractRequest request01 = new Request01("请求-01");
        AbstractRequest request02 = new Request02("请求-02");

        // 每次提交都是从链头开始遍历
        handler01.handleRequest(request01);
        handler01.handleRequest(request02);
    }
}

interface Levels
{
    public static final int LEVEL_01 = 1;
    public static final int LEVEL_02 = 2;
}

// 抽象请求类
abstract class AbstractRequest {
    private String content = null;

    public AbstractRequest(String content)
    {
        this.content = content;
    }

    public String getContent() 
    {
        return this.content;
    }

    // 获得请求的级别
    public abstract int getRequestLevel();
}

// 具体请求类01
class Request01 extends AbstractRequest {
    public Request01(String content) {
        super(content);
    }

    @Override
    public int getRequestLevel() {
        return Levels.LEVEL_01;
    }
}

//具体请求类02
class Request02 extends AbstractRequest {
    public Request02(String content) {
        super(content);
    }

    @Override
    public int getRequestLevel() {
        return Levels.LEVEL_02;
    }
}

// 抽象处理者类，
abstract class AbstractHandler {
    // 责任链的下一个节点，即处理者
    private AbstractHandler nextHandler = null;

    // 捕获具体请求并进行处理，或是将请求传递到责任链的下一级别
    public final void handleRequest(AbstractRequest request) {

        // 若该请求与当前处理者的级别层次相对应，则由自己进行处理
        if (this.getHandlerLevel() == request.getRequestLevel()) {
            this.handle(request);
        } else {
            // 当前处理者不能胜任，则传递至职责链的下一节点
            if (this.nextHandler != null) {
                System.out.println("当前 处理者-0" + this.getHandlerLevel()+ " 不足以处理 请求-0" + request.getRequestLevel());
                // 这里使用了递归调用
                this.nextHandler.handleRequest(request);
            } else {
                System.out.println("职责链上的所有处理者都不能胜任该请求...");
            }
        }
    }

    // 设置责任链中的下一个处理者
    public void setNextHandler(AbstractHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    // 获取当前处理者的级别
    protected abstract int getHandlerLevel();

    // 定义链中每个处理者具体的处理方式
    protected abstract void handle(AbstractRequest request);
}

// 具体处理者-01
class Handler01 extends AbstractHandler {
    @Override
    protected int getHandlerLevel() {
        return Levels.LEVEL_01;
    }

    @Override
    protected void handle(AbstractRequest request) {
        System.out.println("处理者-01 处理 " + request.getContent() + "\n");
    }
}

// 具体处理者-02
class Handler02 extends AbstractHandler {
    @Override
    protected int getHandlerLevel() {
        return Levels.LEVEL_02;
    }

    @Override
    protected void handle(AbstractRequest request) {
        System.out.println("处理者-02 处理 " + request.getContent() + "\n");
    }
}