设计模式—责任链模式

一、定义

    顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

1.1 解决问题：

    职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。

1.2 优点：

• 1、降低耦合度。它将请求的发送者和接收者解耦。
• 2、简化了对象。使得对象不需要知道链的结构。
• 3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。
• 4、增加新的请求处理类很方便。

1.3 缺点：

• 1、不能保证请求一定被接收。
• 2、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。
• 3、可能不容易观察运行时的特征，有碍于除错。
  责任链模式的最大缺点是对链中责任人的遍历，如果责任人太多那么遍历必定会影响性能，特别是在一些递归调用中，要慎重。

二、例子

    接下来用一个例子来说明责任链设计模式。程序员每次要出差需要出差经费，而经费需要领导审批，各级领导可以审批的金额限度不一致，因此不同的出差经费需要由不同的领导审批：
程序员抽象类：

/**
 * 抽象程序员
 */
public abstract class ProgramApe {
    /**
     * 获取程序员具体的差旅费用
     * @return 具体费用
     */
    public abstract int getExpress();

    /**
     * 获取差旅费申请
     *
     * @return 申请内容
     */
    public abstract String getApply();
}

具体程序员：

/**
 * Android 程序员
 *
 */
public class AndroidApe extends ProgramApe{

    // 声明整型成员变量表示出差费用
    private int express;
    // 声明字符串型成员变量表示差旅申请
    private String apply = "Android - 要钱出差去";

    public AndroidApe(int express) {
        this.express = express;
    }

    @Override
    public int getExpress() {
        return express;
    }

    @Override
    public String getApply() {
        return apply;
    }
}

领导抽象类：

/**
 * 领导-抽象类
 */
public abstract class Leader {
    // 当前领导能批复的金额
    private int mEexpress;
    //上级领导
    private Leader mSuperiorLeader;

    /**
     * 当前领导可审批的金额
     *
     * @param express 审批金额
     */
    public Leader(int express) {
        mEexpress = express;
    }

    /**
     * 回应程序员
     *
     * @param mApe 具体程序员
     */
    protected abstract void reply(ProgramApe mApe);

    /**
     * 设置上级领导
     *
     * @param mSuperiorLeader 具体的上级领导
     */
    public void setSuperiorLeader(Leader mSuperiorLeader) {
        this.mSuperiorLeader = mSuperiorLeader;
    }

    /**
     * 处理请求
     */
    public void handleRequest(ProgramApe mApe) {

        // 如果说程序猿申请的money在当前领导的批复范围内
        if (mApe.getExpress() <= mEexpress) {
            reply(mApe);
        } else {
            // 否则看看当前领导是否有上级
            if (null == mSuperiorLeader) {
                // 没有上级的话就批复不了
                System.out.println("Goodbye my money......");
            } else {
                // 有的话简单撒直接扔给上级处理即可
                mSuperiorLeader.handleRequest(mApe);
            }
        }
    }
}

小组领导：

/**
 * 小组领导
 */
public class GroupLeader extends Leader {


    /**
     * 当前领导可审批的金额
     */
    public GroupLeader() {
        super(1000);
    }

    @Override
    protected void reply(ProgramApe mApe) {
        System.out.println(mApe.getApply());
        System.out.println("GroupLeader: Of course Yes!");
    }
}

项目主管:

/**
 * 项目主管
 */
public class DirectorLeader extends Leader{

    public DirectorLeader() {
        super(2000);
    }

    @Override
    protected void reply(ProgramApe mApe) {
        System.out.println(mApe.getApply());
        System.out.println("DirectorLeader: Of course Yes!");
    }
}

经理：

/**
 * 经理
 */
public class ManagerLeader extends Leader {

    public ManagerLeader() {
        super(3000);
    }

    @Override
    protected void reply(ProgramApe mApe) {
        System.out.println(mApe.getApply());
        System.out.println("DirectorLeader: Of course Yes!");
    }
}

客户端：

public class Client {

    public static void main(String[] args) {
        //程序员经费-3000以内
        int fee = (int) (Math.random() * 3000);
        System.out.println("程序员经费：" + fee);
        ProgramApe programApe = new AndroidApe(fee);

        //设置领导
        Leader mGroupLeader = new GroupLeader();
        Leader mDirectorLeader = new DirectorLeader();
        Leader mManagerLeader = new ManagerLeader();

        //设置上级领导
        mGroupLeader.setSuperiorLeader(mDirectorLeader);
        mDirectorLeader.setSuperiorLeader(mManagerLeader);

        //处理请求
        mGroupLeader.handleRequest(programApe);

    }
}