图解设计模式--Chain of Responsibility(职责链)模式

推卸责任

Chain of Responsibility 模式

将多个对象组成一条职责链，然后按照它们在职责链上的顺序一个一个地找出到底应该谁来负责处理。

使用 Chain of Responsibility 模式可以弱化“请求方”和“处理方”之间的关联关系，让双方各自都成为可以复用的组件。

示例程序

Trouble.java

package chainOfResponsibility;

public class Trouble {
    private int number;
    public Trouble(int number) {
        this.number = number;
    }
    public int getNumber() {
        return number;
    }
    public String toString() {
        return "[Trouble " + number + "]";
    }
}

Support.java

package 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;
    }
    public final void support(Trouble trouble) {
        if (resolve(trouble)) {
            done(trouble);
        } else if (next != null) {
            next.support(trouble);
        } else {
            fail(trouble);
        }
    }
    public String toString() {
        return "[" + name + "]";
    }
    protected abstract boolean resolve(Trouble trouble);
    protected void done(Trouble trouble) {
        System.out.println(trouble + " is resolved by " + this + ".");
    }
    protected void fail(Trouble trouble) {
        System.out.println(trouble + " cannot be resolved.");
    }
}

NoSupport.java

package chainOfResponsibility;

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

LimitSupport.java

package 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.java

package 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;
        }
    }
}

SepcialSupport.java

package 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.java

package chainOfResponsibility;

public class Main {

    public static void main(String[] args) {
        Support alice = new NoSupport("Alice");
        Support bob = new LimitSupport("bob", 100);
        Support charlie = new SpecialSupport("charlie", 429);
        Support diana = new LimitSupport("Diana", 200);
        Support elmo = new OddSupport("Elmo");
        Support fred = new LimitSupport("Fred", 300);
        // 形成职责链
        alice.setNext(bob).setNext(charlie).setNext(diana).setNext(elmo).setNext(fred);
        // 制造各种问题
        for (int i = 0; i < 500; i += 33) {
            alice.support(new Trouble(i));
        }
    }

}

Chain of Responsibility 模式中的角色

1. Handler(处理者)

   Handler 角色定义了处理请求的接口(API)。Handler 角色知道“下一个处理者”是谁，如果自己无法处理请求，它会将请求转给“下一个处理者”。

2. ConcreteHandler(具体的处理者)

   ConcreteHandler 角色是处理请求的具体角色。

3. Client(请求者)

   Client 角色是向第一个 ConcreteHandler 角色发送请求的角色。

拓展思路

一、弱化了发出请求的人和处理请求的人之间的关系。

二、可以动态的改变职责链。

三、专注于自己的工作。

四、推卸请求会导致处理延迟。