行为设计模式 -责任链模式- JAVA

news2024/10/27 10:39:58

责任链设计模式

- 一 .简介
- 二. 案例
- - 2.1 抽象处理者(Handler)角色
  - 2.2 具体处理者(ConcreteHandler)角色
  - 2.3 测试
- 三. 结论
- - 3.1 优缺点
  - 3.2 示例
  - 3.3 要点

前言
这是我在这个网站整理的笔记,有错误的地方请指出，关注我，接下来还会持续更新。

作者：神的孩子都在歌唱

一 .简介

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

个人理解： 通过责任链方式可以找到能够处理客户端请求的对象。感觉就跟Switch 或者try-catch 一样，当前不匹配就继续往下匹配。

责任链模式涉及到的角色如下所示：

●　**抽象处理者(Handler)角色：**定义出一个处理请求的接口。如果需要，接口可以定义出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。Handler类的聚合关系给出了具体子类对下家的引用，抽象方法handleRequest()规范了子类处理请求的操作。

●　**具体处理者(ConcreteHandler)角色：**具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。

二. 案例

网上看了很多案例，感觉ATM取款机这个案例最容易理解。需求是让用户输入一个金额数（amount），然后ATM机会将输入的金额数从大到小（能够分配的纸币类型是100元 20 元 10元）进行分配。如果用户输入的金额不是10的倍数，就抛出错误。

其实这个实现起来很简单，不过为了将每种类型的纸币进行解耦，所以需要使用责任链方式去解决

2.1 抽象处理者(Handler)角色

定义分配的处理链接口

/**
 * @author chenyunzhi
 * @date 2024/6/4 16:27
 * @Description 分配的处理链接口
 */
public interface DispenseChain {

    /**
     * 要执行的下一个链（对象）
     */
    void setNextChain(DispenseChain nextChain);


    /**
     * 执行分配的方法
     */
    void dispense(Integer amount);
}

2.2 具体处理者(ConcreteHandler)角色

定义每种纸币的对象

Yuan100Dispenser

/**
 * @author chenyunzhi
 * @date 2024/6/4 16:30
 * @Description
 */
public class Yuan100Dispenser implements DispenseChain{

    private DispenseChain dispenseChain;
    @Override
    public void setNextChain(DispenseChain nextChain) {
        this.dispenseChain = nextChain;
    }

    @Override
    public void dispense(Integer amount) {
        if (amount >= 100) {
            int num = amount / 100;
            int remainder = amount % 100;
            System.out.println("分配了" + num + "张100元");
            // 进入下一个分配
            if (remainder != 0) {
                this.dispenseChain.dispense(remainder);
            }
        } else {
            this.dispenseChain.dispense(amount);
        }
    }
}

Yuan20Dispenser

/**
 * @author chenyunzhi
 * @date 2024/6/4 16:30
 * @Description
 */
public class Yuan20Dispenser implements DispenseChain{

    private DispenseChain dispenseChain;
    @Override
    public void setNextChain(DispenseChain nextChain) {
        this.dispenseChain = nextChain;
    }

    @Override
    public void dispense(Integer amount) {
        if (amount >= 20) {
            int num = amount / 20;
            int remainder = amount % 20;
            System.out.println("分配了" + num + "张20元");
            // 进入下一个分配
            if (remainder != 0) {
                this.dispenseChain.dispense(remainder);
            }
        } else {
            this.dispenseChain.dispense(amount);
        }
    }
}

Yuan10Dispenser

/**
 * @author chenyunzhi
 * @date 2024/6/4 16:30
 * @Description
 */
public class Yuan10Dispenser implements DispenseChain{

    private DispenseChain dispenseChain;
    @Override
    public void setNextChain(DispenseChain nextChain) {
        this.dispenseChain = nextChain;
    }

    @Override
    public void dispense(Integer amount) {
        if (amount >= 10) {
            int num = amount / 10;
            int remainder = amount % 10;
            System.out.println("分配了" + num + "张10元");
            // 进入下一个分配
            if (remainder != 0) {
                this.dispenseChain.dispense(remainder);
            }
        } else {
            this.dispenseChain.dispense(amount);
        }
    }
}

2.3 测试

这一步我们将三种纸币连接起来，创建链进行测试

/**
 * @author chenyunzhi
 * @date 2024/6/4 16:48
 * @Description 测试
 */
public class ChainOfResponsibilityPatternTest {


    private DispenseChain chain;
    /**
     * 初始化atm分配链
     */
    public  ChainOfResponsibilityPatternTest() {
        this.chain = new Yuan100Dispenser();
        Yuan20Dispenser yuan20Dispenser = new Yuan20Dispenser();
        Yuan10Dispenser yuan10Dispenser = new Yuan10Dispenser();

        chain.setNextChain(yuan20Dispenser);
        yuan20Dispenser.setNextChain(yuan10Dispenser);
    }
    public static void main(String[] args) {
        ChainOfResponsibilityPatternTest patternTest = new ChainOfResponsibilityPatternTest();
        for (int i=0; i<3; i++){
            System.out.println("----------输入领取金额-----------");
            Scanner scanner = new Scanner(System.in);
            int amount = scanner.nextInt();
            if (amount % 10 != 0) {
                System.out.println("需要输入10的倍数的金额");
                continue;
            }
            patternTest.chain.dispense(amount);
            System.out.println("----------分配结束-----------");
        }

    }
   
}