À quoi servent la réflexion et les annotations ?

Question

Accepted Answer

**La réflexion** permet à un programme d'**inspecter et manipuler des classes, des méthodes et des champs à l'exécution** — même ceux inconnus au moment de la compilation. **Les annotations** attachent des métadonnées au code que les outils et frameworks lisent (souvent via la réflexion) pour piloter le comportement. Ensemble, elles alimentent une grande partie de la « magie » des frameworks Java (Spring, JPA, JUnit).

## Réflexion — inspection et invocation à l'exécution

```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
```

La réflexion permet au code de découvrir et utiliser les types dynamiquement — instancier des classes par nom, lire/modifier des champs, invoquer des méthodes — ce qui est comment les frameworks opèrent sur *vos* classes sans les connaître à l'avance.

## Annotations — métadonnées pour les outils/frameworks

```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
```

## Définir une annotation personnalisée

```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() { ... }
}
```

## Comment elles se combinent : les frameworks lisent les annotations via la réflexion

```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
    }
}
```

C'est le mécanisme fondamental derrière Spring (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), la validation (`@NotNull`) — ils scannent votre code annoté via la réflexion et câblent le comportement en conséquence.

## Les compromis

```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
```

## Pourquoi c'est important

La réflexion et les annotations sont les **mécanismes derrière l'écosystème des frameworks Java**.

La réflexion active un comportement générique et dynamique — inspecter et opérer sur les classes à l'exécution sans connaissance au moment de la compilation — c'est ainsi que l'injection de dépendances, les ORM (mappage des objets aux tables), les bibliothèques de sérialisation (Jackson lisant les champs) et les frameworks de test fonctionnent sur vos classes arbitraires.

Les annotations fournissent les métadonnées déclaratives que ces outils lisent (via la réflexion) pour piloter leur comportement, remplaçant la configuration verbeuse par de simples marqueurs (`@Entity`, `@Autowired`, `@Test`).

Les comprendre démystifie comment Spring, JPA et JUnit accomplissent leur « magie », vous permet de construire vos propres outils de type framework, et clarifie les compromis de performance/sécurité (plus lent, contourne la vérification des types) afin que vous les utilisiez de manière appropriée.

C'est une connaissance avancée mais essentielle pour travailler en profondeur dans l'écosystème Java.