Hvad bruges reflection og annotations til?

Question

Accepted Answer

**Reflection** lader et program **inspicere og manipulere klasser, metoder og felter ved kørselstid** — selv dem, der er ukendte ved kompileringstid. **Annotations** knytter metadata til kode, som værktøjer og frameworks læser (ofte via reflection) for at styre adfærd. Sammen driver de meget af Javas framework "magi" (Spring, JPA, JUnit).

## Reflection — inspektion og invokation ved kørselstid

```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 lader kode opdage og bruge typer dynamisk — instantiere klasser efter navn, læse/sætte felter, invoker metoder — som er sådan frameworks opererer på *dine* klasser uden at kende dem på forhånd.

## Annotations — metadata til værktøjer/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
```

## Definer en brugerdefineret 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() { ... }
}
```

## Hvordan de kombineres: frameworks læser annotations 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
    }
}
```

Dette er den centrale mekanisme bag Spring (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), validering (`@NotNull`) — de scanner din annoterede kode via reflection og sætter adfærd op derefter.

## Afvejningerne

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

## Hvorfor det betyder noget

Reflection og annotations er **maskineriet bag Javas framework-økosystem**.

Reflection muliggør generisk, dynamisk adfærd — at inspicere og operere på klasser ved kørselstid uden kompileringstidsvidenskab — som er hvordan dependency injection, ORMs (mapping objekter til tabeller), serialiseringsbiblioteker (Jackson læser felter) og testningsframeworks fungerer på dine vilkårlige klasser.

Annotations giver de deklarative metadata, disse værktøjer læser (via reflection) for at styre deres adfærd, og erstatter ordrig konfiguration med simple markører (`@Entity`, `@Autowired`, `@Test`).

At forstå dem afmystificerer, hvordan Spring, JPA og JUnit opnår deres "magi," lader dig bygge dine egne framework-lignende værktøjer, og præciserer ydelses-/sikkerheds-afvejningerne (langsommere, omgår typekontrol) så du bruger dem passende.

Det er avanceret men væsentlig viden for at arbejde dybere i Javas økosystem.