Golang: Struktur-, Schnittstellen- und Abhängigkeitsinjektion (DI)

Strukturen und Schnittstellen in der Go-Sprache: wann man sie verwendet und wie man die Abhängigkeitsinjektion kombiniert

In diesem Artikel wird untersucht, wann Strukturen und wann Schnittstellen in der Go-Sprache verwendet werden sollten und wie beide zum Implementieren der Abhängigkeitsinjektion (DI) verwendet werden können. Wir erklären diese Konzepte anhand einer einfachen Spielzeugkiste-Analogie.

Beispiel aus der Praxis: Spielzeugkiste

Struktur

• Stellen Sie sich eine Struktur als ein bestimmtes Spielzeug in einer Spielzeugkiste vor, beispielsweise ein Auto.
• Das Auto hat bestimmte Attribute wie Farbe, Größe und Typ (z. B. Sportwagen).
• In der Programmierung speichern Strukturen Daten über Objekte.

Schnittstelle

• Die Benutzeroberfläche ist wie eine Spielzeugkiste, die jede Art von Spielzeug aufnehmen kann.
• Es definiert, was das Spielzeug tun kann, z. B. rollen, Geräusche machen oder aufleuchten. Jedes Spielzeug, das diese Aktionen ausführen kann, kommt in die Spielzeugkiste.
• Bei der Programmierung definiert eine Schnittstelle eine Reihe von Methoden, die verschiedene Typen (Strukturen) implementieren können.

Abhängigkeitsinjektion

• Stellen Sie sich ein Kind vor, das mit Spielzeug spielt. Anstatt Ihr Kind auf ein bestimmtes Spielzeug zu beschränken, lassen Sie es jederzeit ein beliebiges Spielzeug aus der Spielzeugkiste auswählen.
• Dies ist wie eine Abhängigkeitsinjektion, bei der Sie einer Funktion oder Klasse die Tools (oder Abhängigkeiten) zur Verfügung stellen, die sie zum Funktionieren benötigt, und so die Flexibilität erhöhen.

Grundkenntnisse

Struktur

• Definition: Eine Struktur ist eine Möglichkeit, einen neuen Typ mit bestimmten Feldern zu definieren.
• Zweck: Wird zur Modellierung von Datenstrukturen und zur Kapselung von Daten und Verhalten in einer Einheit verwendet.

Beispiel:

<code class="language-go">type Car struct {
    Model string
    Year  int
}</code>

Schnittstelle

• Definition: Eine Schnittstelle definiert eine Reihe von Methoden, die ein Typ implementieren muss.
• Zweck: Unverzichtbar für Polymorphismus und entkoppelte Komponenten, unterstützt generische Programmierung.

Beispiel:

<code class="language-go">type CarInterface interface {
    Start()
    Stop()
}</code>

Verwenden Sie die Car-Struktur, um CarInterface zu implementieren:

<code class="language-go">func (c *Car) Start() {
    fmt.Println("Car started")
}

func (c *Car) Stop() {
    fmt.Println("Car stopped")
}</code>

Wann was verwenden?

Wann Strukturen verwendet werden sollten

• Muss eine bestimmte Datenstruktur mit definierten Feldern modellieren.
• Daten und Verhalten müssen in einer Einheit zusammengefasst werden.

Wann werden Schnittstellen verwendet?

• Sie müssen Verträge definieren, die von mehreren Typen implementiert werden können.
• Komponenten müssen entkoppelt werden, um den Code flexibler und einfacher zu testen.
• Um generischen Code zu schreiben, muss der Polymorphismus genutzt werden.

Flexibilität und Leistung in Einklang bringen

Während Schnittstellen Flexibilität bieten, können dynamische Methodenaufrufe zu Mehraufwand führen.

Andererseits haben Strukturen aufgrund statischer Typprüfung und direkter Methodenaufrufe Leistungsvorteile. So bringen Sie beides in Einklang:

Schnittstellenkombination

Kombinieren Sie mehrere Schnittstellen, um spezifischere Schnittstellen zu erstellen. Betrachten Sie beispielsweise eine Dateisystemschnittstelle:

<code class="language-go">type Car struct {
    Model string
    Year  int
}</code>

Jetzt können wir eine spezifischere ReadWrite-Schnittstelle erstellen, indem wir Reader und Writer kombinieren:

<code class="language-go">type CarInterface interface {
    Start()
    Stop()
}</code>

Vorteile: Dieser Ansatz verbessert die Modularität, Wiederverwendbarkeit und Flexibilität des Codes.

Schnittstelleneinbettung

Betten Sie die Schnittstelle in die Struktur ein, um ihre Methoden zu erben. Betrachten Sie beispielsweise eine Protokollierungsschnittstelle:

<code class="language-go">func (c *Car) Start() {
    fmt.Println("Car started")
}

func (c *Car) Stop() {
    fmt.Println("Car stopped")
}</code>

Jetzt können wir eine spezifischere Schnittstelle ErrorLogger erstellen, die die Logger-Schnittstelle einbettet:

<code class="language-go">type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}</code>

Jeder Typ, der die ErrorLogger-Schnittstelle implementiert, muss auch die von der eingebetteten Logger-Schnittstelle geerbte Log-Methode implementieren.

<code class="language-go">type ReadWrite interface {
    Reader
    Writer
}</code>

Vorteile: Dies kann verwendet werden, um hierarchische Beziehungen zwischen Schnittstellen zu erstellen, wodurch der Code sauberer und ausdrucksvoller wird.

Abhängigkeitsinjektion

Dies ist ein Entwurfsmuster, das dabei hilft, Komponenten zu entkoppeln und die Testbarkeit zu verbessern. In der Go-Sprache wird dies normalerweise über Schnittstellen implementiert.

Beispiel: Benachrichtigungssystem

In diesem Beispiel definieren wir einen Benachrichtigungsdienst, der Nachrichten über verschiedene Kanäle senden kann. Wir werden DI verwenden, damit der Dienst mit jeder Benachrichtigungsmethode funktioniert.

Schritt 1: Notifier-Schnittstelle definieren

Zuerst definieren wir eine Schnittstelle für den Notifier. Diese Schnittstelle gibt die Methode zum Senden von Benachrichtigungen an.

<code class="language-go">type Logger interface {
    Log(message string)
}</code>

Schritt 2: Verschiedene Melder implementieren

Als nächstes erstellen wir zwei Implementierungen der Notifier-Schnittstelle: eine zum Senden von E-Mail-Benachrichtigungen und eine andere zum Senden von SMS-Benachrichtigungen.

E-Mail-Benachrichtigungsimplementierung:

<code class="language-go">type ErrorLogger interface {
    Logger
    LogError(err error)
}</code>

SMS Notifier-Implementierung:

<code class="language-go">type ConsoleLogger struct{}

func (cl *ConsoleLogger) Log(message string) {
    fmt.Println(message)
}

func (cl *ConsoleLogger) LogError(err error) {
    fmt.Println("Error:", err)
}</code>

Schritt 3: Benachrichtigungsdienst erstellen

Jetzt erstellen wir einen NotificationService, der die Notifier-Schnittstelle verwendet. Dieser Dienst ist für den Versand von Benachrichtigungen verantwortlich.

<code class="language-go">type Notifier interface {
    Send(message string) error
}</code>

Schritt 4: Verwenden Sie die Abhängigkeitsinjektion in der Hauptfunktion

In der Hauptfunktion erstellen wir Instanzen von Notifiern und fügen sie in den NotificationService ein.

<code class="language-go">type EmailNotifier struct {
    EmailAddress string
}

func (e *EmailNotifier) Send(message string) error {
    // 模拟发送电子邮件
    fmt.Printf("Sending email to %s: %s\n", e.EmailAddress, message)
    return nil
}</code>

Vorteile dieser Methode

• Entkopplung: NotificationService ist nicht von einer bestimmten Implementierung des Notifiers abhängig. Es basiert nur auf der Notifier-Schnittstelle, sodass in Zukunft problemlos neue Benachrichtigungsmethoden hinzugefügt werden können.
• Testbarkeit: Sie können ganz einfach eine Scheinimplementierung der Notifier-Schnittstelle für Unit-Tests von NotificationService erstellen.
• Flexibilität: Wenn Sie eine neue Benachrichtigungsmethode hinzufügen möchten (z. B. eine Push-Benachrichtigung), können Sie eine neue Struktur erstellen, die die Notifier-Schnittstelle implementiert, ohne den NotificationService-Code zu ändern.

Um sauberen, wartbaren und testbaren Go-Code zu schreiben, ist es entscheidend zu verstehen, wann Strukturen und wann Schnittstellen verwendet werden sollten.

Durch die Verwendung dieser beiden Konzepte zusammen mit der Abhängigkeitsinjektion können wir flexible und leistungsstarke Anwendungen erstellen.

Um den vollständigen Blog zu lesen, besuchen Sie bitte unseren Canopas-Blog.

---

Wenn Ihnen der Inhalt dieses Artikels gefällt, klicken Sie bitte auf die Schaltfläche ? - Als Autor bedeutet mir das sehr viel!

Teilen Sie Ihre Gedanken gerne im Kommentarbereich unten mit. Ihre Kommentare bereichern nicht nur unsere Inhalte, sondern inspirieren uns auch dazu, weitere wertvolle und informative Artikel für Sie zu erstellen.

Viel Spaß beim Programmieren! ?

Das obige ist der detaillierte Inhalt vonGolang: Struktur-, Schnittstellen- und Abhängigkeitsinjektion (DI). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!