Annotation ve Reflection — Spring'in Sihri Nasıl Çalışır?

Bir depoda kutuların üstüne yapışkan notlar yapıştırıyorsun: “kırılır”, “önce bunu gönder”. Notlar kutuyu değiştirmez; onları okuyan depo görevlisi davranışını değiştirir.

Spring’in “sihir” gibi görünen her yeri, tam olarak bu iki şeyin birleşimidir: bir not ve o notu okuyan biri.

Annotation bir not, bir komut değil

@Override, @Service, @Transactional gibi @ ile başlayan her şey bir annotation?Terimin tanımını açannotationSınıfa, metoda ya da alana @ ile eklenen bir not. Tek başına kod çalıştırmaz; derleyici ya da Spring gibi bir çerçeve onu okuyup bir şey yapar.@Retention notun ne zamana kadar yaşadığını (SOURCE, CLASS, RUNTIME), @Target nerelere yapıştırılabileceğini belirler.Sözlükte gör →’dır. Sınıfa, metoda ya da alana eklenen bir bilgidir; tek başına hiçbir kod çalıştırmaz.

Onu kimin okuduğu, ne zaman işe yaradığını belirler:

• Derleyici okur: @Override yanlış yazılmış bir metodu derlerken yakalar.
• Bir çerçeve okur: Spring, program açılırken @Service ve @Transactional notlarını okur ve buna göre davranır.

Reflection: kodun kendine bakması

Reflection?Terimin tanımını açreflectionProgramın çalışırken kendi sınıflarını, metotlarını, alanlarını ve notlarını incelemesi; nesne kurup metot çağırabilmesi.Spring, JPA ve JUnit gibi çerçeveler senin sınıflarını önceden bilmeden bu yolla bulur ve çalıştırır. Derleyici kontrollerini atladığı için iş kodunda seyrek kullanılır.Sözlükte gör →, programın çalışırken kendi sınıflarına bakabilmesidir: hangi metotları var, hangi notlar yapıştırılmış, kurucusu ne istiyor? Hatta bir nesne kurup bir metodu adıyla çağırabilir.

1
Class<?> tip = OrderService.class;
2

3
for (Method metot : tip.getDeclaredMethods()) {
4
    boolean islemli = metot.isAnnotationPresent(Transactional.class);
5
    System.out.println(metot.getName() + " → işlemli mi: " + islemli);
6
}
7

8
Object nesne = tip.getDeclaredConstructor().newInstance();   // new yazmadan nesne

Spring de tam olarak bunu yapar: sınıfları bulur, notlarına bakar, nesnelerini kurar ve ihtiyaç duydukları parçaları verir.

Satır satır: kendi küçük Spring’imiz

Kendi notumuzu yazalım ve onu okuyan küçük bir okuyucu kuralım. Önce bir tahmin:

1. Varsayılanla oynat. @Retention yok: iki metodun da notu var, ama okuyucu hiçbirini görmedi.
2. “RUNTIME” seç. odemeAl çağrıldı; private iadeYap bulundu ama çağrılamadı.
3. “getMethods()” seç. private metot hiç listelenmedi; Object’ten gelen metotlar listelendi.
4. “getDeclaredMethods()“e dön ve “setAccessible(true)“yu aç. İki notlu metot da çağrıldı.

Spring bunu nasıl kullanır?

Spring başlarken belirttiğin paketleri tarar ve @Component, @Service, @Repository notlu sınıfları bulur. Sonra reflection ile nesnelerini kurar ve kurucularının istediği parçaları verir.

@Transactional gibi notlar için bir adım daha atar: nesnenin önüne bir proxy?Terimin tanımını açproxySpring'in bean'in yerine koyduğu sarmalayıcı nesne. `@Transactional` gibi anotasyonlar burada çalışır — çağrı proxy'den geçmezse hiçbir şey olmaz.Sözlükte gör → koyar. Her çağrı önce proxy’den geçer; proxy notu hatırlar, işlemi açar, metodu çağırır ve işlemi kapatır.

Bir bankada kendi notunu yazmanın en güzel örneği hassas verileri gizlemektir: T.C. kimlik numarası ve IBAN gibi alanlar işaretlenir, log’a yazılırken otomatik maskelenir.

1
@Retention(RetentionPolicy.RUNTIME)
2
@Target(ElementType.FIELD)
3
public @interface Sensitive {
4
}

1
public class Customer {
2

3
    private final String name;
4
    @Sensitive
5
    private final String nationalId;
6
    @Sensitive
7
    private final String iban;
8

9
    public Customer(String name, String nationalId, String iban) {
10
        this.name = name;
11
        this.nationalId = nationalId;
12
        this.iban = iban;
13
    }
14
}

1
public final class SafeLog {
2

3
    private SafeLog() {
4
    }
5

6
    public static String describe(Object target) throws IllegalAccessException {
7
        StringJoiner out = new StringJoiner(", ", target.getClass().getSimpleName() + "[", "]");
8
        for (Field field : target.getClass().getDeclaredFields()) {
9
            field.setAccessible(true);
10
            String value = String.valueOf(field.get(target));
11
            String shown = field.isAnnotationPresent(Sensitive.class) ? mask(value) : value;
12
            out.add(field.getName() + "=" + shown);
13
        }
14
        return out.toString();
15
    }
16

17
    // Keep only the last four characters visible.
18
    static String mask(String value) {
19
        if (value.length() <= 4) {
20
            return "****";
21
        }
22
        return "*".repeat(value.length() - 4) + value.substring(value.length() - 4);
23
    }
24
}

1
public class Main {
2
    public static void main(String[] args) throws Exception {
3
        Customer customer = new Customer("Ayşe", "12345678901", "TR000001");
4
        System.out.println(SafeLog.describe(customer));
5
        // Customer[name=Ayşe, nationalId=*******8901, iban=****0001]
6
    }
7
}

Tuzaklar

@Retention unutmak. Varsayılan CLASS olduğu için notun çalışma anında görünmez; okuyucu hiçbir şey bulamaz ve hata da vermez.

Notun kimin tarafından okunduğunu bilmemek. @Transactional bir proxy üzerinden çalışır; sınıfın kendi içinden yapılan çağrıda ya da private bir metotta etkisi olmaz.

Reflection’ı her yerde kullanmak. Derleyicinin kontrollerini atlar, private alanlara uzanabilir ve normal çağrıdan yavaştır. Çerçeve yazarken işe yarar; günlük iş kodunda genellikle gereksizdir.

Kendini sına