Do czego służą refleksja (reflection) i adnotacje (annotations)?

Question

Accepted Answer

**Refleksja** pozwala programowi **badać i manipulować klasami, metodami oraz polami w czasie wykonania** — nawet tymi nieznanymi w czasie kompilacji. **Adnotacje** dołączają do kodu metadane, które narzędzia i frameworki odczytują (często za pomocą refleksji), aby sterować zachowaniem. Razem napędzają znaczną część „magii" frameworków Javy (Spring, JPA, JUnit).

## Refleksja — inspekcja i wywoływanie w czasie wykonania

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

Refleksja pozwala kodowi dynamicznie odkrywać i używać typów — tworzyć instancje klas po nazwie, odczytywać/ustawiać pola, wywoływać metody — i właśnie dzięki temu frameworki operują na *Twoich* klasach, nie znając ich z wyprzedzeniem.

## Adnotacje — metadane dla narzędzi/frameworków

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

## Definiowanie własnej adnotacji

```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 się łączą: frameworki odczytują adnotacje za pomocą refleksji

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

To jest fundamentalny mechanizm stojący za Springiem (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), walidacją (`@NotNull`) — skanują one Twój opatrzony adnotacjami kod za pomocą refleksji i odpowiednio konfigurują zachowanie.

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

## Dlaczego to ważne

Refleksja i adnotacje to **maszyneria stojąca za ekosystemem frameworków Javy**.

Refleksja umożliwia generyczne, dynamiczne zachowanie — inspekcję i operowanie na klasach w czasie wykonania bez wiedzy z czasu kompilacji — i właśnie dzięki temu wstrzykiwanie zależności, ORM-y (mapowanie obiektów na tabele), biblioteki serializacji (Jackson odczytujący pola) oraz frameworki testowe działają na Twoich dowolnych klasach.

Adnotacje dostarczają deklaratywnych metadanych, które te narzędzia odczytują (za pomocą refleksji), aby sterować swoim zachowaniem, zastępując rozwlekłą konfigurację prostymi znacznikami (`@Entity`, `@Autowired`, `@Test`).

Zrozumienie ich demistyfikuje sposób, w jaki Spring, JPA i JUnit osiągają swoją „magię", pozwala budować własne narzędzia w stylu frameworków oraz wyjaśnia kompromisy dotyczące wydajności/bezpieczeństwa (wolniejsze, pomijanie kontroli typów), abyś używał ich w odpowiedni sposób.

To wiedza zaawansowana, ale niezbędna do głębokiej pracy w ekosystemie Javy.