Waarvoor worden reflection en annotaties gebruikt?

Question

Accepted Answer

**Reflection** stelt een programma in staat om **klassen, methoden en velden tijdens runtime te inspecteren en te manipuleren** — zelfs degene die op compilatietijd onbekend zijn. **Annotaties** voegen metadata toe aan code die tools en frameworks lezen (vaak via reflection) om gedrag aan te sturen. Samen vormen zij veel van Java's framework "magie" (Spring, JPA, JUnit).

## Reflection — runtime-inspectie en aanroeping

```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 stelt code in staat om types dynamisch te ontdekken en te gebruiken — klassen op naam instantiëren, velden lezen/instellen, methoden aanroepen — wat hoe frameworks werken op *jouw* klassen zonder deze van tevoren te kennen.

## Annotaties — metadata voor tools/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
```

## Een aangepaste annotatie definiëren

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

## Hoe zij samenwerken: frameworks lezen annotaties via reflection

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

Dit is het kernmechanisme achter Spring (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), validatie (`@NotNull`) — zij scannen je geannoteerde code via reflection en verbinden gedrag overeenkomstig.

## De afwegingen

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

## Waarom het belangrijk is

Reflection en annotaties vormen de **mechanica achter Java's framework-ecosysteem**.

Reflection maakt generiek, dynamisch gedrag mogelijk — klassen inspecteren en manipuleren tijdens runtime zonder compilatietijd-kennis — wat hoe dependency injection, ORMs (objecten aan tabellen koppelen), serialisatiebibliotheken (Jackson die velden leest) en testframeworks werken op jouw willekeurige klassen.

Annotaties bieden de declaratieve metadata die deze tools lezen (via reflection) om hun gedrag aan te sturen, vervangend uitgebreide configuratie met eenvoudige markeringen (`@Entity`, `@Autowired`, `@Test`).

Begrip ervan ontmystificeert hoe Spring, JPA en JUnit hun "magie" bereiken, stelt je in staat om je eigen framework-achtige tools te bouwen en verduidelijkt de prestatie-/veiligheidsafwegingen (langzamer, omzeilt typechecking) zodat je ze op passende wijze gebruikt.

Het is geavanceerd maar essentieel kennis voor diep werken in het Java-ecosysteem.