Javaのチェーンオブリスポンシビリティパターンで実現する責任の委譲：設計から実装まで徹底解説

Javaにおけるチェーンオブリスポンシビリティ（Chain of Responsibility）パターンは、オブジェクト間で責任を柔軟に委譲するためのデザインパターンです。このパターンを使用すると、複数のオブジェクトが順番にリクエストを処理できるようになり、特定のオブジェクトに責任を集中させずに処理を分散させることが可能です。例えば、エラーログやユーザー認証の処理など、特定の条件を満たすまで次の処理に委譲する場合に役立ちます。本記事では、Javaでのチェーンオブリスポンシビリティパターンを利用した責任の委譲方法について、基礎から応用まで解説します。

チェーンオブリスポンシビリティパターンとは

チェーンオブリスポンシビリティパターンは、リクエストを処理する複数のオブジェクトが、連鎖的に責任を受け渡すことで、柔軟な処理フローを実現するデザインパターンです。このパターンでは、リクエストが一連のハンドラー（処理オブジェクト）に順番に送信され、各ハンドラーは自分が対応可能なリクエストかどうかを判断し、対応できなければ次のハンドラーに処理を委譲します。

この仕組みにより、特定のオブジェクトにすべての処理を集中させることなく、各オブジェクトがそれぞれの責任範囲に応じて処理を行うことが可能になります。責任の委譲が明確になり、コードの可読性や拡張性が向上するため、複雑なシステムでの使用が効果的です。

パターンの利点

チェーンオブリスポンシビリティパターンには、以下のような多くの利点があります。

1. 柔軟な処理フロー

各ハンドラーが特定の処理を担当し、必要に応じて次のハンドラーに処理を渡すため、柔軟なフローを構築できます。リクエスト処理の順序や処理の追加・削除が簡単にできる点が大きな特徴です。

2. 責任の分散

単一のクラスやメソッドにすべての責任を集中させることなく、複数のオブジェクトに責任を分散できます。これにより、コードがスリムになり、各クラスが特定の責任だけを持つことで、保守性が向上します。

3. オープン/クローズド原則の遵守

新しいハンドラーを追加する場合でも、既存のクラスに手を加えることなく、システムを拡張できます。これは、オープン/クローズド原則（拡張にはオープン、変更にはクローズ）を守りながら、柔軟な設計が可能になることを意味します。

4. コードの再利用性向上

ハンドラーがそれぞれ独立して動作するため、共通の処理を再利用しやすくなります。必要に応じて同じハンドラーを別のチェーンに組み込むことも可能です。

これらの利点により、チェーンオブリスポンシビリティパターンは、大規模なシステムや複雑なフローの管理に非常に適しています。

Javaでの実装方法

Javaでチェーンオブリスポンシビリティパターンを実装するには、まずハンドラー（処理役）を定義し、それを連鎖的に結びます。ここでは、基本的な構造とサンプルコードを用いて、実装方法を説明します。

1. ハンドラーインターフェースの定義

まず、全てのハンドラーが実装すべきインターフェースを定義します。このインターフェースには、リクエストを処理するためのメソッドを含めます。

public interface Handler {
    void setNext(Handler nextHandler);
    void handleRequest(String request);
}

setNextメソッドで次のハンドラーを設定し、handleRequestでリクエストを処理します。

2. 具体的なハンドラーの実装

次に、具体的な処理を行うハンドラークラスをいくつか実装します。それぞれのクラスがリクエストを処理し、処理できない場合は次のハンドラーに委譲します。

public class ConcreteHandlerA implements Handler {
    private Handler nextHandler;

    @Override
    public void setNext(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(String request) {
        if (request.equals("A")) {
            System.out.println("ConcreteHandlerA handled the request.");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

public class ConcreteHandlerB implements Handler {
    private Handler nextHandler;

    @Override
    public void setNext(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(String request) {
        if (request.equals("B")) {
            System.out.println("ConcreteHandlerB handled the request.");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

各ハンドラーは、対応できるリクエストの場合に処理し、対応できない場合は次のハンドラーに処理を委譲します。

3. チェーンの構築

最後に、各ハンドラーを連結してチェーンを構築します。

public class ChainOfResponsibilityExample {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();

        handlerA.setNext(handlerB);

        handlerA.handleRequest("B");
    }
}

このコードでは、ConcreteHandlerAが処理を試みますが、リクエストが”B”であるため、次のConcreteHandlerBがリクエストを処理します。

4. 柔軟な拡張

この構造では、新しいハンドラーを追加したり、処理の順序を変更したりするのが非常に簡単です。また、処理ロジックが各ハンドラーに分散されているため、各クラスが単一の責任を持ち、拡張性が高いコードになります。

このようにして、Javaでチェーンオブリスポンシビリティパターンを実装し、柔軟な責任の委譲を実現することができます。

ハンドラークラスの役割

チェーンオブリスポンシビリティパターンにおけるハンドラークラスは、リクエストを処理する役割を持ちます。それぞれのハンドラーが独自の処理を行い、特定の条件に基づいて次のハンドラーに責任を委譲します。これにより、処理の流れが階層的に整理され、コードの可読性と拡張性が向上します。

1. 単一責任の原則

ハンドラークラスは、単一責任原則に基づき、1つの責任に集中します。つまり、各ハンドラーは特定の種類のリクエストを処理することだけを担当し、他の処理は行いません。例えば、エラーハンドリング、ログ記録、認証など、それぞれ異なる処理が分割され、コードの保守が容易になります。

2. リクエストのフィルタリング

各ハンドラーは、リクエストを受け取るとまずそのリクエストが自分の担当であるかを確認します。自分で処理できる場合は処理を行い、処理できない場合は次のハンドラーにリクエストを渡します。これにより、責任が柔軟に委譲され、システム全体の効率が向上します。

例：リクエストフィルタリング

@Override
public void handleRequest(String request) {
    if (request.equals("A")) {
        System.out.println("ConcreteHandlerA handled the request.");
    } else if (nextHandler != null) {
        nextHandler.handleRequest(request);
    }
}

このように、各ハンドラーは自分が処理できないリクエストが来た場合、次のハンドラーに処理を委譲します。

3. ハンドラーの連携

ハンドラーは次のハンドラーを保持し、処理を連鎖させます。この連携によって、処理のフローが柔軟に設計でき、特定の処理が別のオブジェクトに委ねられたとしてもシステム全体が一貫して動作します。

@Override
public void setNext(Handler nextHandler) {
    this.nextHandler = nextHandler;
}

このようにして、ハンドラー同士が連携し、一連の処理を段階的に行うことで、システムの複雑さを軽減しつつも柔軟な対応が可能になります。

4. 拡張性の確保

ハンドラークラスを分離することで、新しい処理を追加する際に既存のクラスを変更する必要がありません。新たなハンドラーを作成し、チェーンの適切な位置に追加するだけで、簡単にシステムを拡張できます。これにより、オープン/クローズド原則を守りつつ、コードの再利用性が高まります。

このように、ハンドラークラスはパターン全体の中心となり、リクエストのフィルタリング、処理の委譲、責任の分散を効果的に実現します。

実際の使用例

チェーンオブリスポンシビリティパターンは、現実のさまざまな場面で利用されます。ここでは、具体的なシナリオを通じて、Javaでのチェーンオブリスポンシビリティパターンの使用例を紹介します。例として、ユーザーリクエストの処理やエラーログの管理を取り上げます。

1. ユーザーリクエストの処理

例えば、Webアプリケーションにおいて、ユーザーからのリクエストが送信されると、そのリクエストが複数の処理段階を経ることがよくあります。リクエストを検証し、ユーザーの権限を確認し、必要に応じてエラー処理を行うといった処理は、チェーンオブリスポンシビリティパターンで効率的に管理できます。

以下は、リクエスト処理の流れをチェーンで表現した例です。

public class AuthenticationHandler implements Handler {
    private Handler nextHandler;

    @Override
    public void setNext(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(String request) {
        if (request.equals("AUTH")) {
            System.out.println("Authentication successful.");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

public class AuthorizationHandler implements Handler {
    private Handler nextHandler;

    @Override
    public void setNext(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(String request) {
        if (request.equals("AUTHORIZE")) {
            System.out.println("Authorization successful.");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

この例では、ユーザーリクエストが認証（Authentication）と認可（Authorization）のプロセスを順に通過し、各プロセスが問題なく終了すればリクエストが受理されます。

2. エラーログの管理

エラーログの処理も、チェーンオブリスポンシビリティパターンを活用する典型的な例です。アプリケーション内で発生するエラーを、まずは軽度なエラーから順にチェックし、次第に重大なエラーへと処理が進むようにすることで、適切なレベルのエラーハンドリングが可能になります。

public class InfoLogger implements Handler {
    private Handler nextHandler;

    @Override
    public void setNext(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(String request) {
        if (request.equals("INFO")) {
            System.out.println("Info: Logging information.");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

public class ErrorLogger implements Handler {
    private Handler nextHandler;

    @Override
    public void setNext(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(String request) {
        if (request.equals("ERROR")) {
            System.out.println("Error: Logging error.");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

このように、アプリケーション内で発生するログを、情報ログやエラーログなどのカテゴリに応じて分け、それぞれに対応するハンドラーを用意しておくことで、効率的なエラーハンドリングが可能になります。

3. クライアントコードでの実装

これらのハンドラーを連結して使用する例を示します。

public class Application {
    public static void main(String[] args) {
        Handler authHandler = new AuthenticationHandler();
        Handler authorizeHandler = new AuthorizationHandler();
        Handler infoLogger = new InfoLogger();
        Handler errorLogger = new ErrorLogger();

        authHandler.setNext(authorizeHandler);
        authorizeHandler.setNext(infoLogger);
        infoLogger.setNext(errorLogger);

        // "AUTH"は認証ハンドラーで処理される
        authHandler.handleRequest("AUTH");

        // "AUTHORIZE"は認可ハンドラーで処理される
        authHandler.handleRequest("AUTHORIZE");

        // "ERROR"はエラーハンドラーまで到達して処理される
        authHandler.handleRequest("ERROR");
    }
}

このクライアントコードでは、リクエストが各ハンドラーを順番に通過し、適切なハンドラーによって処理されることが確認できます。認証やエラーログ処理のフローが整理され、複雑なロジックでも明確に管理できるようになります。

デザインパターンとの組み合わせ

チェーンオブリスポンシビリティパターンは、他のデザインパターンと組み合わせて使用することで、さらに強力で柔軟な設計が可能になります。ここでは、いくつかのデザインパターンとの組み合わせ方とその効果について説明します。

1. ファクトリーパターンとの組み合わせ

ファクトリーパターンは、オブジェクトの生成をカプセル化するパターンです。チェーンオブリスポンシビリティパターンと組み合わせることで、動的にハンドラーのチェーンを構築し、処理の流れを柔軟に管理できます。これにより、状況に応じたハンドラーの選択や、実行時に異なるチェーンを生成することが容易になります。

例：ファクトリーパターンでのハンドラー生成

public class HandlerFactory {
    public static Handler createHandlerChain() {
        Handler authHandler = new AuthenticationHandler();
        Handler authorizeHandler = new AuthorizationHandler();
        Handler infoLogger = new InfoLogger();
        Handler errorLogger = new ErrorLogger();

        authHandler.setNext(authorizeHandler);
        authorizeHandler.setNext(infoLogger);
        infoLogger.setNext(errorLogger);

        return authHandler;
    }
}

このように、ファクトリーパターンを使ってハンドラーのチェーンを作成し、クライアントコードで簡単に呼び出すことができます。これにより、コードの再利用性と柔軟性が向上します。

2. デコレータパターンとの組み合わせ

デコレータパターンは、オブジェクトに対して動的に機能を追加するためのパターンです。これをチェーンオブリスポンシビリティパターンと組み合わせることで、各ハンドラーに新たな機能を柔軟に付与することが可能です。

例えば、ログ機能やエラーハンドリングを個別に追加する際に、デコレータを使うことで既存のハンドラーに機能を追加できます。

例：ログ機能のデコレーション

public class LoggingHandlerDecorator implements Handler {
    private Handler decoratedHandler;

    public LoggingHandlerDecorator(Handler handler) {
        this.decoratedHandler = handler;
    }

    @Override
    public void setNext(Handler nextHandler) {
        decoratedHandler.setNext(nextHandler);
    }

    @Override
    public void handleRequest(String request) {
        System.out.println("Logging request: " + request);
        decoratedHandler.handleRequest(request);
    }
}

このデコレータを使うことで、どのハンドラーにもログ機能を追加でき、柔軟な拡張が可能です。

3. コマンドパターンとの組み合わせ

コマンドパターンは、操作をオブジェクトとしてカプセル化し、メソッドの呼び出しをオブジェクト化するパターンです。チェーンオブリスポンシビリティパターンと組み合わせることで、リクエストをコマンドオブジェクトとして処理の流れに組み込むことができ、処理の分離と管理が容易になります。

例えば、ユーザーアクションやシステムイベントをコマンドとして扱い、各ハンドラーがそれを処理する役割を担うといったシナリオが可能です。

例：コマンドパターンの活用

public class Command {
    private String commandType;

    public Command(String commandType) {
        this.commandType = commandType;
    }

    public String getCommandType() {
        return commandType;
    }
}

各ハンドラーがCommandオブジェクトを処理することで、システムの柔軟性が向上します。

4. ストラテジーパターンとの組み合わせ

ストラテジーパターンは、アルゴリズムや処理の内容をカプセル化し、それを動的に切り替えるためのパターンです。チェーンオブリスポンシビリティパターンと組み合わせることで、各ハンドラーが異なる処理戦略を持ち、リクエストに応じて動的に戦略を変更することが可能です。

この組み合わせにより、複数の処理方法をチェーンの中で切り替えることができ、より効率的な設計が実現します。

5. まとめ

チェーンオブリスポンシビリティパターンは、他のデザインパターンと組み合わせることで、さらなる柔軟性と拡張性を持つシステムを設計できます。ファクトリーパターンやデコレータパターンなどとの組み合わせによって、より動的でメンテナンスしやすいコード構造を実現できるため、設計の自由度が広がります。

適用時の注意点

チェーンオブリスポンシビリティパターンは、柔軟で拡張性の高いデザインパターンですが、適用時にはいくつかの注意点があります。これらのポイントを押さえておくことで、誤った実装や非効率な処理を避け、効果的なシステム設計を実現できます。

1. チェーンの長さに注意

チェーンがあまりにも長くなると、処理の効率が低下し、パフォーマンスの問題を引き起こす可能性があります。各ハンドラーがリクエストを処理できない場合、次々と処理が委譲されていくため、必要以上に多くのハンドラーを通過することになります。特にリアルタイム性が求められるシステムでは、チェーンの長さに注意を払い、最適な長さを維持することが重要です。

2. 責任の曖昧化を避ける

各ハンドラーは、明確な責任を持つべきです。もし、複数のハンドラーが同じ種類のリクエストを処理しようとする場合、どのハンドラーが責任を持つべきかが曖昧になり、予期しない動作を引き起こす可能性があります。責任の範囲を明確にし、ハンドラー間での処理が重複しないように設計することが大切です。

例：責任の分離

public class AuthenticationHandler implements Handler {
    @Override
    public void handleRequest(String request) {
        if (request.equals("AUTH")) {
            System.out.println("Authentication successful.");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

このように、各ハンドラーが独自の責任を持ち、明確に定義されたリクエストのみを処理することで、責任の曖昧化を防ぎます。

3. ハンドラーの順序に注意

ハンドラーの順序が適切でない場合、正しく機能しない可能性があります。例えば、認可（Authorization）を行う前に認証（Authentication）が済んでいなければ、システムが不適切な状態で動作してしまいます。適切な順序でハンドラーを配置することが、正しい処理フローの維持に不可欠です。

例：正しいハンドラーの順序

authHandler.setNext(authorizeHandler);
authorizeHandler.setNext(loggerHandler);

このように、適切な順序でハンドラーを設定することで、処理の流れが自然で正しいものになります。

4. エラー処理の一貫性

各ハンドラーがリクエストを適切に処理できない場合、次のハンドラーに処理が委譲されますが、エラー処理が一貫していないと、エラーの原因が特定しづらくなります。全てのハンドラーで共通のエラーハンドリングポリシーを定義することが重要です。

5. 責任が委譲されないケースの対処

すべてのハンドラーがリクエストを処理しない場合の対策も考慮する必要があります。例えば、最後のハンドラーでもリクエストが処理されなかった場合、エラーメッセージを返したり、デフォルトの処理を行ったりする必要があります。

例：デフォルトの処理

if (nextHandler == null) {
    System.out.println("No handler could process the request.");
}

最後のハンドラーが処理を行わなかった場合に、適切な対応を行うことで、システムの信頼性を保つことができます。

6. 過剰なハンドラーの追加を避ける

チェーンオブリスポンシビリティパターンは、拡張性が高いため、新しいハンドラーを簡単に追加できますが、無闇にハンドラーを追加するとシステムが複雑になり、管理が困難になります。必要最小限のハンドラーで機能を実装し、コードのシンプルさを維持することが重要です。

7. まとめ

チェーンオブリスポンシビリティパターンは柔軟で強力なデザインパターンですが、適用時にはパフォーマンスや責任の範囲、ハンドラーの順序などに注意を払う必要があります。これらのポイントを正しく理解し、適切に実装することで、シンプルかつ効果的なシステムを構築することができます。

パフォーマンスへの影響

チェーンオブリスポンシビリティパターンは、柔軟なリクエスト処理を実現するために非常に有用ですが、使用方法によってはパフォーマンスに影響を与えることがあります。このセクションでは、パフォーマンスに関連する要素とその最適化方法について説明します。

1. チェーンが長くなる場合の影響

チェーンの長さが増えるほど、各リクエストが通過するハンドラーの数が増加し、処理にかかる時間が長くなる可能性があります。これは特に、処理がリアルタイムで行われる必要があるアプリケーションや、大量のリクエストを処理するシステムでは、パフォーマンスのボトルネックとなる可能性があります。

例えば、10個以上のハンドラーを順に通過するリクエストでは、毎回次のハンドラーに処理を渡す時間が積み重なるため、パフォーマンス低下を引き起こすことがあります。

最適化のアプローチ

• ハンドラー数の最適化：不要なハンドラーが追加されないよう、チェーンの構造を最適化します。
• ハンドラーの条件分岐：各ハンドラーがリクエストを処理するかどうかの判断を迅速に行い、処理の不要な遅延を最小限に抑えます。

2. 遅延の原因：ハンドラーの処理時間

各ハンドラーの処理が重い場合、チェーン全体の処理時間が著しく影響されます。特に、リクエストの受け渡しが頻繁に行われると、無駄な計算や処理が累積し、システム全体の応答性が低下します。

例：非効率な処理

public class HeavyProcessingHandler implements Handler {
    @Override
    public void handleRequest(String request) {
        // 重い処理を行う
        for (int i = 0; i < 1000000; i++) {
            // 処理の繰り返し
        }
        if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

このような非効率な処理を持つハンドラーがチェーンに含まれている場合、リクエスト処理が遅くなり、ユーザー体験やシステムのスループットに悪影響を与える可能性があります。

最適化のアプローチ

• 処理の分散：複雑で重い処理は別スレッドや非同期処理で実行し、メインのリクエストフローへの影響を減らします。
• キャッシュの活用：頻繁に行われる同じ処理結果をキャッシュして再利用することで、パフォーマンスを向上させます。

3. メモリ使用量への影響

チェーンが長くなると、各ハンドラーがメモリを消費します。特に、ハンドラーが大規模なデータを保持している場合、メモリ使用量が増加し、システムのパフォーマンスに悪影響を与える可能性があります。

最適化のアプローチ

• メモリ効率の向上：不要なデータを保持しないように、必要な処理が終わったらメモリを開放する設計にします。
• ハンドラー間の依存性を最小化：各ハンドラーが独立して動作し、無駄なデータのやり取りが発生しないようにします。

4. レイテンシの発生リスク

チェーンオブリスポンシビリティパターンを使用することで、レイテンシが発生するリスクがあります。特に、処理が逐次的に行われるため、処理待ちが連続する場合にレイテンシが増加する傾向があります。

最適化のアプローチ

• 非同期処理：リクエストの処理を非同期で行うことで、処理の遅延を最小限に抑え、レイテンシを軽減します。
• 並列処理：リクエストを複数のハンドラーで並列に処理し、パフォーマンスを向上させることも可能です。

5. 不要なハンドラーの検出と削除

時間が経過するにつれ、システムが進化し、新たなハンドラーが追加されていく中で、古いハンドラーが不要になることがあります。これらの不要なハンドラーが残っていると、無駄な処理が発生し、パフォーマンスに悪影響を与えます。

最適化のアプローチ

• 定期的な見直し：システム全体を定期的に見直し、不要なハンドラーや処理を削除します。

6. まとめ

チェーンオブリスポンシビリティパターンは非常に柔軟ですが、チェーンの長さ、処理の重さ、メモリ使用量、レイテンシなど、パフォーマンスに影響を与える要素を適切に管理することが重要です。これらの問題を理解し、最適化することで、システムの効率を最大限に引き出すことが可能です。

応用例と演習問題

チェーンオブリスポンシビリティパターンの基本的な概念と実装方法を学んだところで、さらに理解を深めるための応用例と演習問題を紹介します。これにより、実際の開発においてどのようにパターンを活用するかを具体的に学べます。

1. 応用例

1.1 APIリクエスト処理のチェーン

Webアプリケーションで、APIリクエストが受信されるたびに、複数の処理を行う必要がある場合、チェーンオブリスポンシビリティパターンは非常に効果的です。例えば、リクエストのバリデーション、認証、認可、キャッシュ確認、レスポンスの生成という一連の処理をチェーンでつなぐことができます。

public class ApiRequestHandler implements Handler {
    private Handler nextHandler;

    @Override
    public void setNext(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(String request) {
        // リクエストバリデーション
        if (request.contains("VALID")) {
            System.out.println("Request is valid.");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

public class AuthenticationHandler implements Handler {
    private Handler nextHandler;

    @Override
    public void setNext(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(String request) {
        // 認証処理
        if (request.contains("AUTH")) {
            System.out.println("Authentication successful.");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

public class AuthorizationHandler implements Handler {
    private Handler nextHandler;

    @Override
    public void setNext(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(String request) {
        // 認可処理
        if (request.contains("AUTHORIZE")) {
            System.out.println("Authorization successful.");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

このように、APIリクエストの各段階をチェーンにより効率的に処理し、システム全体の拡張性を高めることが可能です。

1.2 ログ監視システムでの利用

企業のログ監視システムにおいて、ログメッセージを異なる重要度に基づいて処理することが求められる場合も、チェーンオブリスポンシビリティパターンが役立ちます。ログの重要度（例：INFO、WARNING、ERROR）に応じて、対応するハンドラーがログを処理するように設計できます。

public class InfoLogger implements Handler {
    private Handler nextHandler;

    @Override
    public void setNext(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(String request) {
        if (request.equals("INFO")) {
            System.out.println("INFO: Logging information.");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

public class ErrorLogger implements Handler {
    private Handler nextHandler;

    @Override
    public void setNext(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(String request) {
        if (request.equals("ERROR")) {
            System.out.println("ERROR: Logging error.");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

この例では、ログの重要度に応じて適切なロガーが処理を行い、次のロガーに処理を委譲します。

2. 演習問題

チェーンオブリスポンシビリティパターンを実装し、その効果を体感するために、以下の演習問題に取り組んでください。

演習1: ファイルアクセス権の管理

複数のレベルでファイルアクセスを管理するシステムを設計してください。例えば、「読み取りアクセス」「書き込みアクセス」「管理者アクセス」の3つのアクセスレベルをハンドラーで管理し、各リクエストが適切なレベルで処理されるように実装してください。

演習2: Eコマースサイトの注文処理

Eコマースサイトの注文処理フローをチェーンオブリスポンシビリティパターンを使って実装してください。各ハンドラーは、以下のような役割を持ちます。

• 在庫確認
• 支払い処理
• 発送準備

このフローにおいて、どのハンドラーがどのリクエストを処理するかを考慮して設計を行ってください。

演習3: チェーンの最適化

すでに実装されているチェーンオブリスポンシビリティパターンを使用したシステムがありますが、パフォーマンスの低下が発生しています。各ハンドラーがリクエストを効率的に処理し、チェーンの長さを適切に管理するための最適化方法を考え、実装してください。

3. まとめ

チェーンオブリスポンシビリティパターンは、柔軟で拡張性の高い設計が可能なパターンですが、実際の応用や問題を解決するためには、パフォーマンスや設計上の課題に取り組む必要があります。応用例や演習問題を通して、実際の開発環境でこのパターンをどのように活用できるかを体験し、理解を深めてください。

まとめ

本記事では、Javaにおけるチェーンオブリスポンシビリティパターンを使った責任の委譲について、設計から実装まで詳しく解説しました。このパターンを使用することで、責任を複数のハンドラーに分散し、処理の柔軟性と拡張性を高めることが可能です。また、実装時の注意点やパフォーマンス最適化の方法、他のデザインパターンとの組み合わせについても紹介しました。実際の応用例や演習問題に取り組むことで、パターンの効果的な活用方法をさらに理解できるでしょう。