Kam naudojami reflection ir annotations?

Question

Accepted Answer

**Reflection** leidžia programai **tirti ir manipuliuoti klasėmis, metodais ir laukais vykdant** — net ir tais, kurie buvo nežinomi kompiliavimo metu. **Annotations** prideda metaduomenis prie kodo, kuriuos skaito įrankiai ir sistemos (dažnai per reflection) norėdami valdyti elgesį. Kartu jie suteikia galią daugumai Java struktūrų "magijos" (Spring, JPA, JUnit).

## Reflection — vykdymo laiko tyrimas ir kvietimas

```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 leidžia kodui dinamiškai atžvelgti ir naudoti tipus — suinstancinti klases pagal pavadinimą, skaityti/nustatyti laukus, kviesti metodus — tai yra kaip sistemos veikia su *jūsų* klasėmis nepažinodamos jų iš anksto.

## Annotations — metaduomenys įrankiams/sistemoms

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

## Pasirinktinio annotation apibrėžimas

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

## Kaip jie veikia kartu: sistemos skaito annotations per 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
    }
}
```

Tai yra pagrindinė mechanika už Spring (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), patvirtinimo (`@NotNull`) — jos nuskaitote jūsų anotacinį kodą per reflection ir sukuria elgesį atitinkamai.

## Kompromisai

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

## Kodėl tai svarbu

Reflection ir annotations yra **žarnyne už Java struktūrų ekosistemos**.

Reflection suteikia bendrą, dinaminį elgesį — tiria ir manipuliuoja klasėmis vykdant be kompiliavimo laiko žinios — tai yra kaip priklausomybės injicirimas, ORM (objektų žemėlapis lentelėms), serializavimo bibliotekos (Jackson skaito laukus), ir testų sistemos veikia su jūsų savavališkais klasėmis.

Annotations suteikia deklaracinę metaduomenų, kuriuos šie įrankiai skaito (per reflection) norėdami valdyti elgesį, keičiant žodingą konfigūraciją paprastais žymenimis (`@Entity`, `@Autowired`, `@Test`).

Suprasti tai demistifikuoja kaip Spring, JPA, JUnit pasiekia jų "magiją", leidžia jums kurti savo struktūrinės sistemos įrankius, ir aiškina pelnytos/saugos kompromisus (lėčiau, išvengti tipo tikrinimo) kad jie būtų naudojami tinkamai.

Tai patartas bet reikalinga žinojimas giliai dirbant Java ekosistemoje.