设计模式之职责链模式

模式定义

职责链模式，也叫责任链模式或者责任连锁模式。 避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止，这就是职责链模式，也叫责任链模式或者责任连锁模式。

​ 在职责链模式中最关键的一点就是客户提交请求后，请求沿着链往下传递直到有一个处理者处理它，在这里客户无需关心它的请求是哪个处理者来处理，反正总有一个处理者会处理它的请求。

​ 在这里客户端和处理者都没有对方明确的信息，同时处理者也不知道职责链中的结构。所以职责链可以简化对象的相互连接，他们只需要保存一个指向其后续者的引用，而不需要保存所有候选者的引用。

​ 在职责链模式中我们可以随时随地的增加或者更改一个处理者，甚至可以更改处理者的顺序，增加了系统的灵活性。处理灵活性是增加了，但是有时候可能会导致一个请求无论如何也得不到处理，它会被放置在链末端，这个既是职责链的优点也是缺点。

模式结构

​ 下图是职责链模式的UML结构图：

 

​ 从上面可以看出职责链包含三个角色：

​ Handler: 抽象处理者。定义了一个处理请求的方法。所有的处理者都必须实现该抽象类。 ConcreteHandler: 具体处理者。处理它所负责的请求，同时也可以访问它的后继者。如果它能够处理该请求则处理，否则将请求传递到它的后继者。 Client: 客户类。

​ 下面是最典型的具体处理者类。

public class ConcreteHandler extends Handler
{
    public void handleRequest(String request)
    {
        if(请求request满足条件)
        {
            ......  //处理请求；
        }
        else
        {
            this.successor.handleRequest(request); //转发请求
        }
    }
}

要职责链模式需满足

1、需要将某任务的所有职责执行对象以链的形式加以组织。

2、将消息或请求按照对象链传递，让处于对象链中的对象得到处理机会。

3、处于对象链中的对象，不同的对象执行不同的职责

4、处于对象链的末尾的对象结束任务并停止消息或请求继续传递。

比如客户想要完成一个任务，这个任务包括a,b,c三部分

首先客户把任务交给A去完成a部分，A完成后才能B去完成b部分直到C完成c部分

我们拿组装汽车举例：先安装车头，然后安装车身，最后安装车尾。

处理器的抽象类

/**
 * 职责：Handler 职责类的抽象父类
 */
public abstract class AbstractCarHandler {

    AbstractCarHandler carHandler = null;

    public abstract void carHandler();

    public AbstractCarHandler setNextCarHandler(AbstractCarHandler nextCarHandler){
        this.carHandler = nextCarHandler;
        return this.carHandler;
    }

    /**职责下传*/
    protected void doChain(){
        if(this.carHandler != null){
            this.carHandler.carHandler();
        }
    }
}

责任链一个执行者处理车头

 

/**
 * 职责：concreteHandler 具体的处理类
 */
public class CarHeadHandler extends AbstractCarHandler {
    @Override
    public void carHandler() {
        System.out.println("处理车的head！");

        //下传
        this.doChain();
    }
}

责任链一个执行者处理车身

/**
 * 职责：concreteHandler 具体的处理类
 */
public class CarBodyHandler extends AbstractCarHandler {
    @Override
    public void carHandler() {
        System.out.println("处理车的body！");

        //下传
        this.doChain();
    }
}

责任链一个执行者处理车尾

/**
 * 职责：concreteHandler 具体的处理类
 */
public class CarTailHandler extends AbstractCarHandler {
    @Override
    public void carHandler() {
        System.out.println("处理车的tail！");

        //下传
        this.doChain();
    }
}

 

    public static void main(String[] args) {
        AbstractCarHandler carheadHandle = new CarHeadHandler();
        AbstractCarHandler carbodyHandle = new CarBodyHandler();
        AbstractCarHandler carTailHandler = new CarTailHandler();

        //组装责任链
        carheadHandle.setNextCarHandler(carbodyHandle).setNextCarHandler(carTailHandler);

        //链头部开始执行
        carheadHandle.carHandler();
    }

运行结果：

处理车的head！

处理车的body！

处理车的tail！  

比如你要请假，根据请假的天数不同，不同的领导进行审批。

休假请求类

public class LeaveRequest // 休假请求
{
    private String leaveName; // 休假人
    private int leaveDays; // 休假天数

    public LeaveRequest(String leaveName,int leaveDays)
    {
        this.leaveName=leaveName;
        this.leaveDays=leaveDays;
    }

    public void setLeaveName(String leaveName) {
        this.leaveName = leaveName;
    }

    public void setLeaveDays(int leaveDays) {
        this.leaveDays = leaveDays;
    }

    public String getLeaveName() {
        return (this.leaveName);
    }

    public int getLeaveDays() {
        return (this.leaveDays);
    }
}

2.抽象处理类

public abstract class Leader // 抽象处理者
{
    protected String name;
    protected Leader successor;
    public Leader(String name)
    {
        this.name=name;
    }
    public void setSuccessor(Leader successor) 
    { // 设置下一个处理者
        this.successor=successor;
    }
    public abstract void handleRequest(LeaveRequest request); // 处理请求
}

3.主任 审批小于三天

public class Director extends Leader // 主任
{
    public Director(String name)
    {
        super(name);
    }
    public void handleRequest(LeaveRequest request)
    {
        if(request.getLeaveDays()