Memecahkan Penyongsangan Ketergantungan, IoC dan DI

Meneroka sistem suntikan kebergantungan NestJS mencetuskan penyelaman yang lebih mendalam ke dalam Penyongsangan Ketergantungan, Penyongsangan Kawalan dan Suntikan Ketergantungan. Konsep ini, walaupun kelihatan serupa, menawarkan penyelesaian yang berbeza untuk masalah yang berbeza. Penjelasan ini berfungsi sebagai penyegar peribadi, dan semoga panduan berguna untuk orang lain yang bergelut dengan istilah ini.

---

1. Prinsip Penyongsangan Kebergantungan (DIP)

Definisi: Modul peringkat tinggi tidak seharusnya bergantung pada modul peringkat rendah; kedua-duanya harus bergantung pada abstraksi. Abstraksi tidak seharusnya bergantung pada butiran; butiran harus bergantung pada abstraksi.

Maksud Ini:

Dalam perisian, modul peringkat tinggi merangkumi logik perniagaan teras, manakala modul peringkat rendah mengendalikan pelaksanaan tertentu (pangkalan data, API, dll.). Tanpa DIP, modul peringkat tinggi bergantung secara langsung pada modul peringkat rendah, mewujudkan gandingan ketat yang menghalang fleksibiliti, merumitkan ujian dan penyelenggaraan serta menyukarkan penggantian atau melanjutkan butiran peringkat rendah.

DIP membalikkan hubungan ini. Daripada kawalan langsung, kedua-dua modul peringkat tinggi dan rendah bergantung pada abstraksi yang dikongsi (antara muka atau kelas abstrak).

---

Tanpa DIP

Contoh Python

class EmailService:
    def send_email(self, message):
        print(f"Sending email: {message}")

class Notification:
    def __init__(self):
        self.email_service = EmailService()

    def notify(self, message):
        self.email_service.send_email(message)

Contoh TypeScript

class EmailService {
    sendEmail(message: string): void {
        console.log(`Sending email: ${message}`);
    }
}

class Notification {
    private emailService: EmailService;

    constructor() {
        this.emailService = new EmailService();
    }

    notify(message: string): void {
        this.emailService.sendEmail(message);
    }
}

---

Masalah:

1. Gandingan ketat: Notification secara langsung bergantung pada EmailService.
2. Kebolehlanjutan terhad: Bertukar kepada SMSService memerlukan pengubahsuaian Notification.

---

Dengan DIP

Contoh Python

from abc import ABC, abstractmethod

class MessageService(ABC):
    @abstractmethod
    def send_message(self, message):
        pass

class EmailService(MessageService):
    def send_message(self, message):
        print(f"Sending email: {message}")

class Notification:
    def __init__(self, message_service: MessageService):
        self.message_service = message_service

    def notify(self, message):
        self.message_service.send_message(message)

# Usage
email_service = EmailService()
notification = Notification(email_service)
notification.notify("Hello, Dependency Inversion!")

---

Contoh TypeScript

interface MessageService {
    sendMessage(message: string): void;
}

class EmailService implements MessageService {
    sendMessage(message: string): void {
        console.log(`Sending email: ${message}`);
    }
}

class Notification {
    private messageService: MessageService;

    constructor(messageService: MessageService) {
        this.messageService = messageService;
    }

    notify(message: string): void {
        this.messageService.sendMessage(message);
    }
}

// Usage
const emailService = new EmailService();
const notification = new Notification(emailService);
notification.notify("Hello, Dependency Inversion!");

Kebaikan DIP:

• Fleksibiliti: Tukar perlaksanaan dengan mudah.
• Kebolehujian: Gunakan olok-olok untuk ujian.
• Kebolehselenggaraan: Perubahan dalam modul peringkat rendah tidak memberi kesan kepada modul peringkat tinggi.

---

2. Penyongsangan Kawalan (IoC)

IoC ialah prinsip reka bentuk di mana kawalan kebergantungan beralih kepada sistem luaran (rangka kerja) dan bukannya diuruskan dalam kelas. Secara tradisinya, kelas mencipta dan mengurus kebergantungannya. IoC membalikkan perkara ini—entiti luaran menyuntik kebergantungan.

---

Contoh Python: Tanpa IoC

class SMSService:
    def send_message(self, message):
        print(f"Sending SMS: {message}")

class Notification:
    def __init__(self):
        self.sms_service = SMSService()  # Dependency created internally

    def notify(self, message):
        self.sms_service.send_message(message)

---

Contoh TypeScript: Tanpa IoC

class SMSService {
    sendMessage(message: string): void {
        console.log(`Sending SMS: ${message}`);
    }
}

class Notification {
    private smsService: SMSService;

    constructor() {
        this.smsService = new SMSService(); // Dependency created internally
    }

    notify(message: string): void {
        this.smsService.sendMessage(message);
    }
}

---

Masalah Tanpa IoC:

1. Gandingan yang ketat.
2. Fleksibiliti rendah.
3. Ujian yang sukar.

---

Contoh Python: Dengan IoC

class EmailService:
    def send_email(self, message):
        print(f"Sending email: {message}")

class Notification:
    def __init__(self):
        self.email_service = EmailService()

    def notify(self, message):
        self.email_service.send_email(message)

---

Contoh TypeScript: Dengan IoC

class EmailService {
    sendEmail(message: string): void {
        console.log(`Sending email: ${message}`);
    }
}

class Notification {
    private emailService: EmailService;

    constructor() {
        this.emailService = new EmailService();
    }

    notify(message: string): void {
        this.emailService.sendEmail(message);
    }
}

---

Faedah IoC:

1. Gandingan longgar.
2. Penukaran pelaksanaan yang mudah.
3. Kebolehujian dipertingkatkan.

---

3. Suntikan Kebergantungan (DI)

DI ialah teknik di mana objek menerima kebergantungannya daripada sumber luaran. Ia merupakan pelaksanaan praktikal IoC, menyuntik kebergantungan melalui:

1. Suntikan Pembina
2. Suntikan Setter
3. Suntikan Antara Muka

---

Contoh Python: Rangka Kerja DI (menggunakan pustaka injector)

from abc import ABC, abstractmethod

class MessageService(ABC):
    @abstractmethod
    def send_message(self, message):
        pass

class EmailService(MessageService):
    def send_message(self, message):
        print(f"Sending email: {message}")

class Notification:
    def __init__(self, message_service: MessageService):
        self.message_service = message_service

    def notify(self, message):
        self.message_service.send_message(message)

# Usage
email_service = EmailService()
notification = Notification(email_service)
notification.notify("Hello, Dependency Inversion!")

---

Contoh TypeScript: Rangka Kerja DI (menggunakan pustaka tsyringe)

interface MessageService {
    sendMessage(message: string): void;
}

class EmailService implements MessageService {
    sendMessage(message: string): void {
        console.log(`Sending email: ${message}`);
    }
}

class Notification {
    private messageService: MessageService;

    constructor(messageService: MessageService) {
        this.messageService = messageService;
    }

    notify(message: string): void {
        this.messageService.sendMessage(message);
    }
}

// Usage
const emailService = new EmailService();
const notification = new Notification(emailService);
notification.notify("Hello, Dependency Inversion!");

---

Kebaikan DI:

• Ujian ringkas.
• Skala yang dipertingkatkan.
• Kebolehselenggaraan dipertingkatkan.

Penjelasan terperinci ini menjelaskan perhubungan dan perbezaan antara DIP, IoC dan DI, menekankan sumbangan individu mereka untuk membina perisian yang teguh dan boleh diselenggara.

Atas ialah kandungan terperinci Memecahkan Penyongsangan Ketergantungan, IoC dan DI. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!