Dependency Inversion და Dependency Injection შორის ძირითადი განსხვავება რა არის?

დამოკიდებულების გადაბრუნების პრინციპი (Dependency Inversion) არის SOLID პრინციპებიდან ერთ-ერთი, რომელიც ამბობს, რომ მაღალი დონის მოდულები არ უნდა იყოს დამოკიდებული დაბალი დონის მოდულებზე, ორივე უნდა იყოს დამოკიდებული აბსტრაქციებზე. აბსტრაქციები არ უნდა იყოს დამოკიდებული დეტალებზე, დეტალები უნდა იყოს დამოკიდებული აბსტრაქციებზე.

Dependency Injection არის კონკრეტული ნიმუში ან ტექნიკა, რომელიც ამ პრინციპის განხორციელებას ემსახურება. ეს არის გზავნილი დამოკიდებულებების (ობიექტების) გადაცემის, კლასს ან ფუნქციას გარედან, არა მათი შიგნიდან შექმნის ნაცვლად.

მოყოლით:

• Dependency Inversion — ეს არის კონცეპტი ან დიზაინის პრინციპი.
• Dependency Injection — ეს არის ამ კონცეპტის განხორციელების გზა, როდესაც დამოკიდებულებები გადაეცემა გარედან.

მაგალითი Go-ში:

// აბსტრაქცია
 type Notifier interface {
    Notify(message string)
}

// კონკრეტული რეალიზაცია
 type EmailNotifier struct {}

func (e EmailNotifier) Notify(message string) {
    fmt.Println("ელექტრონული ფოსტის გაგზავნა შეტყობინებით:", message)
}

// მაღალი დონის მოდული
 type UserService struct {
    notifier Notifier // დამოკიდებულია აბსტრაქციაზე
}

// Dependency Injection კონსტრუქტორის მეშვეობით
func NewUserService(n Notifier) *UserService {
    return &UserService{notifier: n}
}

func (s *UserService) RegisterUser(name string) {
    // რეგისტრაციის ლოგიკა
    s.notifier.Notify("მომხმარებელი დარეგისტრირდა: " + name)
}

აქ, Dependency Inversion პრინციპი დაცულია, დამოკიდებულებით Notifier ინტერფეისზე, და Dependency Injection ხორციელდება კონკრეტული EmailNotifier-ის გადაცემით UserService კონსტრუქტორში.