
# get_it と依存性注入

`get_it` はサービスロケーターです。グローバルなレジストリーにオブジェクトを登録し、コードは必要なものをレジストリーに求めます。Spring for Dart は依存性注入のコンテナです。クラスは必要なものをコンストラクターに列挙し、コンテナがクラスを見つけ、正しい順序で組み立て、それらを渡します。

以下の各節は、一つのタスクを両方の方法で行います。Spring 側の背後にある考え方は [制御の反転と依存性注入](../docs/inversion-of-control.md) で説明しています。

## 登録と解決

**get_it。** すべてのサービスは手で登録します。通常は `main` が最初に呼ぶ一つのセットアップ関数の中です。

```dart
final getIt = GetIt.instance;

void setup() {
  getIt.registerSingleton<Clock>(SystemClock());
  getIt.registerSingleton<Mailer>(SmtpMailer());
}

void main() {
  setup();
  final mailer = getIt<Mailer>(); // または getIt.get<Mailer>()
  mailer.send('ada@example.com', 'Hello');
}
```

**Spring for Dart。** `@Service()` (または `@Component()`) で示されたクラスは Bean です。セットアップ関数はありません。ジェネレーターがビルド時にクラスを見つけます。

```dart
@Service()
class SystemClock implements Clock { /* ... */ }

@Service()
class SmtpMailer implements Mailer { /* ... */ }

@SpringBootApplication()
void main(List<String> args) => runApplication(args);
```

変わること: 登録のリストがなくなり、登録を忘れるリスクもなくなります。その代わり、アノテーションを追加・変更したら `dart run build_runner build` を実行し、コンテナは生成ファイル (`main.spring.dart`) から起動します。

## 三つの依存を持つサービス

**get_it。** 登録の順序が重要で、セットアップ関数はすべてのコンストラクター引数を繰り返します。

```dart
void setup() {
  getIt.registerSingleton<Clock>(SystemClock());
  getIt.registerSingleton<PurchaseRepository>(SqlPurchaseRepository());
  getIt.registerSingleton<Mailer>(SmtpMailer());
  getIt.registerSingleton<Checkout>(
    Checkout(getIt<PurchaseRepository>(), getIt<Mailer>(), getIt<Clock>()),
  );
}
```

クラスはメソッドの中で `getIt<Mailer>()` を呼ぶこともできます。そうするとコンストラクターはもはや依存を示さず、テストはクラスを生成する前にグローバルなレジストリーを埋めなければなりません。

**Spring for Dart。** コンストラクターが宣言のすべてです。

```dart
@Service()
class Checkout {
  Checkout(this.purchases, this.mailer, this.clock);

  final PurchaseRepository purchases;
  final Mailer mailer;
  final Clock clock;
}
```

変わること: 四つ目の依存の追加はコンストラクターのパラメーター一つで、編集すべきセットアップのコードはありません。コンテナが順序を決め、足りない依存や曖昧な依存は、クラスとパラメーターを示すメッセージで起動を止めます。`Checkout` は普通のクラスのままです。ユニットテストはコンテナなしで `Checkout(fakeRepo, fakeMailer, fixedClock)` を呼びます。

## 遅延シングルトンとファクトリー

**get_it。** `registerLazySingleton` は最初の `get` でオブジェクトを生成し、`registerFactory` は `get` のたびに新しいものを生成します。

```dart
getIt.registerLazySingleton<ReportGenerator>(() => ReportGenerator());
getIt.registerFactory<ShoppingCart>(() => ShoppingCart());
```

**Spring for Dart。** `@Lazy()` は最初の使用時に Bean を生成し、`@Scope(ScopeType.prototype)` は注入と検索のたびに新しいものを生成します。

```dart
@Component()
@Lazy()
class ReportGenerator { /* ... */ }

@Component()
@Scope(ScopeType.prototype)
class ShoppingCart {
  final items = <String>[];
}
```

変わること: ほとんどありません。違いが一つあります。遅延 Bean も起動時にチェックされる (存在し、一意でなければならない) ので、タイプミスはそれを必要とする画面が開いたときではなく、すぐに失敗します。コンストラクターのパラメーターに付けた `@Lazy()` は、最初の呼び出しで Bean を見つけるプロキシも注入し、依存の循環を断ち切ります。[@Lazy](../components/spring-core-dart/beans/lazy.md) を参照してください。

## 非同期の初期化

**get_it。** `registerSingletonAsync` は非同期のファクトリーを受け取り、`dependsOn` は非同期の手順を順序付け、`allReady()` はそのすべてを待ちます。

```dart
getIt.registerSingletonAsync<Database>(() => Database.open('shop.db'));
getIt.registerSingletonWithDependencies<PurchaseRepository>(
  () => SqlPurchaseRepository(getIt<Database>()),
  dependsOn: [Database],
);

Future<void> main() async {
  await getIt.allReady();
  runApp(const ShopApp());
}
```

**Spring for Dart。** `@PostConstruct()` メソッドは `Future` を返せます。`runApplicationAsync` は、アプリケーションが起動したとみなされる前に、そのすべてを待ちます。

```dart
@Component()
class Database {
  late final Connection connection;

  @PostConstruct()
  Future<void> open() async => connection = await Connection.open('shop.db');
}

@SpringBootApplication()
Future<void> main(List<String> args) => runApplicationAsync(args);
```

変わること: 非同期の手順は、セットアップ関数ではなく、それを必要とするクラスの中にあります。知っておくべきトレードオフがあります。非同期の初期化のコールバックは並行して実行され、起動が完了する前にすべて待たれますが、それら同士の順序は決まりません。Bean は、`open()` がまだ実行中かもしれない状態で `Database` を受け取るので、自身のコンストラクターや `@PostConstruct` で接続を使ってはいけません。get_it の `dependsOn` は、その順序を明示的に与えます。[@PostConstruct](../components/spring-core-dart/beans/post-construct.md) を参照してください。

## 環境ごとに実装を入れ替える

**get_it。** セットアップ関数の `if` が決めます。

```dart
void setup({required bool production}) {
  if (production) {
    getIt.registerSingleton<Mailer>(SmtpMailer());
  } else {
    getIt.registerSingleton<Mailer>(LogMailer());
  }
}
```

**Spring for Dart。** 各実装が、いつ適用されるかを示します。アクティブなプロファイルは、ファイル、環境変数、コマンドラインの `spring.profiles.active` から来ます。

```dart
@Component()
@Profile(['dev', 'test'])
class LogMailer implements Mailer { /* ... */ }

@Component()
@Profile(['!dev & !test'])
class SmtpMailer implements Mailer { /* ... */ }
```

両方の実装が存在し、一方が通常の選択である場合は、代わりにそれに `@Primary()` を付けます。もう一方は、`@Qualifier` が求める場所で注入されます。

変わること: 起動のコードに分岐がなくなり、三つ目の実装は三つ目のクラスになります。[@Profile](../components/spring-core-dart/beans/profile.md) と [@Primary](../components/spring-core-dart/beans/primary.md) を参照してください。

## テストで実装を入れ替える

**get_it。** 各テストの前にレジストリーをリセットし、フェイクを登録します。`allowReassignment` を使うと、テストは本物のセットアップの上に一つの登録を置き換えられます。

```dart
setUp(() async {
  await getIt.reset();
  setup();
  getIt.allowReassignment = true;
  getIt.registerSingleton<PaymentGateway>(FakeGateway());
});

test('checkout pays', () {
  getIt<Checkout>().pay(10);
  // ...
});
```

順序が重要です。`Checkout` は、遅延で登録されているか、呼び出し時に `getIt` を通してゲートウェイを読むのでない限り、`setup()` の中で本物のゲートウェイを使って組み立てられています。

**Spring for Dart。** `spring_boot_starter_test` は、一つの Bean を置き換えて本物のアプリケーションを起動します。元のものは Bean が一つも生成される前に取り除かれるので、それを注入するすべての Bean がフェイクを受け取ります。

```dart
void main() {
  final gateway = FakeGateway();
  final app = springBootTest(
    springApplication,
    profiles: ['test'],
    overrides: [BeanOverride<PaymentGateway>(gateway)],
  );

  test('checkout pays', () {
    app.getBean<Checkout>().pay(10);
    expect(gateway.charged, [10]);
  });
}
```

変わること: テストは、設定がバインドされ、Bean が互いを見つけることもチェックします。コストは、素のユニットテストより遅いテストと、`dart test` の前のビルドの手順です。[BeanOverride と @TestBean](../components/spring-boot-starter-test/bean-override.md) を参照してください。

## スコープ

**get_it。** `pushNewScope` はレジストリーの上にレイヤーを置きます。その中の登録は、`popScope` まで下のものを隠します。典型的な使い道は、ユーザーがログインしている間です。

```dart
void onLogin(User user) {
  getIt.pushNewScope(
    scopeName: 'session',
    init: (getIt) => getIt.registerSingleton<Session>(Session(user)),
  );
}

Future<void> onLogout() => getIt.popScope();
```

**Spring for Dart。** 独自のスコープは、自分で定義する区間ごとに一つのインスタンスを与えます。スコープ付きのプロキシがあれば、その Bean を注入するシングルトンは常に現在のインスタンスに到達します。

```dart
@Component()
@Scope('session', proxyMode: ScopedProxyMode.targetClass)
class Session {
  User? user;
}

// Bean が一つも生成される前にスコープを登録する。
@Component()
class SessionScope implements BeanFactoryPostProcessor {
  final scope = SimpleMapScope(conversationId: 'session');

  @override
  void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) =>
      beanFactory.registerScope('session', scope);

  // Session の @PreDestroy が実行される。次の使用では新しい Session を得る。
  void logout() => scope.destroy();
}
```

変わること: 二つは一対一には対応しません。get_it のスコープは実行時に任意の登録を置き換えられ、シンプルで柔軟です。Spring のスコープは、どの Bean がどのスコープに住むかをビルド時に固定し、シングルトンはプロキシを通して動き続けます。実行時に Bean の集合全体を変えることは、Spring for Dart が行うことではありません。プロファイルが起動時にそれを決めます。[@Scope](../components/spring-core-dart/beans/scope.md) を参照してください。

## まとめ

| タスク | get_it | Spring for Dart |
|---|---|---|
| 登録 | `registerSingleton`、手で、順序どおりに | `@Service()` / `@Component()`、ビルド時に見つかる |
| 解決 | どこでも `getIt<T>()` | コンストラクターのパラメーター。Bean の外では `getBean<T>()` |
| 三つの依存 | それぞれセットアップ関数で渡す | 三つのコンストラクターのパラメーター |
| 遅延 | `registerLazySingleton` | `@Lazy()` |
| 毎回新しいインスタンス | `registerFactory` | `@Scope(ScopeType.prototype)` |
| 非同期の初期化 | `registerSingletonAsync`、`dependsOn`、`allReady()` | `Future` の `@PostConstruct`、`runApplicationAsync` (順序なし) |
| 環境ごと | セットアップの `if` | `@Profile`、`@Primary` |
| テスト | `reset()`、`allowReassignment` | `BeanOverride`、`@TestBean` |
| スコープ | 実行時の `pushNewScope` / `popScope` | 独自のスコープとプロキシを使う `@Scope` |
| 足りない依存 | 最初の `get` でエラー | 起動が失敗し、クラスとパラメーターを示す |
| ビルドの手順 | なし | アノテーションの変更後に `build_runner` |

`get_it` は、少数のサービスを持つ小さなアプリ、ビルドの手順を望まない場合、実行時に登録を自由に入れ替える必要がある場合に適した選択です。Spring for Dart は、グラフが大きくなる場合、設定、プロファイル、テストがセットアップのコードを編集せずに実装を置き換えるべき場合、または同じコンテナでスターター (Web、Feign、キャッシュ、セキュリティ) を使いたい場合に元が取れます。
