რა არის კონტროლის ინვერსია (IoC) და დამოკიდებულებების ინექცია?

მართვის ინვერსია (IoC) — ეს არის საერთო დიზაინის პრინციპი, რომლის მიხედვითაც პროგრამის მართვის ნაკადი იცვლება: ნაცვლად იმისა, რომ მკაფიოდ მართოთ დამოკიდებულებები და მათი გამოძახების ლოგიკა, კომპონენტი მინდობაა გარეგან ფრეიმვორკზე ან კონტეინერზე, რომელიც მართავს ამ ნაკადს.

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

ამიტომ, DI არის გზა IoC-ის მისაღწევად.

ძირითადი განსხვავებები:

• IoC — პრინციპი/კონცეფცია.
• DI — პატერნი/მიღწევა.
• IoC შეიძლება განხორციელდეს სხვადასხვა გზით (მაგალითად, ფაბრიკური მეთოდი, სერვისის ლოკატორი), ხოლო DI — ერთ-ერთი ასეთი გზაა.
• IoC გადადის პასუხისმგებლობას ობიექტების შექმნისა და დაკავშირების შესახებ კომპონენტიდან ფრეიმვორკზე/კონტეინერზე.
• DI ახორციელებს ამ გადაცემას, გადასცემს დამოკიდებულებებს კონსტრუქტორით, სეტტერით ან ინტერფეისით.

DI-ის მაგალითი (კონსტრუქტორით):

// კლასი, რომელიც დამოკიდებულია Service-ზე
public class Client {
    private final Service service;

    // კონსტრუქტორი იღებს დამოკიდებულებას (Service)
    public Client(Service service) {
        this.service = service;
    }

    public void doSomething() {
        service.execute();
    }
}

// დამოკიდებულების ინტერფეისი
public interface Service {
    void execute();
}

// კონკრეტული დამოკიდებულების რეალიზაცია
public class ServiceImpl implements Service {
    @Override
    public void execute() {
        System.out.println("სერვისის შესრულება...");
    }
}

// კლასი, პასუხისმგებელი "შეყვანაზე"
public class AppConfig {
    public static void main(String[] args) {
        Service myService = new ServiceImpl(); // დამოკიდებულების შექმნა
        Client client = new Client(myService); // დამოკიდებულების გადაცემა კონსტრუქტორით
        client.doSomething();
    }
}

ამ მაგალითში, კლასი Client პირდაპირ არ ქმნის ServiceImpl-ს. ამის ნაცვლად, ServiceImpl იქმნება სხვა ადგილას (AppConfig) და გადაეცემა (შეყვანილი) Client-ს მისი კონსტრუქტორით. ეს ახორციელებს IoC პრინციპს, რადგან მართვა შექმნისა და დაკავშირების Service-ის ინვერტირებულია — ის Client-ში არაა.