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:

type Car struct {
    Model string
    Year  int
}

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:

type CarInterface interface {
    Start()
    Stop()
}

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

func (c *Car) Start() {
    fmt.Println("Car started")
}

func (c *Car) Stop() {
    fmt.Println("Car stopped")
}

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:

type Car struct {
    Model string
    Year  int
}

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

type CarInterface interface {
    Start()
    Stop()
}

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:

func (c *Car) Start() {
    fmt.Println("Car started")
}

func (c *Car) Stop() {
    fmt.Println("Car stopped")
}

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

type Reader interface {
    Read(p []byte) (n int, err error)
}

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

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

type ReadWrite interface {
    Reader
    Writer
}

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.

type Logger interface {
    Log(message string)
}

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:

type ErrorLogger interface {
    Logger
    LogError(err error)
}

SMS Notifier-Implementierung:

type ConsoleLogger struct{}

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

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

Schritt 3: Benachrichtigungsdienst erstellen

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

type Notifier interface {
    Send(message string) error
}

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.

type EmailNotifier struct {
    EmailAddress string
}

func (e *EmailNotifier) Send(message string) error {
    // 模擬發(fā)送電子郵件
    fmt.Printf("Sending email to %s: %s\n", e.EmailAddress, message)
    return nil
}

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!