Reflection र annotations लाई के काम मा लगाइन्छ?

Question

Accepted Answer

**Reflection** ले एक प्रोग्रामलाई **runtime मा classes, methods, र fields को निरीक्षण र हेरफेर गर्न अनुमति दिन्छ** — यहाँ कि compile time मा अज्ञात भएका पनि। **Annotations** ले कोडमा metadata जोडिन्छ जो tools र frameworks ले (अक्सर reflection माध्यमबाट) पढ्छन् र व्यवहार चलाउन। सँगै तिनीहरूले Java को अधिकांश framework "magic" (Spring, JPA, JUnit) को शक्ति दिन्छन्।

## Reflection — runtime निरीक्षण र 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 ले कोडलाई प्रकारहरू गतिशील रूपमा खोज्न र प्रयोग गर्न दिन्छ — नामद्वारा 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`) को पछाडिको मूल तंत्र हो — तिनीहरू तपाईंको annotated कोड reflection माध्यमबाट स्क्यान गर्छन् र व्यवहार अनुसार तार गर्छन्।

## 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, गतिशील व्यवहार सक्षम गर्छ — compile-time ज्ञान बिना runtime मा classes को निरीक्षण र संचालन गर्दै — जो कसरी dependency injection, ORMs (objects लाई तालिकामा mapping), serialization libraries (Jackson fields पढ्दै), र testing frameworks तपाईंको स्वेच्छाचारी classes मा काम गर्छन्।

Annotations ले declarative metadata यो tools पढ्छन् (reflection माध्यमबाट) उनीहरूको व्यवहार चलाउन, verbose configuration लाई सरल markers (`@Entity`, `@Autowired`, `@Test`) द्वारा प्रतिस्थापित गर्दै।

तिनीहरूलाई बुझ्दै Spring, JPA, र JUnit को "magic" लाई रहस्यमुक्त गर्छ, तपाईंलाई आफ्नो framework जस्तै tools निर्माण गर्न दिन्छ, र performance/safety trade-offs (ढिलो, type checking बाइपास गर्छ) स्पष्ट गर्छ ताकि तपाईं तिनीहरूलाई उपयुक्त रूपमा प्रयोग गर्नुहुन्छ।

यो उन्नत तर Java ecosystem मा गहिराइमा काम गर्नको लागि आवश्यक ज्ञान हो।