Reflection da Annotations ana abin da ake amfani da su?

Question

Accepted Answer

**Reflection** yana ba wa programa damar **bincika da gyara classes, methods, da fields a lokacin aiki** — har ma waɗanda ba a san su a lokacin daidaitawa. **Annotations** suna haɗa metadata ga code wanda kayan aiki da frameworks suka karanta (sau da yawa ta hanyar reflection) don gida halayen aiki. Tare suna sarrafa yawancin Java's framework "sihiri" (Spring, JPA, JUnit).

## Reflection — bincika da kira a lokacin aiki

```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 yana ba wa code damar gano da amfani da nau'oi ta hanya ta dinamik — haɗa classes ta suna, karanta/saitowa fields, kira methods — wanda ke nan kaida da frameworks suke aiki akan *na ku* classes ba tare da sanin su a gidaje ba.

## Annotations — metadata don kayan aiki/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
```

## Ƙirƙira 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() { ... }
}
```

## Kaida da suka haɗa: frameworks suna karanta annotations ta hanyar 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
    }
}
```

Hai shine mahimmin jiya gida Spring (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), tantanin (`@NotNull`) — suna bincika code din ku mai annotation ta hanyar reflection kuma suna haɗa halayen aiki jiya.

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

## Dalilin da yake mahimmi

Reflection da annotations shine **jiyayen jiya Java's framework ecosystem**.

Reflection yana sarrafa halayen aiki ta gama-gari, ta dinamik — bincika da aiki akan classes a lokacin aiki ba tare da ilimin daidaitawa ba — wanda ke nan kaida da dependency injection, ORMs (haɗa objects zuwa tables), serialization libraries (Jackson karanta fields), da testing frameworks suke aiki akan classes din ku na bazuwa.

Annotations suna sarrafa metadata mai bayani waɗanda kayan aiki wadannan suke karanta (ta hanyar reflection) don gida halayen aiki, maye gurbin configuration mai cikakke da alama mai sauƙi (`@Entity`, `@Autowired`, `@Test`).
\