Cad a úsáidtear Reflection agus Annotations do?

Question

Accepted Answer

**Reflection** a cheadaíonn do chlár **ranganna, modhanna, agus réimsí a scrúdú agus a ionramháil ag am imealla** — fiú cinn nach raibh ar eolas ag am dlúthchomhlíonadh. **Annotations** ceanglaíonn siad sonraí meiteashonraí ar chód a léann uirlisí agus freamhascoil (go minic trí reflection) chun iompar a thiomáint. Le chéile, cumhachtaítear cuid mhór de "dhraíochta" freamhascoile Java (Spring, JPA, JUnit).

## Reflection — scrúdú agus gealladh ag am imealla

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

Ligann Reflection do chód cineálacha a fhionnadiú agus a úsáid go dinimiciúil — ranganna a neamhphacáistí de réir ainm, réimsí a léamh/a shocrú, modhanna a ghealladh — ar an gcaoi ar oibríonn freamhascoila ar do *ranganna* gan iad a bheith ar eolas roimh ré.

## Annotations — sonraí meiteashonraí do uirlisí/freamhascoila

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

## Annotation saincheaptha a shainiú

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

## Conas a chumainn siad: léann freamhascoila annotations trí 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
    }
}
```

Seo an meicníc bhunúsach taobh thiar de Spring (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), fíorúchán (`@NotNull`) — scannann siad do chód atá marcáilte ag reflection agus ceanglaíonn siad iompar dá réir.

## Na malartuithe

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

## Cén fáth a bhíonn tábhacht ann

Tá Reflection agus Annotations ar an **inneall taobh thiar de éiceachórais freamhascoile Java**.

Cumhachtaíonn Reflection iompar cineálach, dinimiciúil — ranganna a scrúdú agus a oibriú ag am imealla gan eolas an-díreach — ar an gcaoi ar oibríonn socrúchán inchuir-agus-aschur, ORMs (réada a mhapáil ar tháblaí), leabharlanna sriantháir (Jackson ag léamh réimsí), agus freamhascoila tástála ar do ranganna treallúsach.

Soláthaíonn Annotations an sonraí meiteashonraí deachúil a léann na huirlisí sin (trí reflection) chun a gcuid iompar a thiomáint, rud a bhíonn in ionad cumraíochta fadalach le marcanna shimplí (`@Entity`, `@Autowired`, `@Test`).

Dá dtuigeann tú iad, déantar soiléir an "dhraíochta" a bhíonn ag Spring, JPA, agus JUnit, ligint do do thúirlisí dhráma-cosúila a thógáil, agus soiléiríonn sé na malartuithe feidhmíochta/sábháilteachta (níos moille, foluain seiceáil cineáil) ionas gur úsáideann tú iad go cuí.

Tá sé ardleibhéal ach riachtanach ar an eolas do obair dhomhain san éiceachórais Java.