
# Observer

購入が行われると、いくつかのことが起きなければなりません。確認のメール、在庫の更新、ロイヤルティポイントです。Observer パターンは、購入のコードが誰が反応するかを知らないようにします。このページでは、素の Dart と Spring for Dart でそれを示し、リスナーをもう一つ追加するのに何が必要かを示します。

例は次のクラスを共有します。

```dart
class Purchase {
  const Purchase(this.id, this.email, this.total);
  final String id;
  final String email;
  final double total;
}
```

## リスナー

**素の Dart、リスナーのリスト。** サービスはリストを保持し、誰かがそれを埋めなければなりません。

```dart
abstract interface class PurchaseListener {
  void onPlaced(Purchase purchase);
}

class Checkout {
  final _listeners = <PurchaseListener>[];

  void addListener(PurchaseListener listener) => _listeners.add(listener);

  void place(Purchase purchase) {
    // ... 購入を保存する
    for (final listener in _listeners) {
      listener.onPlaced(purchase);
    }
  }
}

void main() {
  final checkout = Checkout()
    ..addListener(ConfirmationMail(mailer))
    ..addListener(StockUpdate(warehouse));
}
```

**素の Dart、ストリーム。** `StreamController` がリストを置き換えます。リスナーは購読し、その購読をキャンセルしなければなりません。

```dart
class Checkout {
  final _placed = StreamController<Purchase>.broadcast();

  Stream<Purchase> get placed => _placed.stream;

  void place(Purchase purchase) {
    // ... 購入を保存する
    _placed.add(purchase);
  }

  Future<void> close() => _placed.close();
}

final subscription = checkout.placed.listen(
  (purchase) => mailer.send(purchase.email, 'Thank you'),
);
```

**Spring for Dart、注入されるリスト。** `List<PurchaseListener>` のパラメーターは、そのインターフェースを実装するすべての Bean を、`@Order` でソートして受け取ります。

```dart
@Service()
class Checkout {
  Checkout(this.listeners);

  final List<PurchaseListener> listeners;

  void place(Purchase purchase) {
    // ... 購入を保存する
    for (final listener in listeners) {
      listener.onPlaced(purchase);
    }
  }
}

@Component()
@Order(1)
class StockUpdate implements PurchaseListener {
  StockUpdate(this.warehouse);
  final Warehouse warehouse;

  @override
  void onPlaced(Purchase purchase) => warehouse.reserve(purchase.id);
}
```

変わること: 誰も `addListener` を呼びません。コンテナは各リスナーをそれ自身の依存とともに組み立て、リスト全体を `Checkout` に渡します。リスナーはアプリケーションと同じだけ生きるので、キャンセルすべき購読はありません。

## 新しいリスナーを追加する

**素の Dart。** 二つの編集です。新しいクラスと、リスナーを結び付ける場所です。

```dart
class LoyaltyPoints implements PurchaseListener {
  LoyaltyPoints(this.accounts);
  final Accounts accounts;

  @override
  void onPlaced(Purchase purchase) => accounts.addPoints(purchase.email, purchase.total ~/ 10);
}

// そして main、または Checkout を組み立てる場所で:
checkout.addListener(LoyaltyPoints(accounts));
```

**Spring for Dart。** 一つの編集です。新しいクラスだけです。

```dart
@Component()
class LoyaltyPoints implements PurchaseListener {
  LoyaltyPoints(this.accounts);
  final Accounts accounts;

  @override
  void onPlaced(Purchase purchase) => accounts.addPoints(purchase.email, purchase.total ~/ 10);
}
```

変わること: `Checkout`、`main`、他のリスナーには触れません。一つの環境でだけ必要なリスナーは `@Profile(['prod'])` を加え、テストも同じ方法でそれを外せます。コスト: 結び付けがもはや一か所では見えません。誰が聞いているかを見るには、`PurchaseListener` の実装を探します。

## 共有のインターフェースなしのイベント

リスナーが発行する側とインターフェースすら共有すべきでない場合があります。異なるモジュールが、それぞれ独自の方法で、異なるイベントに反応します。

**素の Dart。** 共有のイベントバスで、通常は `Object` のブロードキャストストリームを型でフィルターします。

```dart
final bus = StreamController<Object>.broadcast();

// 発行する側
bus.add(PurchasePlaced(purchase));

// リスナー。生成される場所はどこでも
bus.stream.listen((event) {
  if (event is PurchasePlaced) mail(event);
});
bus.stream.listen((event) {
  if (event is PurchasePlaced && event.purchase.total > 1000) alertSales(event);
});
```

**Spring for Dart。** `ApplicationEventPublisher` を注入し、任意のオブジェクトを発行します。`@EventListener()` を付け、その型のパラメーターを持つ任意の Bean のメソッドがそれを受け取ります。

```dart
class PurchasePlaced {
  const PurchasePlaced(this.purchase);
  final Purchase purchase;
}

bool isLarge(PurchasePlaced event) => event.purchase.total > 1000;

@Service()
class Checkout {
  Checkout(this.events);
  final ApplicationEventPublisher events;

  void place(Purchase purchase) {
    // ... 購入を保存する
    events.publishEvent(PurchasePlaced(purchase));
  }
}

@Component()
class SalesTeam {
  SalesTeam(this.mailer);
  final Mailer mailer;

  @EventListener(condition: isLarge) // 1000 を超える購入だけ
  @Order(1)                          // より大きい order のリスナーより前
  void onLarge(PurchasePlaced event) => mailer.send('sales@example.com', event.purchase.id);

  @EventListener()
  @Async()                           // publishEvent はこれを待たない
  Future<void> onAny(PurchasePlaced event) => mailer.send(event.purchase.email, 'Thank you');
}
```

変わること: バスはアプリケーションコンテキストそのものなので、生成し、受け渡し、閉じるべきグローバルなストリームはありません。条件は、型でチェックされるトップレベル関数です。`@Async()` が効果を持つのは、コンテキストに `TaskExecutor` Bean がある場合だけです (`spring_boot_starter_scheduling` が一つ登録します)。それがなければ、リスナーは `publishEvent` の中で実行されます。同じ `@EventListener` は、`ContextRefreshedEvent` のようなコンテキスト自身のイベントも受け取ります。

どちらの Spring の形を選ぶか: 発行する側がリスナーの存在を知り、順序どおりに呼ぶ (そしてそれを待つ) べき場合は注入されるリスト。発行する側が誰が反応するかを何も知るべきでない場合はイベントです。

## まとめ

| | リスナーのリスト | `StreamController` | Spring の `List<PurchaseListener>` | Spring のイベント |
|---|---|---|---|---|
| リスナーを結び付けるもの | 自分のコード、`addListener` | 各リスナーが購読する | コンテナ | コンテナ |
| 新しいリスナー | クラスと登録 | クラスと `listen` の呼び出し | クラス | `@EventListener()` を付けたメソッド |
| 順序 | 登録の順 | 未定義 | `@Order` | メソッドの `@Order` |
| フィルター | リスナーの中で | ストリームの `where` | リスナーの中で | `condition:` |
| 非同期 | 手で | 常にそう | 手で | `TaskExecutor` とともに `@Async()` |
| 後片付け | `removeListener` | 購読をキャンセルし、コントローラーを閉じる | なし | なし |
| ビルドの手順 | なし | なし | `build_runner` | `build_runner` |

ストリームは、UI が聞く値のように、一つのウィジェットや一つのクラスの中で時間とともに変わるデータには、引き続き適した道具です。Spring の形は、機能が追加されるにつれてリスナーのリストが増える、アプリケーション全体の反応のためのものです。

## 関連項目

- [制御の反転: 自ら拡張するパターン](../docs/inversion-of-control.md)
- [イベント](../components/spring-core-dart/events/index.md)
- [@EventListener](../components/spring-core-dart/events/event-listener.md)
- [@Async](../components/spring-core-dart/events/async.md)
- [@Autowired](../components/spring-core-dart/beans/autowired.md) (Bean のリスト)
