複数のオブジェクトがリクエストを処理する機会を持つことを許可します。これにより、リクエストの送信者と受信者の間の結合関係を回避できます。これらのオブジェクトをチェーンに接続し、オブジェクトが処理するまでこのチェーンに沿ってリクエストを渡します。
クラス図
コード例
1. class Level {
2. private int level = 0;
3. public Level(int level){
4. this.level = level;
5. };
6.
7. public boolean above(Level level){
8. if(this.level >= level.level){
9. return true;
10. }
11. return false;
12. }
13. }
14.
15. class Request {
16. Level level;
17. public Request(Level level){
18. this.level = level;
19. }
20.
21. public Level getLevel(){
22. return level;
23. }
24. }
25.
26. class Response {
27.
28. }
ハンドラ：
1. abstract class Handler {
2. private Handler nextHandler;
3. public final Response handleRequest(Request request){
4. Response response = null;
5.
6. if(this.getHandlerLevel().above(request.getLevel())){
7. response = this.response(request);
8. }else{
9. if(this.nextHandler != null){
10. this.nextHandler.handleRequest(request);
11. }else{
12. System.out.println("-----没有合适的处理器-----");
13. }
14. }
15. return response;
16. }
17. public void setNextHandler(Handler handler){
18. this.nextHandler = handler;
19. }
20. protected abstract Level getHandlerLevel();
21. public abstract Response response(Request request);
22. }
ConcreteHandler：
1. class ConcreteHandler1 extends Handler {
2. protected Level getHandlerLevel() {
3. return new Level(1);
4. }
5. public Response response(Request request) {
6. System.out.println("-----请求由处理器1进行处理-----");
7. return null;
8. }
9. }
10.
11. class ConcreteHandler2 extends Handler {
12. protected Level getHandlerLevel() {
13. return new Level(3);
14. }
15. public Response response(Request request) {
16. System.out.println("-----请求由处理器2进行处理-----");
17. return null;
18. }
19. }
20.
21. class ConcreteHandler3 extends Handler {
22. protected Level getHandlerLevel() {
23. return new Level(5);
24. }
25. public Response response(Request request) {
26. System.out.println("-----请求由处理器3进行处理-----");
27. return null;
28. }
29. }
クライアント：
1. public class Client {
2. public static void main(String[] args){
3. Handler handler1 = new ConcreteHandler1();
4. Handler handler2 = new ConcreteHandler2();
5. Handler handler3 = new ConcreteHandler3();
6.
7. handler1.setNextHandler(handler2);
8. handler2.setNextHandler(handler3);
9.
10. Response response = handler1.handleRequest(new Request(new Level(4)));
11. }
} 責任連鎖モデル構造
責任接続パターンのクラス図は非常に単純で、抽象処理クラスと一連の実装クラスで構成されています。
- 抽象処理クラス：抽象処理クラスには、主に次の処理クラスを指すメンバー変数nextHandlerと、リクエストを処理するためのメソッドhandRequestが含まれています.handRequestメソッドの主なアイデアは、処理条件が満たされた場合、この処理クラスが処理に使用されることです、それ以外の場合は、nextHandlerによって処理されます。
- 特定の処理カテゴリ：特定の処理カテゴリは、主に特定の処理ロジックを実装し、適用可能な条件を処理するためのものです。
責任連鎖モデルの長所と短所
if ... else ...と比較すると、責任連鎖モデルは、条件の決定を各処理クラスに分散し、これらの処理クラスの優先処理順序を自由に設定できるため、結合が低くなります。
責任連鎖モデルにも欠点があります。これは、if ... else ...ステートメントの欠点と同じです。つまり、正しい処理クラスが見つかる前にすべての判断条件を実行する必要があります。責任連鎖が比較的長い場合、パフォーマンスの問題はより深刻になります。 。
責任連鎖モードを使用するためのシナリオ
最初の例と同じように、if ... else ...ステートメントを使用して責任の連鎖を編成するときに無力であり、コードが見栄えが悪い場合は、責任の連鎖パターンを使用してリファクタリングできます。
総括する
責任連鎖モデルは、実際にはif ... else ...ステートメントの柔軟なバージョンであり、これらの判断条件ステートメントを各処理クラスに配置します。これの利点は、柔軟性が高いことですが、処理の設定などのリスクも伴います。クラスのコンテキストを処理するときは、クラスの前後のロジックの条件付き判断関係を処理するように非常に注意する必要があります。また、チェーン内に循環参照がないように注意する必要があります。