责任链模式

[Musings]

今天把剩下的几个模式都搞完,开始巩固下多线程

public interface CheckerChain {
    boolean check();
}

public class Order {
    private int price;

    public Order(int price) {
        this.price = price;
    }

    public void submit(){
        FundalmentalChecker fundalmentalChecker = new FundalmentalChecker();
        fundalmentalChecker.check();
    }
}

public class FundalmentalChecker implements CheckerChain{
    @Override
    public boolean check() {
        System.out.println("FundalmentalChecker is checking...");
        /*
        *
        * 加入if else逻辑
        *
        * */
        return new RiskChecker().check();
    }
}

public class RiskChecker implements  CheckerChain{
    @Override
    public boolean check() {
        System.out.println("RiskChecker is checking...");
        /*
         *
         * 加入if else逻辑
         *
         * */
        return new ManualChecker().check();
    }
}

public class ManualChecker implements CheckerChain{
    @Override
    public boolean check() {
        System.out.println("ManualChecker is checking...");
        /*
         *
         * 加入if else逻辑
         *
         * */
        return false;
    }
}

这是我一开始想的版本,就是通过一层层调用来做责任链的检查,在每次检查可以直接返回,也可以根据业务条件向下传递
但这里有个核心问题,就是我的责任链是固定死在代码里的,所以为了动态调整,就得再抽象一下

//先修改接口
public interface CheckerChain {
    boolean check();
    void setNext(Checker checker);
}
//定义抽象类,这样的话就可以在外部设置不同chcker的next checker了
public abstract class Checker implements CheckerChain {
    Checker nextChecker;

    @Override
    public void setNext(Checker checker) {
        this.nextChecker = checker;
    }
}

//实现类稍作修改
public class FundalmentalChecker extends  Checker{
    @Override
    public boolean check() {
        System.out.println("FundalmentalChecker is checking...");
        /*
        *
        * 加入if else逻辑
        *
        * */
        return new RiskChecker().check();
    }
}
//看如何调用
public class Order {
    public void submit() {
        // 构建责任链
        CheckerChain chain = buildChain();
        // 从链头开始执行
        chain.check(this);
    }
    
    //这里就可以在外部手动修改checker的逻辑优先级而不需要动checker类本身,更灵活,解耦
    //在此基础可以后续追加其他模式来优化这块逻辑,单独提取出来,比如工厂模式
    private CheckerChain buildChain() {
        CheckerChain fundamental = new FundalmentalChecker();
        CheckerChain risk = new RiskChecker();
        CheckerChain manual = new ManualChecker();
        
        fundamental.setNext(risk);
        risk.setNext(manual);
        
        return fundamental;  // 返回链头
    }
}

```java 

其实增加新的抽象类,目的就是可以存储nextChecker类,这样外部就可以去改动他,从而不至于把nextChecker hard code在Checker类的逻辑里.