Design Pattern: Chain of Responsibility 形式

Design Pattern: Chain of Responsibility 模式

其实Chain of Responsibility的概念，即使是一个刚学程式设计的新手也会用到，一个简单的 if...else if ... else 流程控制就有Chain of Responsibility的概念：

if(/* 符合请求条件一 */)
??? // 执行请求一
else if(/* 符合请求条件二 */)
??? // 执行请求二
else
??? // 执行预设请求或显示讯息

?
这是从结构化程式设计的观点来看Chain of Responsibility的概念，若使用物件的观点来看Chain of Responsibility的话，有一个较佳的例子就是Java的例外处理机制，当程式中发生例外时，也比会catch所捕捉的例外是否符合，如果符合就执行所设定的处理，如果都没有比对到适当的例外物件，就会将例外丢出try...catch区块之外。

在 Gof 的书 中给定Chain of Responsibility目的为：使多个物件都有机会处理请求，以避免请求的发送者与接收者之间的耦合关系，将这些物件组合为一个链，并沿着这个链传递该请求，直到有物件处理它为止。

先用一个例子来说明使用if...else的方式来处理请求：

IHandler.java

public interface IHandler {    public void handle(); }  

?

SymbolHandler.java

public class SymbolHandler implements IHandler {     public void handle() {        System.out.println("Symbol has been handled");     } }  

?

CharacterHandler.java

public class CharacterHandler implements IHandler {     public void handle() {        System.out.println("Character has been handled");     } }  

?

NumberHandler.java

public class NumberHandler implements IHandler {     public void handle() {        System.out.println("Number has been handled");     } } 

?

Application.java

import java.io.*; public class Application {    public void run() throws Exception {        System.out.print("Press any key then return: ");        char c = (char) System.in.read();        IHandler handler = null;        if (Character.isLetter(c)) {         handler = new CharacterHandler();        }       else if (Character.isDigit(c)) {          handler = new NumberHandler();        }       else {          handler = new SymbolHandler();        }       handler.handle();    }    public static void main(String[] args)                            throws IOException {          Application app = new Application();          app.run();    } } 

这是一个很简单的程式，可以判定您所输入的是数字、字元或是符号，如果将之以物件的方式来组织物件之间的职责，可以将程式改写如下：

Handler.java

public class Handler {     private Handler successor;    public void setSuccessor(Handler successor) {         this.successor = successor;     }    public Handler getSuccessor() {         return successor;     }    public void handleRequest(char c) {         if(successor != null)             successor.handleRequest(c);     } }  

?

NumberHandler.java

public class NumberHandler extends Handler {     public void handleRequest(char c) {         if(Character.isDigit(c)) {             System.out.println("Number has been handled");         }         else {            getSuccessor().handleRequest(c);         }    } }  

?

CharacterHandler.java

public class CharacterHandler extends Handler {     public void handleRequest(char c) {         if(Character.isLetter(c)) {             System.out.println("Character has been handled");         }         else {            getSuccessor().handleRequest(c);         }    } }  

?

SymbolHandler.java

public class SymbolHandler extends Handler {     public void handleRequest(char c) {         System.out.println("Symbol has been handled");     } }  

?

Application.java

import java.io.*; public class Application {    public static void main(String[] args)                                  throws IOException {         Handler numberHandler = new NumberHandler();         Handler characterHandler = new CharacterHandler();         Handler symbolHandler = new SymbolHandler();         numberHandler.setSuccessor(characterHandler);         characterHandler.setSuccessor(symbolHandler);         System.out.print("Press any key then return: ");         char c = (char)System.in.read();         numberHandler.handleRequest(c);     } } 

在组织物件之间的职责时，通常是从细粒度至粗粒度的方式来组织，从特殊到抽象化，就像程式中将数字视为字元的特殊化，字元又为符号的特殊化。

以上所举的例子在请求上是很简单的，只是比对输入的型态，在更一般的情况下，可以将请求包装为一个物件，并提供getType()之间的方法，以让 Chain of Responsibility中的物件进行比对，例如：

Request.java

public class Request{ 　　private String type;     public Request(String type) { this.type=type; }　　public String getType() { return type; }　　public void execute(){             // 执行请求 　　} } 

在Gof的书中所举的例子为辅助说明系统，在一个介面中希望使用者一定可以得到相关的说明主题，如果子元件有说明的话，就显示相关说明，否则的话就转发给包括它的容器元件或父元件，以保证使用者的辅助说明请求一定可以得到回应。

?

例子--2
1.要处理的对象

package com.ijo.chain.of.responsibility;

public class Trouble {
?private char ch;

?public char getCh() {
??return ch;
?}

?public void setCh(char ch) {
??this.ch = ch;
?}

?public Trouble(char ch) {
??this.ch = ch;
?}

}
进行处理请求的抽象父类

package com.ijo.chain.of.responsibility;

public abstract class Support {
?private Support support;

?public Support addNext(Support support) {
??this.support = support;
??return support;
?}

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

?private void fail(Trouble trouble) {
??System.out.println(" fail " + trouble.getCh());
?}

?private void done(Trouble trouble) {
??System.out.println(" doing " + trouble.getCh());
?}

?protected abstract boolean resolve(Trouble trouble);
}
实现处理请求的子类，字符

package com.ijo.chain.of.responsibility;

public class CharacterSupport extends Support {

?@Override
?protected boolean resolve(Trouble trouble) {
??if (Character.isLetter(trouble.getCh())) {
???return true;
??}
??return false;
?}

}
实现处理请求的子类，数字

package com.ijo.chain.of.responsibility;

public class NumberSupport extends Support {

?@Override
?protected boolean resolve(Trouble trouble) {
??if (Character.isDigit(trouble.getCh())) {
???return true;
??}
??return false;
?}

}

实现处理请求的子类，符号

package com.ijo.chain.of.responsibility;

public class SymbolSupport extends Support {

?@SuppressWarnings("deprecation")
?@Override
?protected boolean resolve(Trouble trouble) {
??
??if (Character.isSpace(trouble.getCh())) {
???return true;
??}
??return false;
?}

}
测试类

package com.ijo.chain.of.responsibility;

public class Main {

?/**
? * @param args
? */
?public static void main(String[] args) {
??Support symbol = new SymbolSupport();
??Support number = new NumberSupport();
??Support charactor = new CharacterSupport();
??symbol.addNext(number).addNext(charactor);
// 第二个和最后一个都是空格字符??

char[] chs = { 'a', ' ', 'b', '*', '2', '^', 'b', ' ' };
??for (char c : chs) {
???symbol.support(new Trouble(c));
??}
?}

}

结果
?doing a
?doing?
?doing b
?fail *
?doing 2
?fail ^
?doing b
?doing?

?

查看更多 下一篇