Java设计模式之--责任链模式（Chain of Responsibility）

概念：

责任链模式是一种对象的行为模式。在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任，对系统进行动态的调整。

类关系图：

先定义Handler 接口：

public interface Handler {
    public boolean approve(double price);
    public Handler setHnadler(Handler handler);
}

定义抽象类：核心思想是Abstracthandler类提供了get和set方法，方便子类设置和修改引用对象，MyHandle类是核心，实例化后生成一系列相互持有的对象，构成一条链。

public abstract class AbstractHandler implements Handler {

    private Handler handler;
    public Handler getHandler() {
        return handler;
    }

    public Handler setHandler(Handler handler) {
        this.handler = handler;
        return this;
    }

}

实现类：实现方法approve当满足某些条件时，进行处理，停止传递，否则传递下去。

public class ManagerHandler extends AbstractHandler{

    private String name;
    private double power = 0;
    private boolean ishappy =true;

    public void setIshappy(boolean ishappy) {
        this.ishappy = ishappy;
    }


    public ManagerHandler(String name, double power) {
        this.name = name;
        this.power = power;
    }

    @Override
    public boolean approve(double price) {
        if(!ishappy){
            System.out.println(String.format("%s：审批驳回！我今天不开心！回去上班！", name));
            return false;
        }
        if (power >= price) {
            System.out.println(String.format("%s：审批通过！%s 在我的权限内，我的权限有%s.", name,  price,power));
            return true;
        } else {
            if (null != getHandler()) {
                System.out.println(String.format("%s：%s 超过我的权限，我的权限只有%s.将请示上级领导",name, price, power));
                return getHandler().approve(price);
            } else {
                System.out.println(String.format("%s：审批驳回！%s 超过公司最高支出权限，最高支出权限只有%s.没有上一级领导！",name, price, power));
                return false;
            }
        }
    }

    @Override
    public Handler setHnadler(Handler handler) {
        return super.setHandler(handler);
    }

}

测试类：

public class WorkClass {
    public void test() {
        ManagerHandler abstractHandlerTeam = new ManagerHandler("Team Leader", 500.0);
        ManagerHandler abstractHandlerCase = new ManagerHandler("Case Leader", 1000.0);
        ManagerHandler abstractHandlerDepatment = new ManagerHandler("Depatment Leader", 2000.0);
        ManagerHandler abstractHandlerCompany = new ManagerHandler("Company Leader", 5000.0);

        abstractHandlerTeam.setHandler(
                abstractHandlerCase.setHandler(
                        abstractHandlerDepatment.setHandler(
                                abstractHandlerCompany)
                )
        );

        abstractHandlerTeam.approve(500.0);
        abstractHandlerTeam.approve(800.0);
        abstractHandlerTeam.approve(1500.0);
        abstractHandlerTeam.approve(5000.0);
        abstractHandlerTeam.approve(10000.0);

        abstractHandlerDepatment.setIshappy(false);
        abstractHandlerTeam.approve(1500.0);

    }
}

本案例模拟的是公司支出审批流程，每一级负责人都有自己的审批额度，如果超过其额度，将审批向上一级递交。

测试结果：

Team Leader：审批通过！500.0 在我的权限内，我的权限有500.0.


Team Leader：800.0 超过我的权限，我的权限只有500.0.将请示上级领导
Case Leader：审批通过！800.0 在我的权限内，我的权限有1000.0.


Team Leader：1500.0 超过我的权限，我的权限只有500.0.将请示上级领导
Case Leader：1500.0 超过我的权限，我的权限只有1000.0.将请示上级领导
Depatment Leader：审批通过！1500.0 在我的权限内，我的权限有2000.0.


Team Leader：5000.0 超过我的权限，我的权限只有500.0.将请示上级领导
Case Leader：5000.0 超过我的权限，我的权限只有1000.0.将请示上级领导
Depatment Leader：5000.0 超过我的权限，我的权限只有2000.0.将请示上级领导
Company Leader：审批通过！5000.0 在我的权限内，我的权限有5000.0.


Team Leader：10000.0 超过我的权限，我的权限只有500.0.将请示上级领导
Case Leader：10000.0 超过我的权限，我的权限只有1000.0.将请示上级领导
Depatment Leader：10000.0 超过我的权限，我的权限只有2000.0.将请示上级领导
Company Leader：审批驳回！10000.0 超过公司最高支出权限，最高支出权限只有5000.0.没有上一级领导！




Team Leader：1500.0 超过我的权限，我的权限只有500.0.将请示上级领导
Case Leader：1500.0 超过我的权限，我的权限只有1000.0.将请示上级领导
Depatment Leader：审批驳回！我今天不开心！回去上班！.

结语：

链接上的请求可以是一条链，可以是一个树，还可以是一个环，模式本身不约束这个，具体看个人怎么实现，但是，在一个时刻，请求只允许由一个对象传给另一个对象，而不允许传给多个对象。