java设计模式-行为型模式-责任链模式

责任链模式

责任链模式，发送者发送请求给接收者，接收者是一个链，一个接收者不满足条件的话，把请求转发给下一个请求者，接收者拥有下一个接收者的引用。

两个角色

• 请求者
• 接收者

例子：有一笔大额订单需要领导审批

共有三级领导，一级领导处理1万元以下的订单，二级领导处理1万-2万元的订单，三级领导处理2万以上的订单

• 定义一个订单类（Order）

public class Order {

    private Integer amount;

    public Integer getAmount() {
        return amount;
    }

    public void setAmount(Integer amount) {
        this.amount = amount;
    }

    public Order(Integer amount) {
        this.amount = amount;
    }
}

• 定义一个抽象角色类（AbstractRole）

这个抽象角色类中设置了下一个处理请求角色的引用，定义了处理请求的抽象方法

public abstract class AbstractRole {

    public static final Integer ORDER_AMOUNT_LEVEL_ONE = 10000;
    public static final Integer ORDER_AMOUNT_LEVEL_TWO = 20000;

    AbstractRole nextRole;

    public void setNextRole(AbstractRole nextRole) {
        this.nextRole = nextRole;
    }

    protected abstract void approve(Order order);
}

• 定义三个级别的领导类

public class LeaderLevelOne extends AbstractRole {

    @Override
    protected void approve(Order order) {
        if (order.getAmount() < ORDER_AMOUNT_LEVEL_ONE) {
            System.out.println("我是一级领导，我来处理这批订单，订单金额是：" + order.getAmount());
        } else {
            System.out.println("我是一级领导，订单金额过大，交给上级领导处理");
            nextRole.approve(order);
        }
    }
}

public class LeaderLevelTwo extends AbstractRole {

    @Override
    protected void approve(Order order) {
        if (order.getAmount() < ORDER_AMOUNT_LEVEL_TWO) {
            System.out.println("我是二级领导，我来处理这批订单，订单金额是：" + order.getAmount());
        } else {
            System.out.println("我是二级领导，订单金额过大，交给上级领导处理");
            nextRole.approve(order);
        }
    }
}

public class LeaderLevelThree extends AbstractRole {

    @Override
    protected void approve(Order order) {
        System.out.println("我是三级领导，我来处理这批订单，订单金额是：" + order.getAmount());
    }
}

• 模拟具体场景

设置一级领导的下一个处理角色为二级领导，二级领导的下一个处理角色为三级领导

public class Main {
    public static void main(String[] args) {
        Order order = new Order(28000);

        AbstractRole one = new LeaderLevelOne();
        AbstractRole two = new LeaderLevelTwo();
        AbstractRole three = new LeaderLevelThree();

        one.setNextRole(two);
        two.setNextRole(three);
        
        one.approve(order);
    }
}

• 结果如下

我是一级领导，订单金额过大，交给上级领导处理
我是二级领导，订单金额过大，交给上级领导处理
我是三级领导，我来处理这批订单，订单金额是：28000

总结

优点：实现了请求者个接收者之间的解耦，请求者不需要知道具体接收者是谁
缺点：如果需要在两个现有角色之间增加新的角色，需要修改现有代码，不符合开闭原则

补充

上面的例子是单纯的责任链模式，还有不单纯的责任链模式，当前角色先处理了本次请求，再交给下一个角色继续处理。比如说订单需要多级领导都要审批通过，下一个领导在看到了上一个领导的审批后，才会签字审批。

回到主目录