Qaramlik integratsiyasi nima va qanday foyda…

Dependency Injection (DI) — bu dizayn shabloni bo‘lib, unda komponentlar o‘zlarining bog‘liqliklarini tashqaridan oladi, o‘zlari yaratmaydi. Bu Inversion of Control (IoC) prinsipi asoslaridan biridir.

DI ning foydalari:

Test qilish imkoniyatining yaxshilanishi: Modulli testlar uchun bog‘liqliklarni mocks/stubs bilan o‘zgartirish osonroq.
Qattiq bog‘liqlikning kamayishi (Loose Coupling): Komponentlar bog‘liqliklarning aniq amalga oshirishlariga kamroq bog‘liq bo‘ladi.
Moslashuvchanlik va kengaytiriluvchanlikning oshishi: Bog‘liqliklarning amalga oshirishlarini o‘zgartirish oson, asosiy kodni o‘zgartirmasdan.
O‘qilishi va qo‘llab-quvvatlashning yaxshilanishi: Komponentga qanday bog‘liqliklar kerakligini aniq ko‘rish mumkin.

Misol: DI bo‘lmagan va DI bilan:

DI bo‘lmagan:

// Ichida bog‘liqlik yaratadigan sinf
public class ServiceA {
    private DatabaseConnection dbConnection;

    public ServiceA() {
        // Kuchli bog‘liqlik: aniq amalga oshirishni yaratamiz
        this.dbConnection = new OracleConnection(); 
    }

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

DI bilan (konstruktor orqali):

// Bog‘liqlik interfeysi
public interface DatabaseConnection {
    void connect();
    void disconnect();
}

// Turli amalga oshirishlar
public class OracleConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Oracle bilan ulanish...");
    }
    @Override
    public void disconnect() {
        System.out.println("Oracle bilan ulanishni yopish...");
    }
}

public class MySQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("MySQL bilan ulanish...");
    }
    @Override
    public void disconnect() {
        System.out.println("MySQL bilan ulanishni yopish...");
    }
}

// Bog‘liqlik tashqaridan qabul qiladigan sinf
public class ServiceB {
    private DatabaseConnection dbConnection;

    // Konstruktor orqali bog‘liqlikni in‘ektsiya qilish
    public ServiceB(DatabaseConnection dbConnection) {
        this.dbConnection = dbConnection;
    }

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

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

// In‘ektsiyani amalga oshiradigan kod (konfiguratsiya)
public class Application {
    public static void main(String[] args) {
        // Bog‘liqlikni yaratamiz
        DatabaseConnection connection = new MySQLConnection(); 
        // Bog‘liqlikni ServiceB ga in‘ektsiya qilamiz
        ServiceB service = new ServiceB(connection); 
        service.doSomething();

        // Yoki bog‘liqlikni o‘zgartiramiz, ServiceB ni o‘zgartirmasdan
        DatabaseConnection anotherConnection = new OracleConnection();
        ServiceB anotherService  = new ServiceB(anotherConnection);
        anotherService.doSomething();
    }
}

In‘ektsiya usullari:

Konstruktor orqali (Constructor Injection): Bog‘liqliklar sinfning konstruktoriga taqdim etiladi. Majburiy bog‘liqliklar uchun afzal.
Setter orqali (Setter Injection): Bog‘liqliklar setter metodlari orqali taqdim etiladi. Opsional bog‘liqliklar uchun yaxshi.
Maydon orqali (Field Injection): Bog‘liqliklar to‘g‘ridan-to‘g‘ri sinf maydonlariga in‘ektsiya qilinadi (odatda frameworklar bilan, refleksiya talab qiladi). DI-ramkalsiz tavsiya etilmaydi, chunki test qilish qiyinlashadi va bog‘liqliklar yashirin bo‘ladi.

DI ko‘pincha DI konteynerlari/frameworklari yordamida amalga oshiriladi, masalan Spring, Guice, Dagger, ular ob’ektlarning hayot aylanishini boshqaradi va in‘ektsiya jarayonini avtomatlashtiradi.

Qaramlik integratsiyasi nima va qanday foyda keltiradi?