Hva brukes reflection og annotations til?

Question

Accepted Answer

**Reflection** lar et program **inspisere og manipulere klasser, metoder og felt under kjøring** — selv de som er ukjente ved kompileringstid. **Annotations** legger til metapdata til kode som verktøy og rammeverk leser (ofte via reflection) for å styre oppførselen. Sammen driver de mye av Javas rammeverk "magi" (Spring, JPA, JUnit).

## Reflection — kjøringstidsinspeksjon og invokasjon

```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 lar kode oppdage og bruke typer dynamisk — instansiere klasser etter navn, lese/sette felt, invokere metoder — som er hvordan rammeverk opererer på *dine* klasser uten å kjenne dem på forhånd.

## Annotations — metapdata for verktøy/rammeverk

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

## Å definere en egendefinert 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: rammeverk leser 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 kjernemekanismen bak Spring (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), validering (`@NotNull`) — de skanner din annoterte kode via reflection og setter opp oppførsel deretter.

## Avveiningene

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

Reflection og annotations er **maskineriet bak Javas rammeverk-økosystem**.

Reflection muliggjør generisk, dynamisk oppførsel — inspeksjon og drift av klasser under kjøring uten kompileringstidskunnskap — som er hvordan dependency injection, ORMs (kartlegging av objekter til tabeller), serialiseringsbiblioteker (Jackson som leser felt) og testingsrammeverk fungerer på dine vilkårlige klasser.

Annotations gir metapdata disse verktøyene leser (via reflection) for å styre deres oppførsel, og erstatter omstendelig konfigurering med enkle markører (`@Entity`, `@Autowired`, `@Test`).

Å forstå dem avmystifiserer hvordan Spring, JPA og JUnit oppnår deres "magi", lar deg bygge dine egne rammeverk-lignende verktøy, og avklarer ytelse/sikkerhet-avveiningene (langsommere, omgår typekontroll) slik at du bruker dem på passende måte.

Det er avansert men essensielt kunnskap for å jobbe dypt i Java-økosystemet.