ما هي أغراض الـ Reflection والـ Annotations؟

Question

Accepted Answer

**Reflection** يسمح لبرنامج أن **يفحص ويتعامل مع الفئات والطرق والحقول في وقت التشغيل** — حتى تلك غير المعروفة في وقت التجميع. **Annotations** تضع بيانات وصفية على الكود التي تقرأها الأدوات والأطر (غالباً عبر reflection) لدفع السلوك. معاً يشغلان الكثير من "سحر" أطر Java (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 للكود باكتشاف واستخدام الأنواع بشكل ديناميكي — إنشاء مثيلات من الفئات بالاسم، قراءة/تعيين الحقول، استدعاء الطرق — وهذا هو الكيفية التي تعمل بها الأطر على *فئاتك* دون معرفتها مسبقاً.

## Annotations — البيانات الوصفية للأدوات/الأطر

```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 مخصص

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

## كيف يتحدان: الأطر تقرأ annotations عبر 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 للأطر**.

يُمكّن Reflection السلوك العام والديناميكي — فحص والتعامل مع الفئات في وقت التشغيل دون معرفة وقت التجميع — وهذا هو كيفية عمل حقن التبعيات (dependency injection)، ORMs (ربط الكائنات بالجداول)، مكتبات التسلسل (Jackson تقرأ الحقول)، وأطر الاختبار على فئاتك التعسفية.

توفر Annotations البيانات الوصفية الإعلانية التي تقرأها هذه الأدوات (عبر reflection) لدفع سلوكها، مستبدلة الإعدادات الطويلة بعلامات بسيطة (`@Entity`, `@Autowired`, `@Test`).

فهم هذه يزيل الغموض عن كيفية تحقيق Spring و JPA و JUnit "السحر"، يسمح لك ببناء أدواتك الخاصة الشبيهة بالأطر، ويوضح التبديلات بين الأداء والسلامة (أبطأ، تتجاوز فحص النوع) حتى تستخدمها بشكل مناسب.

إنها معرفة متقدمة لكنها ضرورية للعمل بعمق في النظام البيئي Java.