Për çfarë përdoren reflection dhe annotations?

Question

Accepted Answer

**Reflection** lejon një program të **inspektojë dhe manipulojë klasa, metoda dhe fusha në kohën e ekzekutimit** — madje edhe ato të panjohura në kohën e kompilimit. **Annotations** bashkangjitojnë metadata në kod që mjetet dhe framework-et e lexojnë (shpesh përmes reflection) për të drejtuar sjelljen. Së bashku, ato fuqezojnë shumën e "magjisë" të framework-ut të Java (Spring, JPA, JUnit).

## Reflection — inspektimi dhe kërkesa në kohën e ekzekutimit

```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 lejon kodit të zbulojë dhe përdorë llojet dinamikisht — të instantzojë klasa sipas emrit, të lexojë/vendosë fusha, të evokojë metoda — e cila është mënyra se si framework-et operojnë në *klasat tuaja* pa i njohur më përpara.

## Annotations — metadata për mjete/framework-e

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

## Përkufizimi i një annotacioni të personalizuar

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

## Si ato kombinohen: framework-et lexojnë annotations përmes 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
    }
}
```

Este mekanizmi themelor pas Spring (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), validimit (`@NotNull`) — ato skanojnë kodin tuaj të annotuar përmes reflection dhe vendosin sjelljen në përputhje me atë.

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

## Pse ka rëndësi

Reflection dhe annotations janë **makineria pas ekosistemit të framework-ut të Java**.

Reflection mundëson sjelljen gjenerike, dinamike — inspektimin dhe operimin në klasa në kohën e ekzekutimit pa njohuri në kohën e kompilimit — e cila është mënyra se si dependency injection, ORM-et (shëndrrimi i objekteve në tabela), biblioteka serializimi (Jackson që lexon fusha) dhe framework-et e testimit funksionojnë në klasat tuaja arbitrare.

Annotations sigurojnë metadata deklarative që këto mjete e lexojnë (përmes reflection) për të drejtuar sjelljen e tyre, duke zëvendësuar konfigurimin të lodhshëm me shënuesa të thjeshtë (`@Entity`, `@Autowired`, `@Test`).

Komprensioni i tyre demistifikon se si Spring, JPA dhe JUnit arrijnë "magjisë" e tyre, ju lejon të ndërtoni mjete tuaja të ngjashme me framework-e dhe sqaron kompromishin e performancës/sigurisë (më e ngadalshme, kapërcen kontrollimin e llojit) kështu që i përdorni ato në mënyrë të përshtatshme.

Çshtë njohuri e avancuar por thelbësore për të punuar thellësisht në ekosistemit të Java.