Τι είναι η αντανάκλαση (reflection) και οι σχολιασμοί (annotations) και για τι χρησιμοποιούνται;

Question

Accepted Answer

**Reflection** επιτρέπει σε ένα πρόγραμμα να **επιθεωρεί και να χειρίζεται κλάσεις, μεθόδους και πεδία κατά την εκτέλεση** — ακόμα και αυτές που είναι άγνωστες κατά τη μεταγλώττιση. **Annotations** συνδέουν μεταδεδομένα στον κώδικα που εργαλεία και frameworks διαβάζουν (συχνά μέσω reflection) για να οδηγήσουν τη συμπεριφορά. Μαζί τους τροφοδοτούν πολλά από τα Java framework "μαγικά" (Spring, JPA, JUnit).

## Reflection — επιθεώρηση και κλήση κατά τη διάρκεια εκτέλεσης

```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 επιτρέπει στον κώδικα να ανακαλύψει και να χρησιμοποιήσει τύπους δυναμικά — να δημιουργήσει στιγμιότυπα κλάσεων ανά όνομα, να διαβάσει/ορίσει πεδία, να καλέσει μεθόδους — το οποίο είναι ο τρόπος με τον οποίο τα frameworks λειτουργούν στις *δικές σας* κλάσεις χωρίς να τις γνωρίζουν εκ των προτέρων.

## Annotations — μεταδεδομένα για εργαλεία/frameworks

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

## Ορισμός ενός προσαρμοσμένου σχολιασμού

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

## Πώς συνδυάζονται: τα frameworks διαβάζουν σχολιασμούς μέσω 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
    }
}
```

Αυτός είναι ο βασικός μηχανισμός πίσω από το Spring (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), επικύρωση (`@NotNull`) — σαρώνουν τον σχολιασμένο κώδικά σας μέσω reflection και συνδέουν τη συμπεριφορά ανάλογα.

## Οι αντικρουόμενες απαιτήσεις

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

## Γιατί έχει σημασία

Το Reflection και οι Annotations είναι το **μηχάνημα πίσω από το Java framework ecosystem**.

Το Reflection ενεργοποιεί γενική, δυναμική συμπεριφορά — επιθεώρηση και λειτουργία σε κλάσεις κατά την εκτέλεση χωρίς γνώση κατά τη μεταγλώττιση — το οποίο είναι ο τρόπος με τον οποίο λειτουργούν η εισαγωγή εξαρτήσεων, τα ORMs (αντιστοίχιση αντικειμένων με πίνακες), οι βιβλιοθήκες σειριοποίησης (όπως το Jackson που διαβάζει πεδία) και τα frameworks δοκιμών στις αυθαίρετες κλάσεις σας.

Οι Annotations παρέχουν τα δηλωτικά μεταδεδομένα που αυτά τα εργαλεία διαβάζουν (μέσω reflection) για να οδηγήσουν τη συμπεριφορά τους, αντικαθιστώντας τη λεπτολόγη ρύθμιση με απλούς δείκτες (`@Entity`, `@Autowired`, `@Test`).

Α κατανοήσετε τα παραπάνω θα αποκαλύψει τι σημαίνει το "μαγικό" των Spring, JPA και JUnit, θα σας επιτρέψει να δημιουργήσετε τα δικά σας εργαλεία που μοιάζουν με frameworks και θα διευκρινίσει τις αντικρουόμενες απαιτήσεις απόδοσης/ασφάλειας (πιο αργά, παρακάμπτουν τον έλεγχο τύπου) ώστε να τις χρησιμοποιείτε κατάλληλα.

Είναι προχωρημένη αλλά ουσιαστική γνώση για να δουλέψετε σε βάθος στο Java ecosystem.