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

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

DI-ს სარგებელი:

1. ტესტირების გაუმჯობესება: მოდულური ტესტირებისას უფრო ადვილია ჩაანაცვლოს სმოკები (mocks/stubs) დამოკიდებულებებისთვის.
2. საკავშირების გამსუბუქება (Loose Coupling): კომპონენტები ნაკლებად არიან დამოკიდებული კონკრეტულ რეალიზაციებზე.
3. მოწესრიგებისა და გაფართოებადობის გაზრდა: შესაძლებელია მარტივად შეცვალოთ დამოკიდებულებების რეალიზაციები ძირითადი კოდის შეცვლის გარეშე.
4. წაკითხვისა და შენარჩუნების გაუმჯობესება: ნათლად ჩანს, რა დამოკიდებულებები სჭირდება კომპონენტს.

მაგალითი DI-ს გარეშე და DI-სთან:

DI-ს გარეშე:

// კლასი, რომელიც ქმნის დამოკიდებულებას შიგნით
public class ServiceA {
    private DatabaseConnection dbConnection;

    public ServiceA() {
        // ძლიერი კავშირი: კონკრეტული რეალიზაციის პირდაპირი შექმნა
        this.dbConnection = new OracleConnection(); 
    }

    public void doSomething() {
        dbConnection.connect();
        // ...
    }
}

DI-სთან (კონსტრუქტორის საშუალებით):

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

// სხვადასხვა რეალიზაციები
public class OracleConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Connecting to Oracle...");
    }
    @Override
    public void disconnect() {
        System.out.println("Disconnecting from Oracle...");
    }
}

public class MySQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Connecting to MySQL...");
    }
    @Override
    public void disconnect() {
        System.out.println("Disconnecting from MySQL...");
    }
}

// კლასი, რომელიც იღებს დამოკიდებულებას გარედან
public class ServiceB {
    private DatabaseConnection dbConnection;

    // დამოკიდებულების ინექცია კონსტრუქტორის საშუალებით
    public ServiceB(DatabaseConnection dbConnection) {
        this.dbConnection = dbConnection;
    }

    public void doSomething() {
        dbConnection.connect();
        // ...
    }

    public void setDbConnection(DatabaseConnection dbConnection) {
        this.dbConnection = dbConnection;
    }
}

// კოდი, რომელიც ახორციელებს ინექციას (კონფიგურაცია)
public class Application {
    public static void main(String[] args) {
        // დამოკიდებულების შექმნა
        DatabaseConnection connection = new MySQLConnection(); 
        // დამოკიდებულების მიწოდება ServiceB-ს
        ServiceB service = new ServiceB(connection); 
        service.doSomething();

        // ან დამოკიდებულების შეცვლა გარეშე ServiceB-ის შეცვლის გარეშე
        DatabaseConnection anotherConnection = new OracleConnection();
         ServiceB anotherService  = new ServiceB(anotherConnection);
         anotherService.doSomething();
    }
}

ინექციის მეთოდები:

• კონსტრუქტორის საშუალებით (Constructor Injection): დამოკიდებულებები მიწოდება ხდება კლასის კონსტრუქტორით. სასურველია აუცილებელი დამოკიდებულებებისათვის.
• სეტტერის საშუალებით (Setter Injection): დამოკიდებულებები მიწოდება ხდება სეტტერ მეთოდებით. კარგია არჩევითი დამოკიდებულებებისათვის.
• ფილდის საშუალებით (Field Injection): დამოკიდებულებები ინექცირდება პირდაპირ კლასის ფილდებში (ხშირად გამოიყენება ფრეიმვორკებთან, რეფლექსიის საჭიროებით). არ არის რეკომენდებული DI-ფრეიმვორკების გარეშე, რადგან გამარტივებს ტესტირებას და მალავს დამოკიდებულებებს.

DI ხშირად ხორციელდება DI-კონტეინერებით/ფრეიმვორკებით, როგორიცაა Spring, Guice, Dagger, რომლებიც მართავენ ობიექტების ციკლს და ავტომატურად ახორციელებენ ინექციას.