Reflection اور Annotations کس لیے استعمال ہوتے ہیں؟

Question

Accepted Answer

**Reflection** ایک پروگرام کو **runtime پر classes، methods، اور fields کو inspect اور manipulate کرنے** دیتا ہے — یہاں تک کہ وہ بھی جو compile time پر معلوم نہ ہوں۔ **Annotations** کوڈ میں metadata منسلک کرتے ہیں جو tools اور frameworks پڑھتے ہیں (اکثر reflection کے ذریعے) تاکہ behavior کو چلایا جا سکے۔ مل کر یہ Java کے framework "magic" کا زیادہ تر حصہ چلاتے ہیں (Spring، JPA، JUnit)۔

## Reflection — runtime inspection اور invocation

```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 کوڈ کو dynamically types کو دریافت کرنے اور استعمال کرنے دیتا ہے — classes کو نام سے instantiate کریں، fields پڑھیں/سیٹ کریں، methods invoke کریں — یہ وہی طریقہ ہے جس سے frameworks آپ کی classes پر کام کرتے ہیں بغیر انہیں پہلے سے جانے۔

## Annotations — tools/frameworks کے لیے metadata

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

## ایک custom annotation کی تعریف کرنا

```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 کے ذریعے annotations پڑھتے ہیں

```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`)، validation (`@NotNull`) کے پیچھے کا بنیادی نظریہ ہے — وہ reflection کے ذریعے آپ کے annotated کوڈ کو scan کرتے ہیں اور اسی کے مطابق behavior کو wire کرتے ہیں۔

## Trade-offs

```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 generic، dynamic behavior کو ممکن بناتا ہے — runtime پر classes کو inspect اور operate کرنا بغیر compile-time معلومات کے — یہی وہ طریقہ ہے جس سے dependency injection، ORMs (objects کو tables میں map کرنا)، serialization libraries (Jackson fields پڑھنا)، اور testing frameworks آپ کی arbitrary classes پر کام کرتے ہیں۔

Annotations یہ declarative metadata فراہم کرتے ہیں جو یہ tools reflection کے ذریعے پڑھتے ہیں تاکہ اپنی behavior کو چلائیں، verbose configuration کو سادہ markers سے بدل دیں (`@Entity`، `@Autowired`، `@Test`)۔

انہیں سمجھنا Spring، JPA، اور JUnit کی "magic" کو واضح کرتا ہے، آپ کو اپنے خود کے framework جیسے tools بنانے دیتا ہے، اور performance/safety trade-offs کو واضح کرتا ہے (سست، type checking کو bypass کرتا ہے) تاکہ آپ انہیں مناسب طریقے سے استعمال کریں۔

یہ advanced ہے لیکن Java ecosystem میں گہری کام کے لیے ضروری معلومات ہے۔