设计模式之项目审批职责链模式

职责链模式

定义： 为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。

实现方式： 在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

包含对象：
Handler：抽象处理者，定义了处理请求所需的接口。

ConcreteHandler（具体处理者）：根据自己的职责实现了处理请求的接口，如果不能处理，那么就把这个请求转给和它保持联系的后继者（即successor）

Client：客户代码，请求的发起者。

UML图：

实力分析： 学校项目审批过程中不同的金额对应的审批人不同，如果传统方式通过if ，else方式实现就会导致多个对象耦合在一起。现选用职责链模式，根据金额层层传递给相应的处理人处理。

实例代码：

具体项目

package responsibilitychain;

public class Item {

    private float money;
    private int id;

    public Item( int id,float money) {
        this.money = money;
        this.id = id;
    }

    public float getMoney() {
        return money;
    }

    public void setMoney(float money) {
        this.money = money;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

抽象处理人以及各个处理人（系主任，院长，校长）

package responsibilitychain;

public abstract class Head {

    Head head;
    //处理项目审批
    abstract void dealItem(Item item);
    //设置下一个审批人
    abstract void setHead(Head head);

}
====================================
package responsibilitychain;

//系主任
public class DepartmentHead extends Head{
    @Override
    void dealItem(Item item) {
        if (item.getMoney()>=0.0f&&item.getMoney()<1000.0f)
            System.out.println("我是系主任，我给你处理了");
        else{
            System.out.println("我是系主任，金额太大找院长给你处理");
            head.dealItem(item);
        }

    }

    @Override
    void setHead(Head head) {
        this.head=head;
    }
}
====================================
package responsibilitychain;

//院长
public class DeanHead extends Head{
    @Override
    void dealItem(Item item) {
        if (item.getMoney()>=1000.0f&&item.getMoney()<2000.0f)
            System.out.println("我是院长，我给你处理了");
        else {
            System.out.println("我是院长，金额太大找校长给你处理");
            head.dealItem(item);
        }

    }

    @Override
    void setHead(Head head) {
        this.head=head;
    }
}
=====================================
package responsibilitychain;

public class HeadMaster extends Head{
    @Override
    void dealItem(Item item) {
        if (item.getMoney()>=2000.0f)
            System.out.println("我是校长，我给你处理了");
        else{
            System.out.println("我是校长，金额太小找系主任");
            head.dealItem(item);
        }

    }

    @Override
    void setHead(Head head) {
        this.head=head;
    }
}

客户端

package responsibilitychain;

public class ResponsibilityChainClint {

    public static void main(String[] args) {
        //创建系主任，院长，校长对象
        DepartmentHead departmentHead = new DepartmentHead();
        DeanHead deanHead = new DeanHead();
        HeadMaster headMaster = new HeadMaster();
        //设置下一级别
        departmentHead.setHead(deanHead);
        deanHead.setHead(headMaster);
        headMaster.setHead(departmentHead);
        //创建项目，并交给系主任处理
        Item item = new Item(1, 1500);
        deanHead.dealItem(item);
        System.out.println("=================");
        //创建项目，并交给校长处理
        Item item2 = new Item(2, 500);
        headMaster.dealItem(item2);


    }
}

运行结果

1，避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。
2，职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。