(D): Menggunakan \'Prinsip Penyongsangan Ketergantungan\' dengan Typescript dan Java

Konsep

SOLID ialah akronim yang mewakili lima prinsip asas pengaturcaraan berorientasikan objek, yang dicadangkan oleh Robert C. Martin - Uncle Bob. Di sini anda boleh membaca lebih lanjut tentang artikelnya.
Prinsip ini bertujuan untuk menambah baik struktur dan penyelenggaraan kod, menjadikannya lebih fleksibel, berskala dan lebih mudah difahami. Prinsip sedemikian membantu pengaturcara mencipta kod yang lebih teratur, membahagikan tanggungjawab, mengurangkan kebergantungan, memudahkan proses pemfaktoran semula dan menggalakkan penggunaan semula kod.

"D" dalam akronim bermaksud "Prinsip Penyongsangan Kebergantungan". Frasa yang uncle bob gunakan untuk mentakrifkan prinsip ini ialah:

"Modul peringkat tinggi tidak boleh bergantung pada modul peringkat rendah. Kedua-duanya harus bergantung pada abstraksi. Abstraksi tidak boleh bergantung pada butiran. Butiran harus bergantung pada abstraksi"

Prinsip Pembalikan Ketergantungan bertujuan untuk mengurangkan gandingan antara komponen sistem, menggalakkan fleksibiliti, kebolehselenggaraan dan kebolehujian yang lebih besar.

Masalah yang DIP Selesaikan

• Gandingan ketat: Apabila modul bergantung secara langsung pada pelaksanaan konkrit, perubahan pada pelaksanaan itu boleh menjejaskan modul lain.
• Kesukaran ujian: Menguji unit kod yang digabungkan secara langsung dengan pelaksanaan tertentu adalah lebih rumit, kerana ia memerlukan penggunaan pelaksanaan konkrit ini, menjadikannya sukar untuk mencipta olok-olok atau stub.
• Kebolehgunaan semula yang rendah: Modul yang sangat digabungkan dengan butiran konkrit kurang boleh digunakan semula dalam konteks lain.

Aplikasi Praktikal

Kami akan membuat kod yang bertanggungjawab untuk menghantar pemberitahuan melalui e-mel, untuk menganalisis masalah dan kemungkinan penyelesaian untuk menyelesaikannya

Jawa

class EmailService {
    public void sendEmail(String message) {
        System.out.println("Sending email: " + message);
    }
}

class Notification {
    private EmailService emailService;

    public Notification() {
        this.emailService = new EmailService();
    }

    public void notify(String message) {
        this.emailService.sendEmail(message);
    }
}

// Uso
public class Main {
    public static void main(String[] args) {
        Notification notification = new Notification();
        notification.notify("Welcome to our service!");
    }
}

Skrip taip

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);
    }
}

// Uso
const notification = new Notification();
notification.notify("Welcome to our service!");

Masalah:

• Kelas Pemberitahuan secara langsung bergantung pada pelaksanaan konkrit (EmailService).
• Jika kami ingin menukar saluran pemberitahuan (cth.: SMS), kami perlu menukar kod Pemberitahuan.

Penyelesaian dan Faedah:

• Pemberitahuan tidak perlu mengetahui butiran tentang cara mesej dihantar.
• Kemudahan menggantikan atau menambah saluran komunikasi baharu.
• Kami boleh menguji Pemberitahuan secara berasingan, tanpa bergantung pada pelaksanaan sebenar.

Jawa

public interface MessageService {
    void sendMessage(String message);
}

public class EmailService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("Sending email: " + message);
    }
}

public class SMSService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("Sending SMS: " + message);
    }
}

public class Notification {
    private final MessageService messageService;

    public Notification(MessageService messageService) {
        this.messageService = messageService;
    }

    public void notify(String message) {
        messageService.sendMessage(message);
    }
}

// Uso
public class Main {
    public static void main(String[] args) {
        Notification emailNotification = new Notification(new EmailService());
        emailNotification.notify("Welcome via Email!");

        Notification smsNotification = new Notification(new SMSService());
        smsNotification.notify("Welcome via SMS!");
    }
}

Skrip taip

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

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

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

class Notification {
    private messageService: MessageService;

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

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

// Uso
const emailNotification = new Notification(new EmailService());
emailNotification.notify("Welcome via Email!");

const smsNotification = new Notification(new SMSService());
smsNotification.notify("Welcome via SMS!");

3. Ujian Unit

Jawa

public class MockMessageService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("Mock message sent: " + message);
    }
}

// Teste com o mock
public class Main {
    public static void main(String[] args) {
        MessageService mockMessageService = new MockMessageService();
        Notification mockNotification = new Notification(mockMessageService);
        mockNotification.notify("Test message");
    }
}

Skrip taip

class MockMessageService implements MessageService {
    sendMessage(message: string): void {
        console.log(`Mock message sent: ${message}`);
    }
}

// Teste com o mock
const mockNotification = new Notification(new MockMessageService());
mockNotification.notify("Test message");

Kesimpulan

Prinsip Pembalikan Ketergantungan (DIP) ialah tonggak asas untuk projek yang fleksibel dan teguh. Ia membolehkan anda mengurangkan gandingan antara kelas, memudahkan penggunaan semula kod dan meningkatkan kebolehujian aplikasi. Dengan bergantung pada abstraksi, sistem anda menjadi lebih mudah disesuaikan untuk berubah dan boleh dikembangkan dengan ciri baharu. Contoh praktikal menunjukkan bagaimana pelarasan reka bentuk kecil boleh menyelesaikan masalah penyelenggaraan berulang. Menggunakan DIP bersama-sama prinsip SOLID lain memastikan kod yang lebih bersih yang sedia untuk berkembang. Mengguna pakai konsep ini adalah penting untuk pembangun yang mencari kecemerlangan dalam seni bina perisian.

Rujukan Bibliografi

• Martin, Robert C. Pembangunan, Prinsip, Corak dan Amalan Perisian Tangkas. Prentice Hall, 2002.
• Thiago Leite dan Carvalho. Orientasi Objek. Casa do Code, 2014.

Atas ialah kandungan terperinci (D): Menggunakan \'Prinsip Penyongsangan Ketergantungan\' dengan Typescript dan Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!