reflection と annotations は何に使われますか?

Question

Accepted Answer

**Reflection** により、プログラムは **クラス、メソッド、フィールドをランタイムで検査・操作** できます。コンパイル時に不明なものでも可能です。**Annotations** はコードにメタデータを付与し、ツールとフレームワークが（しばしば reflection 経由で）読み込んで動作を制御します。これら2つが Java フレームワークの「魔法」（Spring、JPA、JUnit）を支えています。

## Reflection — ランタイム検査と呼び出し

```java
// examine a class's structure at runtime, without knowing it at compile time
Class<?> clazz = Class.forName("com.example.User");

for (Field field : clazz.getDeclaredFields()) {
    System.out.println(field.getName() + ": " + field.getType());
}
for (Method method : clazz.getDeclaredMethods()) {
    System.out.println(method.getName());
}

// create instances and invoke methods dynamically
Object instance = clazz.getDeclaredConstructor().newInstance();
Method m = clazz.getMethod("setName", String.class);
m.invoke(instance, "Ann");        // call setName("Ann") reflectively

// even access private members (frameworks use this for DI)
Field f = clazz.getDeclaredField("secret");
f.setAccessible(true);             // bypass private access
```

Reflection により、コードは型を動的に発見・使用でき、名前によるクラスのインスタンス化、フィールドの読み取り・設定、メソッドの呼び出しが可能になります。これがフレームワークが事前に知らない *あなたの* クラスに対して動作する仕組みです。

## Annotations — ツール・フレームワーク用のメタデータ

```java
// built-in and framework annotations attach metadata
@Override               // compiler check
@Deprecated             // marks outdated API
@Entity                 // JPA: this class maps to a DB table
@Autowired              // Spring: inject a dependency here
@Test                   // JUnit: this method is a test
```

## カスタム annotation を定義する

```java
@Retention(RetentionPolicy.RUNTIME)   // available at runtime (readable via reflection)
@Target(ElementType.METHOD)
public @interface Loggable {
    String value() default "";
}

// using it
class Service {
    @Loggable("audit")
    void process() { ... }
}
```

## 組み合わせの仕組み：フレームワークが reflection 経由で annotation を読む

```java
// a framework scans methods, finds the annotation, and acts on it
for (Method m : clazz.getDeclaredMethods()) {
    if (m.isAnnotationPresent(Loggable.class)) {
        Loggable l = m.getAnnotation(Loggable.class);
        // wrap/log/intercept the method based on the metadata
    }
}
```

これが Spring（`@Autowired`、`@Component`）、JPA（`@Entity`）、JUnit（`@Test`）、検証（`@NotNull`）の中核メカニズムです。これらはあなたの annotation 付きコードを reflection でスキャンし、それに応じて動作を配線します。

## トレードオフ

```text
✗ Reflection is SLOWER than direct calls (runtime lookup), bypasses compile-time
  type checking, and can break encapsulation (setAccessible) → use judiciously
✓ But it's essential for generic frameworks, DI, serialization, testing tools
```

## なぜ重要なのか

Reflection と annotations は **Java フレームワーク・エコシステムの中核機構** です。

Reflection はジェネリックで動的な動作を実現します。コンパイル時の知識なしでランタイムにクラスを検査・操作することで、依存性注入、ORM（オブジェクトとテーブルのマッピング）、シリアライゼーション・ライブラリ（Jackson がフィールドを読む）、テストフレームワークがあなたの任意のクラスに対して動作する仕組みになっています。

Annotations は、これらのツールが（reflection 経由で）読み込むメタデータを提供し、動作を制御します。冗長な設定を、シンプルなマーカー（`@Entity`、`@Autowired`、`@Test`）に置き換えます。

これらを理解すると、Spring、JPA、JUnit がどのような「魔法」を実現しているのかが明確になり、独自のフレームワーク的なツールを構築でき、パフォーマンス・安全性のトレードオフ（遅い、型チェックをバイパス）が明確になり、適切に使用できるようになります。

高度な知識ですが、Java エコシステムで深く働く上で不可欠です。