设计模式-责任链模式

Posted on | In
Words count in article: 790 | Reading time ≈ 3

责任链模式

定义

顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。

在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

类图

责任链模式类图

Handler

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

ConcreteHandler

是处理具体请求的角色。

Client

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

示例

类图

责任链模式示例类图

Trouble

1
2
3
4
5
6
7
8
9
10
11
12
public class Trouble {
    private int number;             
    public Trouble(int number) {    
        this.number = number;
    }
    public int getNumber() {        
        return number;
    }
    public String toString() {      
        return "[Trouble " + number + "]";
    }
}

LimitSupport

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class LimitSupport extends Support {
    private int 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;
        }
    }
}

NoSupport

1
2
3
4
5
6
7
8
9
public class NoSupport extends Support {
    public NoSupport(String name) {
        super(name);
    }
    protected boolean resolve(Trouble trouble) {     
        return false; 
    }
}

OddSupport

1
2
3
4
5
6
7
8
9
10
11
12
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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;
        }
    }
}

Support

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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 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.");
    }
}

Main

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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));
        }
    }
}

总结

责任链模式最大的优点在于它弱化了发出请求的人和处理请求的人之间的关系。Client角色向第一个ConcreteHandler发出请求，然后请求会在责任链中传播，知道某个ConcreteHandler处理该请求。

如果不使用该模式，就必须由某个伟大的角色知道“谁应该处理什么请求”，这有点类似中央集权制。而让“发出请求的人”知道“谁应该处理该请求”并不明智，因为如果发出请求的人不得不知道处理请求的人各自的责任分担情况，就会降低其作为可复用组件的独立性。

使用责任链模式可以根据情况动态地重组组织链。

0%