Apa guna reflection dan annotations?

Question

IT Interview Practice · Accepted Answer

**Reflection** membolehkan program untuk **memeriksa dan memanipulasi kelas, kaedah, dan bidang pada masa runtime** — bahkan yang tidak diketahui pada masa kompilasi. **Annotations** melampirkan metadata pada kod yang dibaca oleh alat dan rangka kerja (sering kali melalui reflection) untuk mendorong tingkah laku. Bersama-sama mereka memberdayakan kebanyakan "keajaiban" rangka kerja Java (Spring, JPA, JUnit).

## Reflection — pemeriksaan dan penciptaan masa runtime

```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 membenarkan kod untuk menemui dan menggunakan jenis secara dinamis — menjadikan instance kelas mengikut nama, membaca/menetapkan bidang, menggunakan kaedah — iaitu cara rangka kerja beroperasi pada kelas *anda* tanpa mengetahuinya terlebih dahulu.

## Annotations — metadata untuk alat/rangka kerja

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

## Menentukan anotasi tersuai

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

## Cara mereka bersatu: rangka kerja membaca anotasi melalui 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
    }
}
```

Ini adalah mekanisme teras di belakang Spring (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), pengesahan (`@NotNull`) — mereka mengimbas kod teranotasi anda melalui reflection dan menghubungkan tingkah laku accordingly.

## Pertukaran

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

## Mengapa ia penting

Reflection dan annotations adalah **mesin di sebalik ekosistem rangka kerja Java**.

Reflection memungkinkan tingkah laku yang umum dan dinamis — memeriksa dan mengendalikan kelas pada masa runtime tanpa pengetahuan masa kompilasi — iaitu bagaimana suntikan kebergantungan, ORM (memetakan objek ke jadual), perpustakaan penjumlahan (Jackson membaca bidang), dan rangka kerja ujian beroperasi pada kelas sewenang-wenang anda.

Annotations menyediakan metadata deklaratif yang dibaca alat ini (melalui reflection) untuk mendorong tingkah laku mereka, menggantikan konfigurasi yang berlebihan dengan penanda ringkas (`@Entity`, `@Autowired`, `@Test`).

Memahami mereka mendemistifikasi cara Spring, JPA, dan JUnit mencapai "keajaiban" mereka, membolehkan anda membina alat seperti rangka kerja anda sendiri, dan menjelaskan pertukaran prestasi/keselamatan (lebih perlahan, memintas pemeriksaan jenis) supaya anda menggunakannya dengan wajar.

Ini adalah pengetahuan maju tetapi penting untuk bekerja dalam ekosistem Java.

Reflection — pemeriksaan dan penciptaan masa runtime

Annotations — metadata untuk alat/rangka kerja

Menentukan anotasi tersuai

Cara mereka bersatu: rangka kerja membaca anotasi melalui reflection

Pertukaran

Mengapa ia penting

Soalan berkaitan