حقن التبعية

جزء من قسم Object Oriented Programming في رحلة GO على Coddy — الدرس 45 من 107.

حقن التبعية (Dependency Injection) هي تقنية يستقبل فيها الـ struct تبعياته من الخارج بدلاً من إنشائها داخلياً. في لغة Go، تجعل الـ interfaces هذا النمط طبيعياً وقوياً.

بدلاً من كتابة تنفيذ محدد بشكل ثابت داخل الـ struct، فإنك تقبل واجهة (interface). يتيح لك هذا تبديل التنفيذات دون تغيير كود الـ struct:

type Notifier interface {
    Send(message string) string
}

type EmailNotifier struct{}
func (e EmailNotifier) Send(message string) string {
    return "Email: " + message
}

type SMSNotifier struct{}
func (s SMSNotifier) Send(message string) string {
    return "SMS: " + message
}

الآن قم بإنشاء هيكل (struct) يعتمد على الواجهة (interface)، وليس على نوع ملموس (concrete type):

type OrderService struct {
    notifier Notifier  // حقن التبعية عبر الواجهة
}

func NewOrderService(n Notifier) *OrderService {
    return &OrderService{notifier: n}
}

func (o *OrderService) PlaceOrder(item string) string {
    return o.notifier.Send("Order placed: " + item)
}

لا تعرف خدمة OrderService أو تهتم ما إذا كانت تستخدم البريد الإلكتروني أو الرسائل النصية القصيرة (SMS). تقوم بحقن التبعية عند إنشاء الخدمة:

func main() {
    emailService := NewOrderService(EmailNotifier{})
    fmt.Println(emailService.PlaceOrder("Book"))  // البريد الإلكتروني: تم تقديم الطلب: Book
    
    smsService := NewOrderService(SMSNotifier{})
    fmt.Println(smsService.PlaceOrder("Phone"))   // الرسائل النصية القصيرة: تم تقديم الطلب: Phone
}

هذا النهج يجعل الكود الخاص بك أكثر مرونة وقابلية للاختبار. أثناء الاختبار، يمكنك حقن مُبلغ وهمي (mock notifier) لا يرسل رسائل بالفعل. في بيئة الإنتاج، تقوم بحقن التنفيذ الحقيقي. يظل الـ struct دون تغيير في كلا السيناريوهين.

التحدي

سهل

لنقم ببناء نظام تسجيل (logging system) يوضح قوة حقن التبعية (dependency injection). ستقوم بإنشاء خدمة يمكنها كتابة السجلات إلى وجهات مختلفة - دون أن تعرف الخدمة أو تهتم بمكان ذهاب تلك السجلات بالفعل.

ستقوم بتنظيم الكود الخاص بك عبر ثلاثة ملفات:

logger.go: قم بتعريف واجهة Logger تتطلب تابع Log(message string) string. ثم قم بإنشاء تطبيقين مختلفين للمسجل (logger):
- ConsoleLogger مع حقل Prefix - يعيد تابع Log الخاص به [CONSOLE] [Prefix]: [message]
- FileLogger مع حقل Filename - يعيد تابع Log الخاص به [FILE:[Filename]] [message]
service.go: قم بإنشاء هيكل AppService يعتمد على واجهة Logger (وليس نوعاً ملموساً). قم بتضمين دالة منشئ NewAppService تقبل Logger وتعيد مؤشراً (pointer) إلى AppService. امنح AppService تابعاً يسمى DoWork(task string) string يستخدم المسجل المحقون لتسجيل الرسالة Processing: [task] ويعيد ما يعيده المسجل.
main.go: اقرأ التكوين من المدخلات، وأنشئ كلا نوعي المسجل، واحقن كل منهما في مثيلات AppService منفصلة، واستدعِ DoWork في كل خدمة مع المهمة المقدمة. اطبع النتيجة من كل استدعاء للخدمة.

سيتم توفير المدخلات التالية:

السطر 1: بادئة مسجل وحدة التحكم (Console logger prefix)
السطر 2: اسم ملف مسجل الملف (File logger filename)
السطر 3: المهمة المراد معالجتها

على سبيل المثال، إذا تم إعطاء INFO و app.log و user authentication، يجب أن يكون مخرجك:

[CONSOLE] INFO: Processing: user authentication
[FILE:app.log] Processing: user authentication

لاحظ كيف أن AppService لا يعرف ما إذا كان يسجل في وحدة التحكم أو في ملف - فهو ببساطة يستدعي Log على أي مسجل تم حقنه. هذه المرونة هي جوهر حقن التبعية (dependency injection): يعمل كود الخدمة نفسه مع تطبيقات تسجيل مختلفة تماماً.

ورقة مرجعية

حقن التبعية (Dependency Injection) هو أسلوب يتلقى فيه الهيكل (struct) تبعياته من الخارج بدلاً من إنشائها داخلياً. في لغة Go، تجعل الواجهات (interfaces) هذا النمط طبيعياً وقوياً.

قم بتعريف واجهة (interface) للتبعية:

type Notifier interface {
    Send(message string) string
}

قم بإنشاء تطبيقات ملموسة (concrete implementations) للواجهة:

type EmailNotifier struct{}
func (e EmailNotifier) Send(message string) string {
    return "Email: " + message
}

type SMSNotifier struct{}
func (s SMSNotifier) Send(message string) string {
    return "SMS: " + message
}

قم بإنشاء هيكل (struct) يعتمد على الواجهة، وليس على نوع ملموس:

type OrderService struct {
    notifier Notifier  // يتم حقن التبعية عبر الواجهة
}

func NewOrderService(n Notifier) *OrderService {
    return &OrderService{notifier: n}
}

func (o *OrderService) PlaceOrder(item string) string {
    return o.notifier.Send("Order placed: " + item)
}

قم بحقن التبعية عند إنشاء الخدمة:

emailService := NewOrderService(EmailNotifier{})
fmt.Println(emailService.PlaceOrder("Book"))  // Email: Order placed: Book

smsService := NewOrderService(SMSNotifier{})
fmt.Println(smsService.PlaceOrder("Phone"))   // SMS: Order placed: Phone

يجعل هذا النهج الكود أكثر مرونة وقابلية للاختبار من خلال السماح بتبديل التطبيقات المختلفة دون تغيير كود الهيكل (struct).

جرّب بنفسك

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	
	// قراءة بادئة مسجل وحدة التحكم (console logger prefix)
	prefix, _ := reader.ReadString('\n')
	prefix = prefix[:len(prefix)-1]
	
	// قراءة اسم ملف مسجل الملفات (file logger filename)
	filename, _ := reader.ReadString('\n')
	filename = filename[:len(filename)-1]
	
	// قراءة المهمة المطلوب معالجتها
	task, _ := reader.ReadString('\n')
	if len(task) > 0 && task[len(task)-1] == '\n' {
		task = task[:len(task)-1]
	}
	
	// TODO: إنشاء ConsoleLogger مع الـ prefix
	
	// TODO: إنشاء FileLogger مع الـ filename
	
	// TODO: إنشاء AppService مع حقن الـ ConsoleLogger
	
	// TODO: إنشاء AppService آخر مع حقن الـ FileLogger
	
	// TODO: استدعاء DoWork في كل خدمة مع المهمة وطباعة النتائج
	fmt.Println("result1")
	fmt.Println("result2")
}