Vad används reflektion och annotationer till?

Question

Accepted Answer

**Reflektion** låter ett program **inspektera och manipulera klasser, metoder och fält vid körning** — även sådana som är okända vid kompileringstid. **Annotationer** bifogar metadata till kod som verktyg och ramverk läser (ofta via reflektion) för att driva beteende. Tillsammans möjliggör de mycket av Javas ramverk "magi" (Spring, JPA, JUnit).

## Reflektion — inspektion och anrop vid körning

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

Reflektion låter kod upptäcka och använda typer dynamiskt — instansiera klasser efter namn, läsa/ställa in fält, anropa metoder — vilket är hur ramverk arbetar på *dina* klasser utan att känna dem på förhand.

## Annotationer — metadata för verktyg/ramverk

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

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

## Hur de kombineras: ramverk läser annotationer via reflektion

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

Detta är kärnmekanismen bakom Spring (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), validering (`@NotNull`) — de skannar din annoterad kod via reflektion och kopplar upp beteende därefter.

## Avvägningarna

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

## Varför det spelar roll

Reflektion och annotationer är **maskinerin bakom Javas ramverkekosystem**.

Reflektion möjliggör generiskt, dynamiskt beteende — inspektion av och drift på klasser vid körning utan kunskap vid kompileringstid — vilket är hur beroendeinjicering, ORM:er (mappning av objekt till tabeller), serialiseringsbibliotek (Jackson läser fält) och testramverk fungerar på dina godtyckliga klasser.

Annotationer tillhandahåller den deklarativa metadata som dessa verktyg läser (via reflektion) för att driva sitt beteende, och ersätter verbose konfiguration med enkla markörer (`@Entity`, `@Autowired`, `@Test`).

Att förstå dem gör det klart hur Spring, JPA och JUnit uppnår sin "magi", låter dig bygga dina egna ramverksliknande verktyg, och klargör prestanda-/säkerhetskompromisserna (långsammare, förbigår typkontroll) så du använder dem lämpligt.

Det är avancerat men väsentlig kunskap för att arbeta djupt i Javas ekosystem.