Go’da Bağımlılık Enjeksiyonunu Kolaylaştıran Parsley Kılavuzu

Go dilinde bağımlılık yönetimi, uygulamalar büyüdükçe giderek karmaşıklaşabilir. Manuel bağımlılık enjeksiyonu, sisteminizdeki bileşenler arası ilişkileri elle tanımlamayı gerektirir. Bu yöntem, kodunuzun izlenebilirliğini artırsa da uzun vadede ciddi zorluklar yaratır:

• Tekrarlayan kurulum kodu: Projenizdeki düzinelerce hizmeti başlatmak için main.go dosyasında yüzlerce satır kod yazmanız gerekebilir.
• Yaşam döngüsü yönetimi: Veritabanı bağlantı havuzunun uygulama genelinde tekil olmasını sağlamak, ancak her istek için yeni bir günlükleyici oluşturmak manuel izleme gerektirir.
• Yeniden yapılanma zorluğu: Düşük seviyeli bir hizmete yeni bir bağımlılık eklemek, tüm ara katman üretici fonksiyonlarının güncellenmesini gerektirir.

Bu sorunlara yönelik çözümler arasında, google/wire gibi derleme zamanı kod üreten araçlar veya uber-go/dig gibi çalışma zamanı yansıma tabanlı enjeksiyon yöntemleri bulunuyor. Ancak Parsley, basit yapılandırmadan otomatik hizmet etkinleştirmeye kadar köprü kuran, yansıma tabanlı alternatif bir kütüphanedir.

Parsley Nedir ve Nasıl Çalışır?

Parsley, Go için tasarlanmış bir bağımlılık enjeksiyon (DI) çatısıdır. Yansıma (reflection) tabanlı çalışma prensibiyle, Inversion of Control (IoC) ilkelerini uygulamaya koyar. Hizmetlerin nasıl oluşturulması gerektiğini tanımlamanıza izin verirken, arka planda tüm bağlantıları ve yaşam döngülerini yönetir.

En önemli avantajlarından biri, derleme zamanı araçlarına kıyasla basitlik sunmasıdır. wire gibi araçlar ek dosyalar üreterek proje dizinini dağınık hale getirebilirken, Parsley doğrudan çalışma zamanı üzerinde çalışır. Bu da ek yapılandırma adımlarına gerek bırakmaz. Özellikle C# (.NET) veya Java (Spring) ekosistemlerinden gelen geliştiriciler için ideal bir seçimdir, çünkü kayıt tabanlı bir DI yaklaşımı sunar.

Temel Bileşenler: Kayıt Defteri ve Çözümleyici

Parsley’ın mimarisi iki temel bileşene dayanır:

• Hizmet Kayıt Defteri (Service Registry): Hizmet eşlemelerini, yapıcı fonksiyonlarını ve yaşam döngüsü davranışlarını tanımladığınız merkezi bir konteynırdır.
• Çözümleyici (Resolver): Bağımlılık grafiğini taramak ve hizmetleri ihtiyaç duyulduğunda oluşturmakla görevli bileşendir.

Bu sistem, üç farklı yaşam döngüsü davranışını destekler:

• Tekil (Singleton): Uygulama genelinde yalnızca bir kez oluşturulan ve paylaşılan örnek.
• Kapsamlı (Scoped): Belirli bir kapsam (örneğin, HTTP isteği) için bir kez oluşturulan örnek.
• Geçici (Transient): Her kullanımda yeni bir örnek oluşturulan hizmetler.

Uygulama Örneği: Basit Bir Selamlama Sistemini Kurmak

Parsley’ın nasıl çalıştığını görmek için basit bir selamlama uygulaması örneği inceleyelim. Bu örnekte, kullanıcıya selam veren bir Greeter hizmeti oluşturacağız.

Adım 1: Soyutlama Tanımlama

Öncelikle, Greeter arayüzünü tanımlayalım. Go dilinde bağımlılıkları yönetirken, soyutlamaları tüketici seviyesinde (veya ona yakın) tanımlamak, bileşenleri birbirinden ayırmak için iyi bir uygulamadır:

type Greeter interface {
    Greet(name string) string
}

Adım 2: Hizmetin Gerçekleştirilmesi

Ardından, somut bir greeter tipi oluşturalım. Bu yapı, dışa aktarılmayan (unexported) kalabilir, çünkü bir yapıcı fonksiyon aracılığıyla arayüz olarak dışa aktarılacaktır:

type greeter struct{}

func (s *greeter) Greet(name string) string {
    return fmt.Sprintf("Merhaba, %s!", name)
}

func NewGreeter() Greeter {
    return &greeter{}
}

Adım 3: Hizmetin Kaydedilmesi ve Çözümlenmesi

Son olarak, kayıt defterini kurup hizmeti geçici olarak kaydettiğimiz ve ardından çözümlediğimiz örneği inceleyelim:

package main

import (
    "context"
    "fmt"
    "github.com/matzefriedrich/parsley/pkg/registration"
    "github.com/matzefriedred/parsley/pkg/resolving"
)

func main() {
    // Kayıt defterini başlat
    registry := registration.NewServiceRegistry()

    // Yapıcı fonksiyonu kaydet
    _ = registration.RegisterTransient(registry, NewGreeter)

    // Çözümleyiciyi ve kapsamı oluştur
    resolver := resolving.NewResolver(registry)
    ctx := context.Background()
    scope := resolving.NewScopedContext(ctx)

    // Greeter hizmetini çözümle
    greeterService, err := resolving.ResolveRequiredServiceGreeter
    if err != nil {
        panic(err)
    }

    fmt.Println(greeterService.Greet("Parsley"))
}

Bu kod, uygulamayı başlattığınızda konsol çıktısı olarak Merhaba, Parsley! mesajını üretecektir.

Uygulama Esnasında Dikkat Edilmesi Gerekenler

Reflection tabanlı DI araçları kullanırken, aşağıdaki operasyonel hususları göz önünde bulundurmak önemlidir:

• Hata Yönetimi: Parsley, açık hata yönetimini teşvik eder. Kayıt defteri fonksiyonları hata döndürse de, yapıcı fonksiyonlarınızın başlatma sırasında başarısız olabileceğini de varsaymalısınız. Bu durumları error döndürecek şekilde tasarlamak gerekir.

• Başlangıç Performansı: Reflection, başlangıç aşamasında küçük bir performans maliyetine sahiptir. Veritabanı bağlantıları veya ağ işlemleriyle karşılaştırıldığında çoğu arka uç uygulaması için bu maliyet ihmal edilebilir düzeydedir. Ancak zamanlama açısından kritik uygulamalarda ölçülmesi önerilir.

• Bağlam Yönetimi: Kapsamlı hizmetlerin düzgün bir şekilde izlenebilmesi ve temizlenebilmesi için her zaman NewScopedContext kullanın. Eğer hizmetleriniz temizlik mantığı içeriyorsa, bu önemlidir.

Avantajlar ve Sınırlamalar

Parsley, basitlik ve kullanım kolaylığı üzerine odaklanmış olsa da, yansıma tabanlı DI araçlarının genel sınırlamalarını taşır:

• Derleme Zamanı vs. Çalışma Zamanı: wire gibi araçların aksine, Parsley eksik bağımlılıkları derleme zamanında yakalayamaz. Bu nedenle, eksik bağımlılıkları uygulamanızın başlangıcında veya CI/CD sürecinde tespit etmek için Parsley’ın yerleşik doğrulama özelliklerinden yararlanmanız gerekir.

• Yansımanın Performans Maliyeti: Go’nun yansıma mekanizması oldukça verimlidir, ancak doğrudan oluşturma yöntemine kıyasla daha yavaştır. Parsley, çözüm planlarını önbelleğe alarak bu maliyeti en aza indirmeye çalışır. Ancak bir türün ilk kez çözümlenmesi sırasında küçük bir gecikme yaşanabilir.

Sonuç: Basitlik ve Esneklik Arasında Denge

Parsley, Go uygulamalarında bağımlılık enjeksiyonunu basitleştirirken kod üretimi gibi ek karmaşıklıklara yol açmaz. Yapıcı fonksiyonlar ve otomatik yaşam döngüsü yönetimi sayesinde geliştiriciler, iş mantığına odaklanabilir ve hizmetler arasındaki bağlantıları elle yönetmek zorunda kalmaz.

Bu serinin bir sonraki bölümünde, Hizmet Kayıt Temelleri konusunu derinlemesine inceleyeceğiz. Mevcut örneklerin nasıl kaydedileceğini ve daha karmaşık yapıcı imzalarının nasıl ele alınacağını öğreneceğiz. Bu sayede, bağımlılık enjeksiyonunu Go projelerinizde daha etkili bir şekilde kullanabilirsiniz.