Apa guna reflection lan annotations?

Question

Accepted Answer

**Reflection** ndadekaken program bisa **mriksa lan manipulasi kelas, metode, lan kolom ing runtime** — malah sing ora dienal ing wektu kompilasi. **Annotations** nglempakake metadata menyang kode sing diarep tools lan frameworks (asring liwat reflection) kanggo ngatur tingkah laku. Bareng-bareng dikuwatake akeh "magic" framework Java (Spring, JPA, JUnit).

## Reflection — mriksa lan ngaktifake ing 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 ndadekaken kode bisa nemokake lan nggunakake tipe sacara dinamis — nggawe instance kelas miturut jeneng, maca/nyetel kolom, ngaktifake metode — iki cara frameworks bisa manggon klasis *mu* tanpa ngerti ing maju.

## Annotations — metadata kanggo tools/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
```

## Nggawe annotation khusus

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

## Carane bareng-bareng: frameworks maca annotations liwat 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
    }
}
```

Iki mekanisme utama ing mburi Spring (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), validasi (`@NotNull`) — scane kode sing merga annotation mu liwat reflection lan nggandeng tingkah laku.

## Tukar rugi

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

## Mulane penting

Reflection lan annotations punika **mesin nang urip ecosystem framework Java**.

Reflection ndadekaken tingkah laku umum, dinamis — mriksa lan manggon kelas ing runtime tanpa kawruh kompilasi-wektu — iki cara injection ketergantungan, ORM (mapping obyek menyang tabel), perpustakaan serialisasi (Jackson maca kolom), lan frameworks testing manggon klasis sembarang mu.

Annotations siyane metadata deklaratif sing tools iki maca (liwat reflection) kanggo ngatur tingkah laku, ngganti konfigurasi rumit karo tandha prasaja (`@Entity`, `@Autowired`, `@Test`).

Mengerti iki mbukak sandi carane Spring, JPA, lan JUnit oleh "magic" mau, dadikaken mu bisa nggawe tools kaya-kaya framework dhewe, lan jelaskake trade-offs performance/safety (luwih teles, langkahi type checking) supaya mu gunakake kanthi bener.

Pengetahuan maju, nanging wigati banget kanggo ngumbe ing ecosystem Java.