Reflection ve annotations ne için kullanılır?

Question

Accepted Answer

**Reflection**, bir programın **sınıfları, metodları ve alanları çalışma zamanında incelemesini ve manipüle etmesini** sağlar — derleme zamanında bilinmeyenleri de dahil olmak üzere. **Annotations** kod üzerine metadata ekler; araçlar ve frameworkler bunları (sıklıkla reflection aracılığıyla) okuyarak davranışı yönlendirir. Birlikte Java'nın framework "sihirinin" büyük kısmını güçlendirir (Spring, JPA, JUnit).

## Reflection — çalışma zamanında inceleme ve çağırma

```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, kod tarafından türleri dinamik olarak keşfedip kullanmasını sağlar — sınıfları isme göre örneklendir, alanları oku/yaz, metodları çağır — frameworklerin bu şekilde *senin* sınıflarında öncelikleri bilmeden çalışması budur.

## Annotations — araçlar/frameworkler için 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
```

## Özel bir annotation tanımlama

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

## Nasıl birleşirler: frameworkler reflection aracılığıyla annotation'ları okur

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

Bu, Spring (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), doğrulama (`@NotNull`) işlemlerinin temelindeki mekanizmadır — annotated kodunuzu reflection aracılığıyla tarar ve davranışı buna göre ayarlar.

## Tradeoff'lar

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

## Neden önemli

Reflection ve annotations Java'nın **framework ekosisteminin makinması** olan temel mekanizmadır.

Reflection, genel ve dinamik davranışı sağlar — sınıfları çalışma zamanında derleme-zamanı bilgisi olmaksızın inceleme ve işletme — bağımlılık enjeksiyonu, ORM'ler (nesneleri tablolara eşleme), serileştirme kütüphaneleri (Jackson alanları okuma) ve test çerçeveleri, sınırlandırılmamış sınıflarınız üzerinde çalışabilir.

Annotations, bu araçların okuduğu (reflection aracılığıyla) bildirimsel metaveri sağlar; davranışı yönlendirerek, ayrıntılı konfigürasyonun yerini basit işaretleyiciler (`@Entity`, `@Autowired`, `@Test`) alır.

Bunları anlamak Spring, JPA ve JUnit'in "sihirini" açık hale getirir, kendi framework benzeri araçlarını oluşturmanızı sağlar ve performans/güvenlik tradeoff'larını (daha yavaş, tür kontrolünü atlar) netleştirir; böylece bunları uygun şekilde kullanabilirsiniz.

İleri düzey olsa da Java ekosisteminde derinlemesine çalışmak için gerekli bilgidir.