Na jaké účely se používá reflexe a anotace?

Question

Accepted Answer

**Reflexe** umožňuje programu **prozkoumávat a manipulovat třídy, metody a pole za běhu** — i ty, které byly neznámé v čase kompilace. **Anotace** připojují metadata ke kódu, která čtou nástroje a frameworky (často prostřednictvím reflexe) a řídí tak jejich chování. Dohromady poháňejí velkou část Java framework "magie" (Spring, JPA, JUnit).

## Reflexe — kontrola a vyvolání za běhu

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

Reflexe umožňuje kódu dynamicky objevovat a používat typy — vytvářet instance tříd podle názvu, čít a nastavovat pole, vyvolávat metody — což je způsob, jak frameworky pracují s *vašimi* třídami bez předchozí znalosti.

## Anotace — metadata pro nástroje a frameworky

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

## Definování vlastní anotace

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

## Jak se kombinují: frameworky čtou anotace prostřednictvím reflexe

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

Toto je základní mechanismus za Spring (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), validací (`@NotNull`) — skenují váš anotovaný kód prostřednictvím reflexe a odpovídajícím způsobem zapojují chování.

## Kompromisy

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

## Proč je to důležité

Reflexe a anotace jsou **strojovnou Java framework ekosystému**.

Reflexe umožňuje generické, dynamické chování — zkoumání a práci s třídami za běhu bez znalosti v čase kompilace — což je způsob, jak injekce závislostí, ORM (mapování objektů na tabulky), knihovny pro serializaci (Jackson čtoucí pole) a testovací frameworky pracují s vašimi libovolnými třídami.

Anotace poskytují deklarativní metadata, která tyto nástroje čtou (prostřednictvím reflexe) a řídí jejich chování, nahrazují podrobnou konfiguraci jednoduchými značkami (`@Entity`, `@Autowired`, `@Test`).

Porozumění jim demystifikuje, jak Spring, JPA a JUnit dosahují své "magie", umožňuje vám vytvořit vlastní podobné nástroje a objasňuje kompromisy výkonu a bezpečnosti (pomalejší, obchází kontrolu typů), takže je používáte vhodně.

Jde o pokročilé, ale zásadní znalosti pro hlubší práci v Java ekosystému.