Za kaj se uporabljata refleksija in anotacije?

Question

Accepted Answer

**Refleksija** programu omogoči, da **ob izvajanju inspicira in manipulira razrede, metode in polja** — tudi tiste, ki niso znane ob času prevajanja. **Anotacije** priložijo metapodatke kodi, ki jih orodja in ogrodja berejo (pogosto preko refleksije) za vodenje vedenja. Skupaj poganjajo večino Java ogrodij (Spring, JPA, JUnit).

## Refleksija — inspiciranje in priklic med izvajanjem

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

Refleksija omogoči kodi, da dinamično odkrije in uporablja tipe — instancira razrede po imenu, bere/nastavi polja, prikliče metode — kar je način, kako ogrodja delujejo na *vaših* razredih, ne da bi jih poznala vnaprej.

## Anotacije — metapodaci za orodja/ogrodja

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

## Opredelitev prilagojene anotacije

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

## Kako se kombinirajo: ogrodja berejo anotacije preko refleksije

```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 je osnovni mehanizem za Spring (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), validacijo (`@NotNull`) — skenirajo vašo opremljeno kodo preko refleksije in ustrezno povežejo vedenje.

## Kompromisi

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

## Zakaj je to pomembno

Refleksija in anotacije so **mehanizem za Java ekosistem ogrodij**.

Refleksija omogoči splošno, dinamično vedenje — inspiciranje in delo z razredi ob izvajanju brez znanja ob času prevajanja — kar je način, kako delujejo vrizani odvisnosti, ORM-ji (preslikava objektov v tabele), knjižnice za serijalizacijo (Jackson branje polj) in ogrodja za testiranje na vaših poljubnih razredih.

Anotacije zagotavljajo deklarativne metapodatke, ki jih ta orodja berejo (preko refleksije) za vodenje svojega vedenja, kar zamenja besedno konfiguriranje s preprostimi oznakami (`@Entity`, `@Autowired`, `@Test`).

Razumevanje jih demistificira, kako Spring, JPA in JUnit dosegajo svojo "magijo", vam omogoči, da zgradite svoja ogrodja, in razjasni kompromise zmogljivosti/varnosti (počasnejši, preskakuje preverjanje tipov), da jih uporabljate ustrezno.

To je napredeno, a bistveno znanje za globoko delo v Java ekosistemu.