Javaの内部クラスで実現する依存性注入（DI）の具体的な実装方法

Javaの内部クラスを利用した依存性注入（DI）は、柔軟かつ効率的にオブジェクトの依存関係を管理するためのテクニックです。通常、依存性注入はオブジェクト指向プログラミングにおいて、クラス同士の依存を疎結合に保つために利用されます。これにより、コードのテストが容易になり、メンテナンス性も向上します。Javaの内部クラスを使用すると、外部クラスとその内部クラス間で簡単に依存性を管理することが可能です。本記事では、内部クラスを活用した依存性注入の基本的な概念から、具体的な実装方法までを詳しく解説します。

依存性注入（DI）とは

依存性注入（Dependency Injection、DI）とは、オブジェクト指向プログラミングにおいて、クラスが他のクラスやオブジェクトに依存している部分を外部から注入する設計パターンの一つです。通常、あるクラスが他のクラスを直接インスタンス化すると、そのクラスに強い依存が生まれ、コードの再利用性や保守性が低下する可能性があります。DIを用いることで、依存関係を外部から提供するため、クラス間の結合度が緩和され、テストやメンテナンスが容易になります。

依存性注入の種類

DIには主に以下の3つの形態があります。

• コンストラクタ注入：依存オブジェクトをコンストラクタを通じて注入します。
• セッター注入：依存オブジェクトをセッターメソッドを用いて注入します。
• インターフェース注入：特定のインターフェースを実装したクラスが、依存オブジェクトを注入します。

この設計パターンは、疎結合を実現し、柔軟なコード設計を可能にするため、多くのフレームワークやライブラリで採用されています。

Javaの内部クラスの役割

Javaの内部クラス（Nested Class）とは、外部クラスの内部に定義されたクラスのことです。内部クラスは外部クラスのメンバーに直接アクセスできるため、特定のタスクに密接に関連する機能をカプセル化し、コードの可読性や設計の効率を向上させることができます。Javaには4つの内部クラスの種類があります。それぞれの特徴と使い方を以下で説明します。

1. 静的内部クラス

静的内部クラス（Static Nested Class）は、外部クラスの静的な一部として扱われます。このため、静的メソッドやフィールドにアクセスすることが可能です。外部クラスのインスタンスを必要とせずに利用でき、主に外部クラスに関連する補助的な機能を提供する場合に使用されます。

2. 非静的内部クラス

非静的内部クラス（Non-static Inner Class）は、外部クラスのインスタンスに依存し、外部クラスのインスタンスが生成された際に一緒に生成されます。この内部クラスは、外部クラスのメンバーにアクセスできますが、非静的であるため、外部クラスのインスタンスなしでは使用できません。外部クラスの状態を共有したい場合に役立ちます。

3. ローカルクラス

ローカルクラス（Local Class）は、メソッド内に定義される内部クラスです。メソッドのスコープ内でのみ使用可能で、主に特定のメソッドの処理に限定された補助的な機能を提供するために使用されます。ローカル変数と似た振る舞いを持ち、メソッドが終了するとローカルクラスも消滅します。

4. 匿名クラス

匿名クラス（Anonymous Class）は、インスタンス化の際に即座にクラスの定義が行われる一時的なクラスです。名前を持たず、一度きりの使用に適しています。インターフェースや抽象クラスのメソッドをオーバーライドする際に使用されることが多く、コードを簡潔に保つ目的で使われます。

内部クラスを適切に使用することで、外部クラスとの関係を明確にし、依存性注入の一部として利用することができます。

内部クラスを使ったDIの実装方法

内部クラスを使用した依存性注入（DI）は、外部クラスのインスタンスに依存するオブジェクトやサービスを効率的に管理するために役立ちます。内部クラスは、外部クラスのメンバーに直接アクセスできるため、クラス間の依存関係を簡潔に設定することができます。ここでは、具体的なコード例を通じて、内部クラスを利用したDIの実装方法を解説します。

実装例：内部クラスを利用した依存性注入

以下のコードは、外部クラス Car がエンジンオブジェクトを内部クラスとして管理し、DIを使用してエンジンを注入する例です。

public class Car {

    private Engine engine;

    // コンストラクタによる依存性注入
    public Car() {
        // エンジンのインスタンスを内部クラスで生成
        this.engine = new Engine();
    }

    public void start() {
        engine.startEngine();
    }

    // 非静的内部クラスとしてエンジンを定義
    class Engine {
        public void startEngine() {
            System.out.println("エンジンが始動しました");
        }
    }

    public static void main(String[] args) {
        Car car = new Car();
        car.start();
    }
}

コード解説

• 外部クラス Car は、車を表すクラスであり、その中でエンジンの依存性を管理しています。
• 内部クラス Engine は、エンジンの機能を定義する非静的内部クラスです。外部クラス Car のインスタンスに依存しており、エンジンの操作が車のインスタンス内でのみ行われます。
• コンストラクタ注入 によって、 Car のインスタンスが生成された際に、エンジンのインスタンスも同時に作成されます。この手法は、依存性注入の典型的なパターンです。

DIを利用した場合のメリット

• 疎結合： Car クラスは Engine に依存していますが、内部クラスを利用することで、外部クラスから依存オブジェクトにアクセスしやすく、依存関係を明確に保ちながら、柔軟に変更できます。
• カプセル化： Engine クラスは Car の内部でカプセル化されており、外部から直接アクセスできないため、適切に依存性を管理できます。

このように、内部クラスを活用したDIの実装は、特定のコンポーネントを効率的に管理し、コードの保守性を高める強力な手法です。

内部クラスを使ったDIの利点

Javaの内部クラスを利用した依存性注入（DI）は、コードの柔軟性や可読性を向上させるだけでなく、特定の状況で非常に便利な利点を提供します。ここでは、内部クラスを使用することで得られる主な利点を解説します。

1. 外部クラスとの強い結合性を維持しつつ、疎結合を実現

内部クラスは、外部クラスのメンバーに直接アクセスできるため、外部クラスとの関係が強く結びついています。しかし、その一方で、外部クラスの外部からの依存性は抑えられており、設計上は外部クラス内で閉じた形の疎結合を実現することができます。これにより、外部クラスのメンテナンスが簡単になります。

2. 外部クラスの状態と密接に連携

非静的な内部クラスは、外部クラスの状態（フィールドやメソッド）に簡単にアクセスできるため、依存するオブジェクトが外部クラスの内部状態に依存して動作するケースでは非常に便利です。これにより、複雑な依存関係をスムーズに処理することができます。

3. カプセル化によるセキュリティと可読性の向上

内部クラスは、外部クラスの一部として扱われるため、外部クラス外から直接アクセスすることができません。このカプセル化により、依存オブジェクトの管理が簡単になり、コード全体のセキュリティや可読性が向上します。例えば、外部クラスのみに関連する依存関係は、内部クラスに限定して管理できます。

4. コードの一貫性と管理の効率化

内部クラスを使用することで、関連する機能が1つのクラスにまとまり、コードの一貫性を保つことができます。特に、外部クラスが特定のオブジェクトに強く依存する場合、そのオブジェクトのクラス定義を外部クラス内に置くことで、全体のコードを効率的に管理できます。

5. テストの簡略化

内部クラスを使用したDIは、テスト環境においても利便性を提供します。外部クラスとその内部クラスを一体として扱えるため、依存関係の注入やモックの設定が簡略化され、テストコードの記述量が減少します。また、外部クラスとその依存関係が緊密に連携することで、単体テストの対象が明確になります。

内部クラスを使用したDIは、コードの再利用性や可読性を向上させつつ、依存関係を効率的に管理できる強力な手段です。適切に利用すれば、システム全体の構造をシンプルに保ちながら、柔軟な拡張を可能にします。

DIとテストの関係

依存性注入（DI）は、テストをしやすくするための設計手法としても重要な役割を果たします。特に、内部クラスを使ったDIは、依存関係の明示的な管理とカプセル化によって、テスト環境を簡略化し、柔軟なテストシナリオを実現します。ここでは、内部クラスを使用したDIがテストにどのように寄与するかを解説します。

1. 疎結合によるテスト可能性の向上

DIの主な目的は、クラス間の依存関係を外部から注入することにより、クラス同士を疎結合に保つことです。これにより、依存しているクラスをモック（仮想オブジェクト）に置き換えたり、スタブを利用したりすることが容易になります。特に、内部クラスを利用する場合、外部クラスが依存するクラスを簡単に注入できるため、テストが効率的になります。

例：モックを用いたテスト

以下は、内部クラス Engine をモックに置き換えてテストを行う例です。

public class CarTest {

    @Test
    public void testCarStart() {
        Car car = new Car();
        // モックのエンジンを注入
        Car.Engine mockEngine = Mockito.mock(Car.Engine.class);
        car.setEngine(mockEngine);

        car.start();

        // エンジンが開始されたことを検証
        Mockito.verify(mockEngine).startEngine();
    }
}

このように、モックを使用することで、本物の Engine クラスを用いずに Car クラスをテストできます。

2. テストデータの注入が簡単

内部クラスを使ったDIを利用することで、テスト対象のクラスに依存するデータやオブジェクトを簡単に注入できます。例えば、外部クラスが複数の依存オブジェクトを持つ場合、テスト環境に応じてそれらを適切に注入することができます。この柔軟性により、異なるシナリオのテストを効率的に実施可能です。

3. 依存オブジェクトの容易なモック化

内部クラスを使ったDIでは、依存オブジェクトが外部クラスに密接に関連しているため、モックを作成するのが比較的簡単です。依存するクラスやサービスをモックに置き換え、特定の振る舞いをシミュレーションすることが容易になるため、特にユニットテストやインテグレーションテストの実装がシンプルになります。

4. テスト対象のスコープの明確化

内部クラスは、外部クラスのコンテキスト内でのみ存在するため、テスト範囲が明確になります。外部クラスとその内部クラスの依存関係をはっきりさせることで、テスト対象のスコープを限定し、特定の機能やモジュールにフォーカスしたテストを行うことができます。

5. テストコードの簡略化

内部クラスを使用するDIは、依存関係を注入しやすくするだけでなく、テストコード自体を簡潔に保つ役割も果たします。特定の依存オブジェクトをインスタンス化する必要がなくなるため、テストコードの複雑さが減少し、メンテナンスがしやすくなります。

このように、DIとテストは密接に関連しており、特に内部クラスを使ったDIは、依存関係の管理を容易にし、テストの効率化と精度向上に大きく貢献します。

Javaの依存性注入フレームワークとの比較

内部クラスを使った依存性注入（DI）は、シンプルでJavaの標準機能を活用した実装方法ですが、依存性注入のフレームワークと比較すると、そのメリットとデメリットが浮き彫りになります。ここでは、Javaの代表的なDIフレームワークであるSpringやGuiceなどと、内部クラスを使ったDIとの比較を行い、それぞれの特徴を解説します。

1. SpringやGuiceの自動化されたDI

SpringやGuiceなどのフレームワークを使用すると、DIの設定や依存オブジェクトの管理が自動的に行われます。これにより、以下のようなメリットが得られます。

• 依存関係の自動解決: アノテーションやXML設定ファイルを用いて、依存オブジェクトを自動的に解決・注入します。これにより、開発者は手動で依存関係を設定する必要がなくなります。
• スコープ管理: これらのフレームワークは、オブジェクトのスコープ（シングルトンやプロトタイプなど）を容易に管理する機能を提供します。これにより、依存関係のライフサイクル管理が簡単に行えます。
• AOP（アスペクト指向プログラミング）との連携: SpringはDIとAOPを組み合わせ、より強力な機能拡張が可能です。

一方、内部クラスを使ったDIでは、これらの機能は標準で提供されておらず、手動で実装する必要があります。

2. 内部クラスDIのシンプルさ

内部クラスを使ったDIの最大の利点は、そのシンプルさにあります。フレームワークに依存せず、Javaの標準機能のみを使って実装できるため、設定が不要で、フレームワークの学習コストも発生しません。また、外部ライブラリに依存しないため、軽量なアプリケーションや単純な依存関係を持つプロジェクトに適しています。

• 軽量性: フレームワークを導入しなくてもDIを実現できるため、必要以上にプロジェクトが複雑になることを防ぎます。
• 可読性: 内部クラスを使ったDIは、そのクラス内で完結しているため、コードの可読性が高くなり、依存関係が一目でわかるという利点があります。

3. テストサポートの差異

SpringやGuiceのようなフレームワークでは、DIを利用したオブジェクトのモック化やテストサポートが強力です。例えば、Springでは @MockBean を使って、依存オブジェクトのモックを簡単に作成でき、テストフレームワークとの統合がスムーズです。これに対して、内部クラスを使ったDIでは、テストの際に手動でモックを作成する必要があり、やや複雑になることがあります。

4. スケーラビリティの違い

DIフレームワークは、大規模プロジェクトや複雑な依存関係を持つシステムに適しています。SpringやGuiceは、多数のコンポーネント間の依存関係を効率的に管理するためのツールや機能を備えており、スケーラビリティが高いのが特徴です。一方、内部クラスを使ったDIは、シンプルで小規模なプロジェクトには適していますが、大規模なシステムでは依存関係の管理が難しくなる可能性があります。

5. 初期設定と学習コスト

内部クラスを使ったDIは、特別な初期設定が不要で、すぐに使用できます。一方、SpringやGuiceは、DIの仕組みを理解するために一定の学習コストがかかり、初期設定にも時間を要することがあります。しかし、一度導入すると、自動化された管理機能や拡張性が役立ちます。

結論

内部クラスを使ったDIは、シンプルで軽量なプロジェクトに適していますが、複雑なシステムではSpringやGuiceのようなフレームワークを使用する方が効果的です。依存関係の自動管理やテストサポート、スケーラビリティを重視する場合はフレームワークを利用し、軽量で分かりやすい実装を求める場合は、内部クラスを使ったDIが有効です。

DIのベストプラクティス

内部クラスを使った依存性注入（DI）は、適切に実装すればコードの柔軟性とメンテナンス性を大きく向上させることができます。ただし、DIの設計や利用にはいくつかのベストプラクティスがあり、それらを理解し実践することが重要です。ここでは、内部クラスを用いたDIを効果的に活用するためのベストプラクティスを紹介します。

1. 明確な責任範囲を持たせる

依存性注入を行う際には、各クラスが明確な責任範囲を持つように設計することが重要です。内部クラスを使う場合、外部クラスと内部クラスの役割を明確に分け、依存関係を持つクラスが必要な機能だけに依存するように設計します。これにより、コードの理解が容易になり、依存関係の管理も簡単になります。

実践例

public class Car {
    private Engine engine;

    // DIによる責任分担
    public Car(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        engine.startEngine();
    }

    class Engine {
        public void startEngine() {
            System.out.println("エンジンが起動しました");
        }
    }
}

この設計では、 Car クラスは車全体の操作を担当し、 Engine クラスはエンジンの管理のみを担当しています。各クラスがそれぞれの責任範囲に従って分離されており、依存関係が整理されています。

2. 依存関係の数を最小限に抑える

DIを利用する際、クラスが依存するオブジェクトの数を最小限にすることが推奨されます。複数の依存関係があると、コードが複雑になり、メンテナンスが困難になります。内部クラスを使う場合も、依存するオブジェクトは外部クラスが必要とする最小限のものに絞り込み、余計な依存を避けることが重要です。

3. コンストラクタ注入を優先する

依存性を注入する方法として、コンストラクタ注入が最も安全で、効果的な方法です。コンストラクタ注入を使うことで、オブジェクトの生成時にすべての依存関係が確立され、未定義の依存が存在することを防ぎます。内部クラスを使う場合も、コンストラクタを通じて必要な依存オブジェクトを注入することで、外部クラスのインスタンスが常に正しい状態で生成されます。

コンストラクタ注入の例

public class Car {
    private Engine engine;

    // コンストラクタによる依存性注入
    public Car(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        engine.startEngine();
    }

    class Engine {
        public void startEngine() {
            System.out.println("エンジンが始動しました");
        }
    }
}

この例では、 Car クラスのインスタンスが生成されるときに、 Engine がコンストラクタを通して注入されます。これにより、 Car のオブジェクトは常に必要な依存関係を持つことが保証されます。

4. 不変オブジェクトを利用する

DIを使った設計では、できるだけ依存関係が注入された後は変更されないようにすることが推奨されます。不変オブジェクト（immutable object）として扱うことで、依存関係が変化するリスクを排除し、コードの予測可能性を高めることができます。内部クラスでも、依存オブジェクトを変更しないように設計し、必要に応じてオブジェクトを再生成するような設計を心がけます。

5. スコープを適切に管理する

DIを使用する場合、依存オブジェクトのライフサイクル管理も重要です。オブジェクトのスコープを適切に設定し、依存オブジェクトが必要以上に長く存在しないように管理します。内部クラスを使う場合、外部クラスのライフサイクルと密接に連携しているため、依存オブジェクトの寿命が外部クラスに適切に関連付けられているかを確認する必要があります。

6. 単一責任の原則を守る

各クラスが単一の責任を持つという設計原則（Single Responsibility Principle, SRP）を守ることは、DIのベストプラクティスの一つです。内部クラスも例外ではなく、1つのクラスが多くの役割を持つことなく、特定の機能に集中するように設計することで、依存関係が過剰にならないようにします。

これらのベストプラクティスを守ることで、内部クラスを使ったDIを効果的に利用し、拡張性とメンテナンス性の高いコードを実現できます。

応用例：実際のプロジェクトでのDI実装

内部クラスを利用した依存性注入（DI）は、さまざまなプロジェクトにおいて柔軟かつ効率的な設計を可能にします。ここでは、内部クラスを使ったDIの応用例として、現実のプロジェクトでどのように利用されるかを具体的に紹介します。

1. WebアプリケーションにおけるDIの利用

Webアプリケーションでは、複数のサービスやコンポーネントが依存し合いながら機能を提供します。例えば、ショッピングカートシステムでは、ユーザー認証、カート管理、支払い処理などの機能がそれぞれ依存関係を持ちます。ここでは、内部クラスを使ったDIの実装例を示します。

public class ShoppingCart {

    private final UserService userService;
    private final PaymentService paymentService;

    // コンストラクタによる依存性注入
    public ShoppingCart() {
        this.userService = new UserService();
        this.paymentService = new PaymentService();
    }

    public void checkout() {
        userService.verifyUser();
        paymentService.processPayment();
    }

    // 内部クラスでのUserServiceの定義
    class UserService {
        public void verifyUser() {
            System.out.println("ユーザー認証が完了しました");
        }
    }

    // 内部クラスでのPaymentServiceの定義
    class PaymentService {
        public void processPayment() {
            System.out.println("支払い処理が完了しました");
        }
    }

    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();
        cart.checkout();
    }
}

コード解説

• ShoppingCart クラスは、ユーザー認証や支払い処理などの複数の機能を統合しています。
• 内部クラスとして UserService と PaymentService を定義し、これらのサービスを外部クラス内でDIしています。
• checkout メソッドでは、ユーザー認証と支払い処理が順次行われます。

この例では、各機能（ユーザー認証や支払い）が ShoppingCart クラスの一部として密接に結びついており、内部クラスを使うことでこれらの依存関係がシンプルかつ明確に管理されています。

2. モバイルアプリでのDI活用例

モバイルアプリ開発では、機能のモジュール化が求められ、DIを使ってモジュール間の依存関係を管理することが一般的です。ここでは、アプリ内の通知機能を内部クラスを使って実装し、依存関係を管理する例を示します。

public class NotificationManager {

    private final PushNotificationService pushService;

    // コンストラクタ注入による依存性管理
    public NotificationManager() {
        this.pushService = new PushNotificationService();
    }

    public void sendNotification(String message) {
        pushService.sendPush(message);
    }

    // 内部クラスとしてPushNotificationServiceを定義
    class PushNotificationService {
        public void sendPush(String message) {
            System.out.println("プッシュ通知: " + message);
        }
    }

    public static void main(String[] args) {
        NotificationManager manager = new NotificationManager();
        manager.sendNotification("アップデートが完了しました");
    }
}

コード解説

• NotificationManager クラスは、アプリ内の通知を管理します。
• 内部クラス PushNotificationService は、プッシュ通知を送信するためのサービスを提供しています。
• NotificationManager クラスで PushNotificationService をDIし、通知機能を簡潔に実装しています。

この設計では、通知機能が NotificationManager 内にカプセル化され、他のクラスや機能と疎結合で運用できるように工夫されています。内部クラスを使うことで、依存するサービスが NotificationManager 内で適切に管理され、コード全体の可読性も向上しています。

3. デスクトップアプリでの内部クラスDIの活用

デスクトップアプリケーションでは、UI（ユーザインターフェース）とビジネスロジックが密接に連携します。内部クラスを使って、UIコンポーネントとロジックを効率的に分離し、DIを活用することが可能です。以下の例では、フォーム入力を管理するコンポーネントとその依存オブジェクトを内部クラスとして扱っています。

public class FormHandler {

    private final InputValidator validator;

    // コンストラクタ注入
    public FormHandler() {
        this.validator = new InputValidator();
    }

    public void handleSubmit(String input) {
        if (validator.validate(input)) {
            System.out.println("入力が有効です");
        } else {
            System.out.println("無効な入力です");
        }
    }

    // 内部クラスでバリデーションロジックを定義
    class InputValidator {
        public boolean validate(String input) {
            return input != null && !input.trim().isEmpty();
        }
    }

    public static void main(String[] args) {
        FormHandler handler = new FormHandler();
        handler.handleSubmit("ユーザー入力");
    }
}

コード解説

• FormHandler クラスは、フォームの送信処理を担当します。
• 内部クラス InputValidator は、入力のバリデーションロジックを持ちます。
• FormHandler が InputValidator をDIすることで、入力の検証とその処理が明確に分離されています。

この設計により、入力の処理とその検証を効率的に管理でき、依存関係を簡潔に扱うことができます。

結論

内部クラスを使ったDIは、シンプルかつ柔軟な依存関係管理を実現し、Web、モバイル、デスクトップアプリケーションにおいても効果的に利用できます。適切に設計することで、クラスの責任分担が明確になり、メンテナンス性や可読性も向上します。

内部クラスDIのデメリット

内部クラスを利用した依存性注入（DI）はシンプルで軽量な設計を可能にしますが、いくつかのデメリットや注意すべき点も存在します。ここでは、内部クラスDIの主なデメリットを解説します。

1. 外部クラスへの強い依存

内部クラスは、外部クラスのインスタンスに強く依存しているため、外部クラスが存在しないと内部クラスを使用できません。これにより、外部クラスの変更や再利用性が制限され、内部クラスと外部クラス間の結合度が高くなります。依存関係が強すぎると、後から設計を変更する際に問題が生じる可能性があります。

2. コードの肥大化

内部クラスを用いると、外部クラス内に多くの機能が含まれるため、コードが肥大化し、外部クラスが複雑になりがちです。特に、複数の依存オブジェクトを内部クラスとして扱う場合、外部クラスの役割が曖昧になり、可読性が低下する恐れがあります。

3. テストの複雑さ

内部クラスを使ったDIでは、依存オブジェクトが外部クラスのインスタンスに依存しているため、単体テストがやや複雑になることがあります。外部クラスをモック化しないと、内部クラスのテストが難しくなるため、テストコードの設計が煩雑になる場合があります。

4. スケーラビリティの問題

内部クラスを使ったDIは、小規模なプロジェクトやシンプルな設計には適していますが、大規模なプロジェクトではスケーラビリティに限界があります。依存関係が増加すると、内部クラスを使った方法では効率的に管理することが難しくなり、専用のDIフレームワーク（SpringやGuiceなど）の導入が必要となることがあります。

5. 外部アクセスの制限

内部クラスは外部クラスに閉じた存在であり、外部から直接アクセスできないため、場合によっては柔軟性が低下することがあります。例えば、内部クラスを他のモジュールやコンポーネントで再利用したい場合には、外部クラスごと再利用しなければならず、設計上の制約が発生します。

結論

内部クラスを利用したDIには、依存関係の管理がシンプルで手軽な一方、外部クラスへの依存性が強まることや、テストやスケーラビリティの面で課題があります。特に大規模なシステムや、依存関係が複雑なプロジェクトでは、専用のDIフレームワークの方が適していることが多いです。

演習問題

内部クラスを使った依存性注入（DI）の理解を深めるために、いくつかの演習問題に挑戦してみましょう。これらの問題は、DIの実装方法や内部クラスの役割を確認するのに役立ちます。

問題1: 基本的な内部クラスのDI実装

以下のコードは、 Printer クラスが内部クラス Ink に依存して動作するように設計されています。 Printer クラスのコンストラクタを使用して、 Ink の依存関係を注入し、 print メソッドを実行すると、「インクが十分です」と出力されるように実装してください。

public class Printer {

    private Ink ink;

    public Printer() {
        // Inkの依存性を注入してください
    }

    public void print() {
        ink.checkInk();
    }

    // 内部クラスInkの定義
    class Ink {
        public void checkInk() {
            System.out.println("インクが十分です");
        }
    }

    public static void main(String[] args) {
        Printer printer = new Printer();
        printer.print();
    }
}

ヒント:

• Printer のコンストラクタ内で、 Ink クラスのインスタンスを作成し、 ink フィールドに注入してください。

問題2: 複数の依存関係を持つ内部クラスのDI

次に、 Printer クラスが Ink クラスと Paper クラスの2つの依存関係を持つように拡張してください。 print メソッドで「インクが十分です」と「紙が十分です」を順番に出力するようにしてください。

public class Printer {

    private Ink ink;
    private Paper paper;

    public Printer() {
        // InkとPaperの依存性を注入してください
    }

    public void print() {
        ink.checkInk();
        paper.checkPaper();
    }

    // 内部クラスInkの定義
    class Ink {
        public void checkInk() {
            System.out.println("インクが十分です");
        }
    }

    // 内部クラスPaperの定義
    class Paper {
        public void checkPaper() {
            System.out.println("紙が十分です");
        }
    }

    public static void main(String[] args) {
        Printer printer = new Printer();
        printer.print();
    }
}

ヒント:

• コンストラクタ内で、 Ink と Paper のインスタンスをそれぞれ作成し、 ink と paper フィールドに注入してください。

問題3: テスト用モックの作成

上記の Printer クラスに対して、 Ink クラスと Paper クラスのモックを作成し、それぞれのメソッドが呼び出されることを確認する単体テストを書いてください。JUnitやMockitoを使用して、依存オブジェクトの挙動をモック化してテストを実行します。

public class PrinterTest {

    @Test
    public void testPrinter() {
        // モックのInkとPaperを作成し、Printerに注入
        // printメソッドの動作をテストする
    }
}

ヒント:

• Mockito.mock() を使って Ink と Paper のモックを作成し、それぞれのメソッドが呼び出されることを検証します。

これらの演習を通して、内部クラスを使ったDIの設計と実装に慣れ、依存関係を効率的に管理する方法を理解してください。

まとめ

本記事では、Javaの内部クラスを使った依存性注入（DI）の基本概念と具体的な実装方法について解説しました。内部クラスを利用することで、依存オブジェクトをシンプルに管理し、外部クラスとの強い結合を維持しながらも疎結合を実現できる点が強調されました。また、DIフレームワークとの比較、実際のプロジェクトでの応用例、さらにベストプラクティスや注意点についても触れました。内部クラスを効果的に活用することで、コードの可読性やテストのしやすさを向上させることが可能です。