なぜDIが必要？プログラムを分けて使いやすくする考え方を初心者向けに解説

新人と先輩の会話形式で理解しよう

新人

「先輩、Springを勉強しているとDI（依存性注入）っていう言葉がよく出てくるんですが、これは何なんですか？」

先輩

「DIは依存性注入と呼ばれる考え方で、プログラムの部品を外から渡してあげる仕組みだよ。Springのようなフレームワークでは、とても重要な機能なんだ。」

新人

「部品を外から渡す？普通は自分でnewして作るんじゃないんですか？」

先輩

「確かにそうだけど、そうするとクラス同士が強く結びついてしまって変更やテストがしづらくなるんだ。DIを使えば、クラス間の依存を減らして柔軟で保守しやすい設計にできるんだよ。」

新人

「なるほど！じゃあDIの基本から教えてください！」

1. DI（依存性注入）とは何か

DI（Dependency Injection、依存性注入）とは、あるクラスが必要とする他のクラス（依存オブジェクト）を、自分で作らずに外部から渡してもらう設計パターンです。通常のJavaプログラムでは、クラスの中でnewを使ってオブジェクトを作りますが、DIではそれをフレームワーク（例えばSpring）が代わりに行い、必要な場所に注入します。

例えば、ユーザー情報を扱うUserServiceクラスがUserRepositoryを必要とする場合、DIを使わなければ次のように書きます。


public class UserService {
    private UserRepository userRepository = new UserRepository();

    public void registerUser(String name) {
        userRepository.save(name);
    }
}

この場合、UserRepositoryの作り方が固定されてしまい、他の実装に変えるのが難しくなります。DIを使うと、外部からUserRepositoryを注入することで、実装の切り替えやテストの際の差し替えが簡単になります。

2. プログラムを分けることの意味（依存関係の分離と再利用性の向上）

プログラムを機能ごとに分けることは、保守性や再利用性を高めるための重要な設計の基本です。依存関係を分離することで、ある部分の変更が他の部分に影響しにくくなります。

例えば、ユーザー情報を保存する機能を、ファイル保存からデータベース保存に変えたい場合を考えてみましょう。依存性が強い設計だと、保存方法を変えるたびにメインのロジックを修正しなければなりません。しかし、DIを使って外部から保存用のクラスを注入していれば、メインの処理は一切変更せずに保存方法だけを差し替えることができます。

これにより、以下のようなメリットが得られます。

クラスごとの役割が明確になり、可読性が向上する
変更が発生しても影響範囲が限定されるため、バグのリスクが減る
同じ部品（クラス）を複数の場所で再利用できる

SpringのDI機能を使うと、この「部品を外から渡す」作業が自動で行われるため、開発者はビジネスロジックに集中できます。

以下は、Springの@Controllerを使い、@Autowiredで依存を注入する簡単な例です。


package com.example.demo.controller;

import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class UserController {

    private final UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/register")
    public String registerUser() {
        userService.registerUser("山田太郎");
        return "registerSuccess";
    }
}

このコードでは、UserControllerがUserServiceを直接生成せず、Springが自動的にインスタンスを注入しています。これが「プログラムを分ける」ことの実例であり、依存関係を分離することで再利用性と保守性が飛躍的に向上します。

3. DIを使った依存関係の注入の仕組み

DI（依存性注入）の仕組みは、フレームワークがオブジェクトの生成と管理を肩代わりし、必要な場所に自動で渡してくれる点にあります。Springの場合、この役割を果たすのがIoCコンテナと呼ばれる仕組みです。IoCコンテナは、アプリケーション起動時にすべての必要なオブジェクト（Bean）を生成し、それらの依存関係を解決したうえで、必要なクラスに注入します。

例えば、UserControllerがUserServiceを、さらにUserServiceがUserRepositoryを必要とする場合、Springは以下のような流れで処理します。

アプリ起動時にUserRepositoryのインスタンスを生成
UserRepositoryをコンストラクタの引数としてUserServiceを生成
UserServiceをコンストラクタの引数としてUserControllerを生成

開発者は「どうやって作るか」を書く必要がなく、「何が必要か」だけをクラスで宣言すればよいのです。これにより、依存関係を意識せずに部品を組み合わせることができます。

4. SpringでDIを実現する方法（@Autowiredやコンストラクタインジェクション）

SpringでDIを実現する代表的な方法は、@Autowiredアノテーションを使ったコンストラクタインジェクションです。これは依存関係を明確にし、必須であることをコンパイル時に保証できるため、推奨されています。

以下は、UserServiceをUserControllerにコンストラクタインジェクションする例です。


package com.example.demo.controller;

import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class UserController {

    private final UserService userService;

    @Autowired // Springが自動で依存関係を解決
    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/process")
    public String process() {
        userService.registerUser("田中太郎");
        return "processDone";
    }
}

このように書くことで、UserControllerはnew UserService()を使わずに済み、Springが必要なタイミングでUserServiceを注入してくれます。

一方、フィールドインジェクションでは、次のようにフィールドに直接@Autowiredを付与します。


@Autowired
private UserService userService;

ただし、フィールドインジェクションはテストのしやすさや依存関係の明示性に欠けるため、実務ではコンストラクタインジェクションが推奨されます。

5. DIを使わない場合の問題点と比較

DIを使わない場合、依存するクラスを自分で生成することになります。これには以下のような問題があります。

依存クラスの実装が固定されてしまい、変更や拡張が難しい
テスト時にモックやスタブに差し替えるのが困難
複数の場所で同じオブジェクト生成処理を繰り返すため、保守性が低下する

例えば、DIを使わない場合のコードは次のようになります。


package com.example.demo.controller;

import com.example.demo.service.UserService;
import com.example.demo.repository.UserRepository;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class UserControllerWithoutDI {

    private final UserService userService;

    public UserControllerWithoutDI() {
        // 依存関係を自分で生成
        UserRepository userRepository = new UserRepository();
        this.userService = new UserService(userRepository);
    }

    @GetMapping("/process")
    public String process() {
        userService.registerUser("佐藤花子");
        return "processDone";
    }
}

この設計だと、もしUserRepositoryの実装を変更する必要があれば、このクラスのコンストラクタを直接修正しなければなりません。これが複数クラスにまたがると、修正箇所が増えてバグの原因になります。

一方で、DIを使えば、依存クラスの生成や管理はすべてSpringに任せられます。実装を差し替えるときも、Springの設定やアノテーションを変更するだけで済み、クラス本体のコードを修正する必要はありません。結果として、プログラムの再利用性と保守性が大幅に向上します。

6. DIを使うメリット（保守性の向上、テストの容易化など）

DI（依存性注入）を使う最大のメリットは、プログラム全体の保守性とテストのしやすさが大幅に向上することです。依存関係を外部から注入することで、クラス内部の変更を最小限に抑えられます。特に大規模なSpringアプリケーションでは、後から機能を追加したり修正したりする場面が多く、そのたびにコード全体を見直す必要がある設計は非効率です。

また、テストコードを書くときにもDIは役立ちます。モック（テスト用の簡易オブジェクト）を用意して注入することで、外部リソース（データベースやAPI）に依存せずに動作確認ができます。これにより、開発スピードが上がるだけでなく、不具合の早期発見にもつながります。

例えば、UserServiceがUserRepositoryに依存している場合、テストでは次のようにモックを使えます。


UserRepository mockRepository = Mockito.mock(UserRepository.class);
UserService userService = new UserService(mockRepository);

このように、実際のデータベースアクセスを行わずにサービスのロジックを検証できます。これがDIを使うことによる大きなメリットのひとつです。

7. 実際のプロジェクトにおけるDIの活用例

Springを使った実際のプロジェクトでは、DIはほぼすべてのクラスで利用されます。特にサービス層とリポジトリ層の依存関係管理において威力を発揮します。

以下は、ユーザー登録機能を実装する例です。


package com.example.demo.service;

import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void registerUser(String name) {
        System.out.println("登録処理開始: " + name);
        userRepository.save(name);
    }
}


package com.example.demo.controller;

import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class UserController {

    private final UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/register")
    public String register() {
        userService.registerUser("山田花子");
        return "registerSuccess";
    }
}

この例では、UserServiceがUserRepositoryを、UserControllerがUserServiceをそれぞれDIによって受け取っています。これにより、依存オブジェクトを自分で生成せずに済み、実装の切り替えも容易になります。