设计模式：责任链模式原理学习

学习内容整理记录，如有错误感谢指正，互相交流，共同进步

责任链模式介绍

优点：
1. 低耦合，责任处理者继承于抽象类而不是具体类，客户端不需要知道责任链上的处理者是谁
2. aop思想，如filter，当业务变更时，不需要修改业务对象，只需修改责任链成员或成员方法实现
缺点：
1. 需要遍历整条责任链，耗时增加
2. 责任链中责任对象非完全使用，内存使用增加

责任链应用

异常Exception处理
过滤器Filter处理 chain.doFilter
spring security

责任链-链表方式

创建折扣审批责任链，客户申请一个折扣，根据不同折扣大小，分别由sales、manager、leader去审批处理
1. 先创建责任处理者抽象类：PriceHandler 其继承子类分别是 Sales、Manager、Leader
2. 抽象类中定义successor，和successor的设置方法，类似链表，用于设置下一责任人
3. 抽象类中定义抽象方法execute()，由继承子类实现，为责任者的具体业务方法

关系图介绍：

代码实现：

责任处理者抽象类

public abstract class PriceHandler {
    //下一个责任者
    protected PriceHandler successor;
    //设置下一个责任者的方法
    public void setSuccessor(PriceHandler successor){
        this.successor=successor;
    }
    //本责任者应该执行的抽象方法，由继承子类实现
    public abstract void execute(int discount);
}

责任处理者—具体继承子类

class Leader extends PriceHandler {
    @Override
    public void execute(int discount) {
        if(discount>5){
            System.out.println("handle by leader");
        }else {
            //无下一责任人
            System.out.println("refuse by leader");
        }
    }
}

class Manager extends PriceHandler {
    @Override
    public void execute(int discount) {
        if(discount>7){
            System.out.println("handle by manager");
        }else {
            successor.execute(discount);
        }
    }
}

class Sales extends PriceHandler {
    @Override
    public void execute(int discount) {
        if(discount>8){
            //sales处理折扣
            System.out.println("handle by sales");
        }else {
            //sales无法处理，交由下一责任人
            successor.execute(discount);
        }
    }
}

创建客户对象，折扣发起者

public class Customer {

    //设置折扣处理对象，面向抽象类，低耦合，不需要具体实现类
    private PriceHandler priceHandler;

    public void setPriceHandler(PriceHandler priceHandler) {
        this.priceHandler = priceHandler;
    }
    //发起折扣申请方法
    public void requestDiscount(int discount){
        //责任对象处理折扣
        priceHandler.execute(discount);
    }
}

客户端调用测试

public static void main(String[] args){
    Customer customer=new Customer();
    //创建责任链条，设置责任者之间的链路关系
    PriceHandler sales=new Sales();
    PriceHandler manager=new Manager();
    PriceHandler leader=new Leader();
    sales.setSuccessor(manager);
    manager.setSuccessor(leader);
    //由责任链的首位责任人处理折扣
    customer.setPriceHandler(sales);
    customer.requestDiscount(6);
}

引入工厂模式（可以继续优化，完善工厂的灵活性）

public class PriceHandlerFactory {
    //工厂模式，创建priceHandler责任链
    public static PriceHandler createPriceHandler(){
        PriceHandler sales=new Sales();
        PriceHandler manager=new Manager();
        PriceHandler leader=new Leader();
        sales.setSuccessor(manager);
        manager.setSuccessor(leader);
        return sales;
    }
}
public static void main(String[] args){
    //客户端调用测试
    Customer customer=new Customer();
    customer.setPriceHandler(PriceHandlerFactory.createPriceHandler());
    customer.requestDiscount(6);
}

执行结果

handle by leader

责任链-迭代器方式，链表方式的另一种实现

创建一个迭代器DiscountHandlerChain，折扣审批责任链
创建DiscountHandler 与上述 priceHandler类似

代码实现：

这里的重点是，责任者处理完自身业务后需要执行责任链的process()方法，进行下一责任人的转移，类似filter的chain.doFilter，然后由责任链管理对象DiscountHandlerChain去进行责任人的迭代调用

public class DiscountHandlerChain {
    private int index=0;
    private List<DiscountHandler> discountHandlers;

    public DiscountHandlerChain(List<DiscountHandler> discountHandlers) {
        this.discountHandlers = discountHandlers;
    }
    public void process(int discount){
        if(index>=discountHandlers.size()){
            //责任链执行完毕
            return;
        }else {
            DiscountHandler discountHandler=discountHandlers.get(index);
            index=index+1;
            discountHandler.execute(this,discount);
        }
    }
}

//单责任链方式，当有责任人执行则退出责任链，非单责任链，不需要关注责任者的执行情况 因此handleProcess可设置为void
public abstract class DiscountHandler {
    //放入需要执行的业务方法
    protected abstract boolean handleProcess(int discount);

    //责任链运行所需的递归调用方法
    public void execute(DiscountHandlerChain chain,int discount){
        //单责任模式：判断责任者是否执行，若执行则跳出责任链，
        if(handleProcess(discount)){
            return ;
        }else {
            chain.process(discount);
        }
        //非单责任模式
//        handleProcess(discount);
//        chain.process(discount);
    }
}

责任者继承子类

class Sales extends DiscountHandler{
    @Override
    protected boolean handleProcess(int discount) {
        if(discount>9){
            System.out.println("sales处理了");
            return true;
        }else {
            return false;
        }
    }
}

class Manager extends DiscountHandler{
    @Override
    protected boolean handleProcess(int discount) {
        if(discount>7){
            System.out.println("manager处理了");
            return true;
        }else {
            return false;
        }
    }
}

class Leader extends DiscountHandler{
    @Override
    protected boolean handleProcess(int discount) {
        if(discount>5){
            System.out.println("leader处理了");
            return true;
        }else {
            System.out.println("leader拒绝了");
            return true;
        }
    }
}

调用测试

public static void main(String[] args){
    Sales sales=new Sales();
    Manager manager=new Manager();
    Leader leader=new Leader();
    List<DiscountHandler> discountHandlers=new ArrayList<>();
    discountHandlers.add(sales);
    discountHandlers.add(manager);
    discountHandlers.add(leader);
    DiscountHandlerChain chain=new DiscountHandlerChain(discountHandlers);
    chain.process(8);
}

执行结果：

manager处理了

原文链接：https://blog.csdn.net/qq_41066277/article/details/121852710

责任链模式介绍

责任链应用

责任链-链表方式

关系图介绍：

代码实现：

责任链-迭代器方式，链表方式的另一种实现

你可能也喜欢