(D): Typescript と Java で「依存関係逆転の原則」を適用する

コンセプト

SOLID は、ロバート C. マーティン (アンクル ボブ) によって提案された、オブジェクト指向プログラミングの 5 つの基本原則を表す頭字語です。ここで彼の記事の詳細を読むことができます。
これらの原則は、コードの構造とメンテナンスを改善し、コードをより柔軟でスケーラブルにし、理解しやすくすることを目的としています。このような原則は、プログラマーがより組織化されたコードを作成し、責任を分割し、依存関係を減らし、リファクタリング プロセスを簡素化し、コードの再利用を促進するのに役立ちます。

頭字語の「D」は、「依存関係反転原理」 を表します。ボブおじさんがこの原則を定義するために使用したフレーズは次のとおりです:

「高レベルのモジュールは低レベルのモジュールに依存すべきではありません。両方とも抽象化に依存すべきです。抽象化は詳細に依存すべきではありません。詳細は抽象化に依存すべきです。」

依存関係逆転の原則は、システムのコンポーネント間の結合を減らし、柔軟性、保守性、テスト容易性を向上させることを目的としています。

DIPが解決する問題

• 密結合: モジュールが具体的な実装に直接依存している場合、その実装への変更は他のモジュールに影響を与える可能性があります。
• テストの難しさ: 特定の実装に直接結合されたコードユニットのテストは、これらの具体的な実装を使用する必要があるため、より複雑になり、モックやスタブの作成が困難になります。
• 再利用性が低い: 具体的な詳細と高度に結合されたモジュールは、他のコンテキストでは再利用可能性が低くなります。

実用化

問題とそれを解決するために考えられる解決策を分析するために、電子メールで通知を送信するコードを作成します

ジャワ

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

タイプスクリプト

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!");

問題点:

• Notification クラスは、具体的な実装 (EmailService) に直接依存します。
• 通知チャネル (例: SMS) を変更したい場合は、通知コードを変更する必要があります。

ソリューションと利点:

• 通知は、メッセージの送信方法の詳細を知る必要はありません。
• 新しいコミュニケーション チャネルの置き換えや追加が簡単。
• 実際の実装に依存せずに、通知を単独でテストできます。

ジャワ

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

タイプスクリプト

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. 単体テスト

ジャワ

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

タイプスクリプト

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

結論

依存性反転原則 (DIP) は、柔軟で堅牢なプロジェクトの基本的な柱です。これにより、クラス間の結合を減らし、コードの再利用を容易にし、アプリケーションのテスト容易性を向上させることができます。抽象化に依存することで、システムは変化への適応性が高まり、新しい機能によって拡張可能になります。この実践的な例では、わずかな設計調整で繰り返し発生するメンテナンスの問題を解決できることが実証されました。 DIP を他の SOLID 原則と組み合わせて適用すると、拡張に備えたクリーンなコードが保証されます。これらの概念を採用することは、ソフトウェア アーキテクチャの卓越性を求める開発者にとって不可欠です。

参考文献

• Martin, Robert C. アジャイル ソフトウェア開発、原則、パターン、実践。プレンティス・ホール、2002年。
• チアゴ・レイテとカルヴァーリョ。 オブジェクト指向。カサ・ド・コード、2014年。

以上が(D): Typescript と Java で「依存関係逆転の原則」を適用するの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。