【java学习笔记】设计模式14——Chain of Responsibility （责任链）模式

该文章是阅读《图解设计模式》的学习笔记。书本链接https://www.ituring.com.cn/book/1811

现实生活中，假如要去医院看病，首先要去挂号窗口挂号，然后再去某个科室看病，结果该病可能能够治疗，也有可能无法治疗。这个过程就形成了一条职责链，每个窗口负责各自职责处理对应的请求。而在程序设计中，将过个对象组成一条职责链，然后按照他们在职责链上的顺序一个一个地找出应该谁来负责处理该当前请求。

Trouble类代码：

package com.wen.ChainOfResponsibility;

public class Trouble {
    private int number;

    public Trouble(int number) {
        this.number = number;
    }

    public int getNumber() {
        return number;
    }

    @Override
    public String toString() {
        return "问题{" +
                number +
                '}';
    }
}

Support抽象类代码：

package com.wen.ChainOfResponsibility;

public abstract class Support {
    private String name;
    private Support next;

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

    public Support setNext(Support next) {
        this.next = next;
        return next;
    }

    protected abstract boolean resolve(Trouble trouble);

    protected void done(Trouble trouble){
        System.out.println(trouble +"被"+this+"解决了");
    }

    protected void fail(Trouble trouble){
        System.out.println(trouble +"没有解决");
    }


    public final void support(Trouble trouble){
        if(resolve(trouble)){
            done(trouble);
        }else if(next!=null){
            next.support(trouble);
        }else {
            fail(trouble);
        }
    }


    @Override
    public String toString() {
        return "{" +
                name +
                '}';
    }
}

NoSupport类代码：

package com.wen.ChainOfResponsibility;

public class NoSupport extends Support {
    public NoSupport(String name) {
        super(name);
    }
    protected boolean resolve(Trouble trouble) {     // 解决问题的方法
        return false; // 自己什么也不处理
    }
}

LimitSupport类代码：

package com.wen.ChainOfResponsibility;

public class LimitSupport extends Support {
    private int limit;                              // 可以解决编号小于limit的问题
    public LimitSupport(String name, int limit) {   // 构造函数
        super(name);
        this.limit = limit;
    }
    protected boolean resolve(Trouble trouble) {    // 解决问题的方法
        if (trouble.getNumber() < limit) {
            return true;
        } else {
            return false;
        }
    }
}

OddSupport类代码：

package com.wen.ChainOfResponsibility;

public class OddSupport extends Support {
    public OddSupport(String name) {                // 构造函数
        super(name);
    }
    protected boolean resolve(Trouble trouble) {    // 解决问题的方法
        if (trouble.getNumber() % 2 == 1) {
            return true;
        } else {
            return false;
        }
    }
}

SpecialSupport类代码：

package com.wen.ChainOfResponsibility;

public class SpecialSupport extends Support {
    private int number;                                 // 只能解决指定编号的问题
    public SpecialSupport(String name, int number) {    // 构造函数
        super(name);
        this.number = number;
    }
    protected boolean resolve(Trouble trouble) {        // 解决问题的方法
        if (trouble.getNumber() == number) {
            return true;
        } else {
            return false;
        }
    }
}

Main入口类代码：

package com.wen.ChainOfResponsibility;

public class Main {
    public static void main(String[] args) {
        Support one   = new NoSupport("第一部门");
        Support two     = new LimitSupport("第二部门", 100);
        Support three = new SpecialSupport("第三部门", 429);
        Support four   = new LimitSupport("第四部门", 200);
        Support five    = new OddSupport("第五部门");
        Support six    = new LimitSupport("第六部门", 300);
        // 形成职责链
        one.setNext(two).setNext(three).setNext(four).setNext(five).setNext(six);
        // 制造各种问题
        for (int i = 0; i < 500; i += 33) {
            one.support(new Trouble(i));
        }
    }
}

 

 

模式中的角色： 

 Handler（处理者）：定义了处理请求的接口，该角色知道下一个处理者是谁，自己无法处理的请求会给下一个处理者进行处理。如上面代码中的Support类。

ConcreteHandler（具体的处理者）：处理具体请求的具体角色，实现Handler定义的处理方法，如上面代码中的NoSupport、LimitSupport、OddSupport、以及SpecialSupport这四个类。

Client（请求者）：该角色向第一个ConcreteHandler角色发送请求，如上面代码中的Main程序入口类。