責任チェーンの完全な理解
詳細
責任チェーン(Chain of Responsibility)モード
責任チェーンモードは、オブジェクトの動作モードです.
責任チェーンモードでは、多くのオブジェクトが各オブジェクトの下位への参照によって接続されてチェーンを形成します.要求は、チェーン上のオブジェクトが要求を処理することを決定するまで、このチェーンに渡されます.
この要求を発行したクライアントは、チェーン上のどのオブジェクトが最終的にこの要求を処理するかを知らないため、システムは、クライアントに影響を及ぼさずにチェーンを動的に再組織し、責任を割り当てることができる.
責任チェーン・モードの役割:
1、抽象処理者ロール:要求を処理するインタフェースを定義します.必要に応じて、インタフェースは、次の参照を設定して返す方法を定義できます.この役は通常
Java抽象クラスまたはjavaインタフェースが実装されます.
2、具体的な処理者の役割:具体的な処理者は要求を受け取った後に、要求を処理することを選択することができて、あるいは要求を下の家に伝えることができて、具体的な処理者は下の家に対する引用を持っているため、
、必要に応じて、具体的な処理者は次の家にアクセスできます.
Javaコードコレクションコード
純粋と不純の責任チェーンモデル
1つの純粋な責任チェーンモデルは、1つの具体的な処理者オブジェクトが2つの行為の中で1つしか選択できないことを要求しています.1つは責任を負うことであり、2つは責任を下の家に押し付けることです.
ある特定の処理者オブジェクトが一部の責任を負った後、また責任を下に伝えることは許されない.
純粋な責任チェーンモードでは、1つの要求はある処理者オブジェクトに受け入れられなければならない.不純な責任チェーンモードでは、1つの要求は最終的に受け入れられない.
任意の受信側オブジェクトが受信します.
Javaコードコレクションコード
次の場合は、職責チェーン・モードを使用できます.
(1)システムには既に処理者オブジェクトからなるチェーンがある.このチェーンは合成モードによって与えられる可能性がある.
(2)複数の処理者オブジェクトが1つの要求を処理し,どの処理者オブジェクトが1つの要求を処理するかは事前に知らなかった.
このプロセッサオブジェクトは動的に決定されます.
(3)システムは、複数のプロセッサオブジェクトのいずれかに要求を発行しようとするが、どのプロセッサオブジェクトがこの要求を処理するかは明らかに指定されていない.
(4)1つの要求を処理する処理者オブジェクトの集合を動的に指定する必要がある場合.
責任チェーンモードは、コマンドを発行するオブジェクトとコマンドを処理するオブジェクトとの結合を低減し、複数のプロセッサオブジェクトが自分の論理に基づいて決定することを可能にする.
どのプロセッサが最終的にこのコマンドを処理しますか.言い換えれば、命令を出す対象は、命令をチェーン構造の開始者に伝えるだけであり、チェーン上であることを知る必要はない
のどのノードがこのコマンドを処理しましたか.
明らかに.これは、コマンドを処理するときに、システムの柔軟性を向上させることを意味します.どのオブジェクトが最終的にコマンドを処理するかは、どのオブジェクトが責任チェーンに参加するかによって決まります.
これらのオブジェクトの責任チェーン上の位置が異なります.
Javaコードコレクションコード
責任チェーン(Chain of Responsibility)モード
責任チェーンモードは、オブジェクトの動作モードです.
責任チェーンモードでは、多くのオブジェクトが各オブジェクトの下位への参照によって接続されてチェーンを形成します.要求は、チェーン上のオブジェクトが要求を処理することを決定するまで、このチェーンに渡されます.
この要求を発行したクライアントは、チェーン上のどのオブジェクトが最終的にこの要求を処理するかを知らないため、システムは、クライアントに影響を及ぼさずにチェーンを動的に再組織し、責任を割り当てることができる.
責任チェーン・モードの役割:
1、抽象処理者ロール:要求を処理するインタフェースを定義します.必要に応じて、インタフェースは、次の参照を設定して返す方法を定義できます.この役は通常
Java抽象クラスまたはjavaインタフェースが実装されます.
2、具体的な処理者の役割:具体的な処理者は要求を受け取った後に、要求を処理することを選択することができて、あるいは要求を下の家に伝えることができて、具体的な処理者は下の家に対する引用を持っているため、
、必要に応じて、具体的な処理者は次の家にアクセスできます.
Javaコードコレクションコード
//
public abstract class Hander{
// ，
protected Handle successor;
public abstract void handleRequest();
// ，
public void setSuccessor(Handler successor){
this.successor = successor;
}
public Handler getSuccessor(){
return successor;
}
}
//
public class ConcreteHandler extends Handler{
public void handlerRequest(){
if(getSuccessor() != null){
System.out.println("The request is passed to " + getSuccessor());
getSuccessor().handlerRequest();
}else{
System.out.println("The request is handled here.");
}
}
}
//
public class Client{
private static Handler handler1, handler2;
public static void main(String args[]){
handler1 = new ConcreteHandler();
handler2 = new ConcreteHandler();
handler1.setSuccessor(handler2);
handler1.handleRequest();
}
} 純粋と不純の責任チェーンモデル
1つの純粋な責任チェーンモデルは、1つの具体的な処理者オブジェクトが2つの行為の中で1つしか選択できないことを要求しています.1つは責任を負うことであり、2つは責任を下の家に押し付けることです.
ある特定の処理者オブジェクトが一部の責任を負った後、また責任を下に伝えることは許されない.
純粋な責任チェーンモードでは、1つの要求はある処理者オブジェクトに受け入れられなければならない.不純な責任チェーンモードでは、1つの要求は最終的に受け入れられない.
任意の受信側オブジェクトが受信します.
Javaコードコレクションコード
//
// ( )
public class DrumBeater{
private static Player player;
public static void main(String[] args){
//
player = new JiaMu(new JiaShe(new JiaZheng(new JiaBaoYu(new JiaHuan(null)))));
//
player.handler(4);
}
}
public abstract class Player{
public abstract void handler(int i);
private Player successor;
public Player(){
successor = null;
}
protected void setSuccessor(Player aSuccessor){
successor = aSuccessor;
}
// ， ，
public void next(int index){
//
if(successor != null){
//
successor.handler(index);
}else{
//
System.out.println("Program terminated.");
System.exit(0);
}
}
}
//JiaMu
public class JiaMu extends Player{
public JiaMu(Player aSuccessor){
this.setSuccessor(aSuccessor);
}
public void handler(int i){
if(i == 1){
System.out.println("Jia Mu gotta drink!");
}else{
System.out.println("JiaMu passed!");
next(i);
}
}
}
//JiaShe
public class JiaShe extends Player{
public JiaShe(Player aSuccessor){
this.setSuccessor(aSuccessor);
}
public void handler(int i){
if(i == 2){
System.out.println("Jia She gotta drink!");
}else{
System.out.println("Jia She passed!");
next(i);
}
}
}
public class JiaZheng extends Player{
public JiaZheng(Player aSuccessor){
this.setSuccessor(aSuccessor);
}
public void handler(int i){
if(i == 3){
System.out.println("Jia Zheng gotta drink!");
}else{
System.out.println("Jia Zheng passed!");
next(i);
}
}
}
public class JiaBaoYu extends Player{
public JiaBaoYu(Player aSuccessor){
this.setSuccessor(aSuccessor);
}
public void handler(int i){
if(i == 4){
System.out.println("Jia Bao Yu gotta drink!");
}else{
System.out.println("Jia Bao Yu passed!");
next(i);
}
}
}
public class JiaHuan extends Player{
public JiaHuan(Player aSuccessor){
this.setSuccessor(aSuccessor);
}
public void handler(int i){
if(i == 5){
System.out.println("Jia Huan gotta drink!");
}else{
System.out.println("Jia Huan passed!");
next(i);
}
}
} 次の場合は、職責チェーン・モードを使用できます.
(1)システムには既に処理者オブジェクトからなるチェーンがある.このチェーンは合成モードによって与えられる可能性がある.
(2)複数の処理者オブジェクトが1つの要求を処理し,どの処理者オブジェクトが1つの要求を処理するかは事前に知らなかった.
このプロセッサオブジェクトは動的に決定されます.
(3)システムは、複数のプロセッサオブジェクトのいずれかに要求を発行しようとするが、どのプロセッサオブジェクトがこの要求を処理するかは明らかに指定されていない.
(4)1つの要求を処理する処理者オブジェクトの集合を動的に指定する必要がある場合.
責任チェーンモードは、コマンドを発行するオブジェクトとコマンドを処理するオブジェクトとの結合を低減し、複数のプロセッサオブジェクトが自分の論理に基づいて決定することを可能にする.
どのプロセッサが最終的にこのコマンドを処理しますか.言い換えれば、命令を出す対象は、命令をチェーン構造の開始者に伝えるだけであり、チェーン上であることを知る必要はない
のどのノードがこのコマンドを処理しましたか.
明らかに.これは、コマンドを処理するときに、システムの柔軟性を向上させることを意味します.どのオブジェクトが最終的にコマンドを処理するかは、どのオブジェクトが責任チェーンに参加するかによって決まります.
これらのオブジェクトの責任チェーン上の位置が異なります.
Javaコードコレクションコード
// Timer
import java.util.Timer;
import java.util.TimerTask;
public class Reminder{
Timer timer;
// ， seconds
public Reminder(int seconds){
timer = new Timer();
timer.schedule(new RemindTask(),seconds*1000); //schedule( ， )
}
// ，
class RemindTask extends TimerTask{
public void run(){
System.out.println("Time's up!");
timer.cancle();
}
}
public static void main(String[] args){
System.out.println("About to schedule task.");
new Reminder(5);
System.out.println("Task scheduled.");
}
}
//Timer ， ， Timer ， 。 Timer 。
// （ ）
import java.lang.Thread;
import java.util.Timer;
import java.util.TimerTask;
public class DrumBeater{
private static Player firstPlayer;
public static boolean stopped = false;
Timer timer;
public static void main(String[] args){
DrumBeater drumBeater = new DrumBeater();
JiaMu jiaMu = new JiaMu(null);
JiaMu.setSuccessor(new JiaShe(new JiaZheng(new JiaBaoYu(new JiaHuan(jiaMu)))));
//
drumBeater.startBeating(1);
//
firstPlayer = jiaMu;
firstPlayer.handle();
}
// ，
public void startBeating(int stopInSeconds){
System.out.println("Drum beating started...");
timer = new Timer();
timer.schedule(new StopBeatingReminder(),stopInSeconds*1000);
}
// ，
class StopBeatingReminder extends TimerTask{
public void run(){
System.out.println("Drum beating stopped!");
stopped = true;
timer.cancel();
}
}
}
//
public abstract class Player{
public abstract void handle();
private Player successor;
public Player(){
successor = null;
}
protected void setSuccessor(Player aSuccessor){
successor = aSuccessor;
}
public void next(){
//
if(successor != null){
//
successor.handle();
}else{
//
System.out.println("Program is terminating.");
System.exit(0);
}
}
}
//
public class JiaMu extends Player{
public JiaMu(Player aSuccessor){
this.setSuccessor(aSuccessor);
}
public void handle(){
// ］
if(DrumBeater.stopped){
System.out.pritntln("Jia Mu gotta drink!");
}else{
System.out.println("Jia Mu passed!");
next();
}
}
}
......................
public class JiaHuan extends Player{
public JiaHuan(Player aSuccessor){
this.setSuccessor(aSuccessor);
}
public void handle(){
// ］
if(DrumBeater.stopped){
System.out.println("Jia Huan gotta drink!");
}else{
System.out.println("Jia Huan passed!");
next();
}
}
}