行为型设计模式

基本介绍

职责链模式（chain of Responsibilities Pattern）允许你将请求沿着处理者链进行发送，处理者收到请求后，可以对请求进行处理，或者将其传递给下一个处理者。

模式结构

Handler（抽象处理者）：定义一个处理请求的接口，并且聚合了一个类型为自身的对象（后继者），子类可以通过设置后继者，将请求传递下去

ConcreteHandler（具体处理者）：具体处理者收到请求后，可以自己将请求处理，或者传给后继者。

Request（请求）：定义一些属性，表示一个请求

举例说明

公司采购审批流程：

• 金额 <= 5000 由组长审批
• 5000 < 金额 <= 10000 由经理审批
• 金额 > 10000 由老板审批

请求，包含 id 和 价格字段

public class PurchaseRequest {
    private int id;
    private float price;

    public PurchaseRequest(int id, float price) {
        this.id = id;
        this.price = price;
    }

    public int getId() {
        return id;
    }

    public float getPrice() {
        return price;
    }
}

抽象处理者

public abstract class Approver {
    protected String name;
    protected Approver approver;

    public Approver(String name) {
        this.name = name;
    }

    public void setApprover(Approver approver) {
        this.approver = approver;
    }

    /**
     * 处理请求
     * @param request
     */
    public abstract void processRequest(PurchaseRequest request);
}

具体处理者

public class TeamLeader extends Approver {

    public TeamLeader(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getPrice() <= 5000) {
            System.out.println(name + "审批了" + request.getId() + "号请求，价格为" + request.getPrice());
        } else {
            approver.processRequest(request);
        }
    }
}

public class Manager extends Approver {

    public Manager(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getPrice() > 5000 && request.getPrice() <= 10000) {
            System.out.println(name + "审批了" + request.getId() + "号请求，价格为" + request.getPrice());
        } else {
            approver.processRequest(request);
        }
    }
}

public class Boss extends Approver {

    public Boss(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getPrice() > 10000) {
            System.out.println(name + "审批了" + request.getId() + "号请求，价格为" + request.getPrice());
        } else {
            approver.processRequest(request);
        }
    }
}

测试类

public class Client {
    @Test
    public void test(){
        PurchaseRequest request = new PurchaseRequest(1, 5000);

        TeamLeader teamLeader = new TeamLeader("李组长");
        Manager manager = new Manager("张经理");
        Boss boss = new Boss("王老板");

        teamLeader.setApprover(manager);
        manager.setApprover(boss);
        boss.setApprover(teamLeader);

        manager.processRequest(request);
        boss.processRequest(request);
    }
}

运行结果

李组长审批了1号请求，价格为5000.0
李组长审批了1号请求，价格为5000.0

模式分析

优点

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

缺点

• 不能保证请求一定被接收
• 系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用
• 可能不容易观察运行时的特征，有碍于除错

适用场景

• 有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定
• 在不明确指定接收者的情况下，向多个对象中的一个提交一个请求
• 可动态指定一组对象处理请求