
# メソッドの周りのロジック

メソッドの中ではなく、多くのメソッドの周りに置くべきコードがあります。計測、ロギング、権限のチェック、トランザクション、キャッシュです。このページでは、素の Dart と Spring for Dart でメソッドの時間を計測し、その後同じ考え方を多くのクラスに広げます。

## 一つのメソッドを計測する

**素の Dart、デコレーター。** 二つ目のクラスが同じインターフェースを実装し、追加の作業を行い、本物を呼びます。計測しないものも含め、インターフェースのすべてのメソッドを書き出さなければなりません。

```dart
abstract interface class Purchases {
  Future<Purchase> place(Basket basket);
  Future<List<Purchase>> history(String email);
}

class TimedPurchases implements Purchases {
  TimedPurchases(this._inner);
  final Purchases _inner;

  @override
  Future<Purchase> place(Basket basket) async {
    final watch = Stopwatch()..start();
    try {
      return await _inner.place(basket);
    } finally {
      log.info('place: ${watch.elapsedMilliseconds} ms');
    }
  }

  @override
  Future<List<Purchase>> history(String email) => _inner.history(email);
}

final purchases = TimedPurchases(PurchaseService(repository));
```

**Spring for Dart、アスペクト。** アノテーションがメソッドを示し、一つのアスペクトが、示されたすべてのメソッドの周りで何が実行されるかを示します。

```dart
class Timed {
  const Timed();
}

@Aspect()
@Component()
class TimingAspect {
  @Around('@annotation(Timed)')
  Future<Object?> time(ProceedingJoinPoint call) async {
    final watch = Stopwatch()..start();
    try {
      return await (call.proceed()! as Future<Object?>);
    } finally {
      log.info('${call.signature.name}: ${watch.elapsedMilliseconds} ms');
    }
  }
}

@Service()
class PurchaseService implements Purchases {
  @Timed()
  @override
  Future<Purchase> place(Basket basket) async { /* ... */ }

  @override
  Future<List<Purchase>> history(String email) async { /* ... */ }
}
```

変わること: `PurchaseService` に残る追加のコードは一行、`@Timed()` だけです。ジェネレーターがデコレーターにあたるプロキシを書き出し、コンテナは `Purchases` や `PurchaseService` が求められるあらゆる場所にそれを注入します。クラスが一つだけなら、手書きのデコレーターもほぼ同じ長さで、誰でもステップ実行できる素のコードです。

## 多くのクラスを計測する

**素の Dart、ラッパー関数。** 高階関数を使えばサービスごとのデコレータークラスは不要になりますが、すべての呼び出し箇所でそれを使わなければなりません。

```dart
Future<T> timed<T>(String name, Future<T> Function() body) async {
  final watch = Stopwatch()..start();
  try {
    return await body();
  } finally {
    log.info('$name: ${watch.elapsedMilliseconds} ms');
  }
}

Future<Purchase> place(Basket basket) => timed('place', () async {
  // ... 本当の作業
});

Future<Stock> reserve(String sku) => timed('reserve', () async {
  // ... 本当の作業
});
```

**Spring for Dart、ポイントカット。** アスペクトが、クラス、名前、アノテーション、Bean 名で、自分でメソッドを選びます。クラスはまったく編集されません。

```dart
@Aspect()
@Component()
class TimingAspect {
  // すべての @Service クラスのすべての Future メソッド。
  @Around('@within(Service) && execution(Future *(..))')
  Future<Object?> time(ProceedingJoinPoint call) async {
    final watch = Stopwatch()..start();
    try {
      return await (call.proceed()! as Future<Object?>);
    } finally {
      log.info('${call.toShortString()}: ${watch.elapsedMilliseconds} ms');
    }
  }
}
```

その他のポイントカット: `execution(* PurchaseService.*(..))` (一つのクラスのすべてのメソッド)、`within(*Repository)` (名前によるクラス)、`bean(purchase*)` (名前による Bean)。複数を `&&`、`||`、`!` で組み合わせることができ、不正な式はメッセージとともにビルドや起動を止めます。

変わること: ラッパー関数は各メソッドの編集を必要とし、忘れたものは気付かれません。ポイントカットは、追加された新しいサービスも対象にします。コストは、ルールが別のファイルにあることです。`PurchaseService` だけを読んでも、それが計測されているかはわかりません。

## 組み込みのアスペクト

スターターは自身のアノテーションに同じ仕組みを使っているので、これらはアスペクトを書かずに動きます。

| アノテーション | パッケージ | メソッドの周りで |
|---|---|---|
| `@Transactional()` | `spring_boot_starter_data` | `Future` が完了するとコミットし、失敗するとロールバックする |
| `@Cacheable`、`@CachePut`、`@CacheEvict` | `spring_boot_starter_cache` | キャッシュされた結果を返す、または保存・削除する |
| `@PreAuthorize`、`@PostAuthorize`、`@Secured` | `spring_security_core` | 呼び出しの前後に呼び出し元の権限をチェックする |
| クラスに付けた `@Validated()` | `spring_core_dart` | 引数と結果の制約をチェックする |

```dart
@Service()
class PurchaseService {
  @Transactional()
  @PreAuthorize("hasRole('CUSTOMER')")
  Future<Purchase> place(Basket basket) async { /* ... */ }

  @Cacheable('purchases', key: '#email')
  Future<List<Purchase>> history(String email) async { /* ... */ }
}
```

素の Dart では、これらはそれぞれ、自分で書いてクラスと同期させ続けるデコレーターやラッパーです。

## プロキシのコスト

Spring for Dart には頼れる実行時のリフレクションがないため、ジェネレーターはアドバイスされる Bean ごとに、ビルド時にプロキシクラスを書き出します。それには次の帰結があります。

- **ビルドの手順。** アスペクトやアノテーションを追加したら、`dart run build_runner build` を実行します (または `watch` を動かしておきます)。それがないと、アドバイスは適用されません。
- **自己呼び出しはアドバイスをスキップします。** `place` が `this.history(...)` を呼ぶと、その呼び出しはデコレーターとまったく同じく、プロキシを通りません。内側の呼び出しにもアドバイスが必要な場合は、`@Lazy()` で Bean を自分自身に注入します。
- **クラスの形が重要です。** private なメンバーを持つ Bean クラスは生成されたサブクラスでプロキシ化され、`final` や `sealed` のクラスはそれが実装するインターフェースを通してのみプロキシ化されます。プロキシが不可能な場合、コンテキストは起動を拒否し、何を変えるべきかを伝えます。
- **一致しない Bean はコストがかかりません。** どのポイントカットも一致しない Bean はラップされません。

## まとめ

| | デコレータークラス | ラッパー関数 | Spring のアスペクト |
|---|---|---|---|
| アドバイスされるメソッドごとのコード | デコレーターの中の完全なメソッド | ラッパーの呼び出し | なし、またはアノテーション一つ |
| アドバイスされないメソッド | 手で転送しなければならない | なし | なし |
| 新しいクラス | それぞれ新しいデコレーター | メソッドごとの編集 | ポイントカットが対象にする |
| ルールの置き場所 | クラスの隣 | 各メソッド | アスペクトの中 |
| デバッグ | 素の呼び出し | 素の呼び出し | 生成されたプロキシを通して |
| 自己呼び出し | デコレーターをスキップする | ラップされる | アドバイスをスキップする |
| ビルドの手順 | なし | なし | `build_runner` |

デコレーターやラッパーは、一つか二つのクラス、または一つのインターフェースにだけ意味のあるロジックに適した選択です。アスペクトは、同じ関心事が多くのクラスに広がる場合や、組み込みのトランザクション、キャッシュ、セキュリティのアノテーションを使いたい場合に元が取れます。

## 関連項目

- [AOP](../components/spring-core-dart/aop/index.md)
- [@Pointcut とポイントカット式](../components/spring-core-dart/aop/pointcut.md)
- [アドバイス](../components/spring-core-dart/aop/advice.md)
- [AOP プロキシ](../components/spring-core-dart/aop/proxies.md)
- [制御の反転: 自ら拡張するパターン](../docs/inversion-of-control.md)
- [トランザクション](../components/spring-boot-starter-data/transactions.md)、[キャッシュのアノテーション](../components/spring-boot-starter-cache/annotations.md)、[メソッドセキュリティ](../components/spring-security-core/method-security.md)、[メソッドバリデーション](../components/spring-core-dart/validation/method-validation.md)
