Struktur dan antara muka dalam bahasa Go: bila hendak digunakan dan cara menggabungkan suntikan pergantungan

Artikel ini akan meneroka masa untuk menggunakan struktur dan masa untuk menggunakan antara muka dalam bahasa Go, dan cara menggunakan kedua-duanya untuk melaksanakan suntikan kebergantungan (DI). Kami akan menerangkan konsep ini melalui analogi Kotak Mainan yang mudah.

Contoh Dunia Sebenar: Kotak Mainan

Struktur

• Fikirkan struct sebagai mainan khusus dalam kotak mainan, seperti kereta.
• Kereta itu mempunyai atribut khusus, seperti warna, saiz dan jenis (mis., kereta sukan).
• Dalam pengaturcaraan, struktur menyimpan data tentang objek.

Antara Muka

• Antaramuka adalah seperti kotak mainan yang boleh memuatkan sebarang jenis mainan.
• Ia mentakrifkan perkara yang boleh dilakukan oleh mainan, seperti bergolek, mengeluarkan bunyi atau menyala. Mana-mana mainan yang boleh melakukan tindakan ini boleh dimasukkan ke dalam kotak mainan.
• Dalam pengaturcaraan, antara muka mentakrifkan satu set kaedah yang boleh dilaksanakan oleh jenis (struktur) yang berbeza.

Suntikan Kebergantungan

• Bayangkan seorang kanak-kanak bermain dengan mainan. Daripada mengehadkan anak anda kepada satu mainan tertentu, biarkan mereka memilih mana-mana mainan dari kotak mainan pada bila-bila masa.
• Ini seperti suntikan kebergantungan, di mana anda menyediakan fungsi atau kelas dengan alat (atau kebergantungan) yang diperlukan untuk berfungsi, sekali gus meningkatkan fleksibiliti.

Pengetahuan asas

Struktur

• Definisi: Struktur ialah cara untuk mentakrifkan jenis baharu dengan medan tertentu.
• Tujuan: Digunakan untuk memodelkan struktur data dan merangkum data dan gelagat dalam unit.

Contoh:

type Car struct {
    Model string
    Year  int
}

Antara Muka

• Definisi: Antara muka mentakrifkan satu set kaedah yang mesti dilaksanakan oleh sesuatu jenis.
• Tujuan: Penting untuk komponen polimorfisme dan decoupled, menyokong pengaturcaraan generik.

Contoh:

type CarInterface interface {
    Start()
    Stop()
}

Gunakan struktur Kereta untuk melaksanakan CarInterface:

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

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

Bila hendak menggunakan yang mana?

Bila menggunakan struktur

• Perlu memodelkan struktur data tertentu dengan medan yang ditentukan.
• Perlu merangkum data dan tingkah laku dalam satu unit.

Bila menggunakan antara muka

• Anda perlu menentukan kontrak yang boleh dilaksanakan oleh pelbagai jenis.
• Perlu memisahkan komponen untuk menjadikan kod lebih fleksibel dan lebih mudah untuk diuji.
• Perlu memanfaatkan polimorfisme untuk menulis kod generik.

Mengimbangi fleksibiliti dan prestasi

Walaupun antara muka memberikan fleksibiliti, panggilan kaedah dinamik mungkin memperkenalkan overhed.

Sebaliknya, struct mempunyai kelebihan prestasi disebabkan oleh pemeriksaan jenis statik dan panggilan kaedah langsung. Begini cara mengimbangi kedua-duanya:

Gabungan antara muka

Gabungkan berbilang antara muka untuk mencipta antara muka yang lebih khusus. Sebagai contoh, pertimbangkan antara muka sistem fail:

type Car struct {
    Model string
    Year  int
}

Kini kita boleh mencipta antara muka yang lebih khusus ReadWrite dengan menggabungkan Pembaca dan Penulis:

type CarInterface interface {
    Start()
    Stop()
}

Faedah: Pendekatan ini meningkatkan modulariti kod, kebolehgunaan semula dan fleksibiliti.

Pembenaman Antara Muka

Benamkan antara muka dalam struktur untuk mewarisi kaedahnya. Sebagai contoh, pertimbangkan antara muka pengelogan:

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

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

Kini, kita boleh mencipta antara muka yang lebih khusus ErrorLogger, yang membenamkan antara muka Logger:

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

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

Sebarang jenis yang melaksanakan antara muka ErrorLogger juga mesti melaksanakan kaedah Log yang diwarisi daripada antara muka Logger terbenam.

type ReadWrite interface {
    Reader
    Writer
}

Faedah: Ini boleh digunakan untuk mencipta perhubungan hierarki antara antara muka, menjadikan kod lebih bersih dan lebih ekspresif.

Suntikan Kebergantungan

Ini ialah corak reka bentuk yang membantu memisahkan komponen dan meningkatkan kebolehujian. Dalam bahasa Go, ia biasanya dilaksanakan menggunakan antara muka.

Contoh: Sistem Pemberitahuan

Dalam contoh ini, kami akan mentakrifkan perkhidmatan pemberitahuan yang boleh menghantar mesej melalui saluran yang berbeza. Kami akan menggunakan DI untuk membenarkan perkhidmatan berfungsi dengan sebarang kaedah pemberitahuan.

Langkah 1: Tentukan antara muka Pemberitahu

Pertama, kami mentakrifkan antara muka untuk pemberi maklumat. Antara muka ini akan menentukan kaedah untuk menghantar pemberitahuan.

type Logger interface {
    Log(message string)
}

Langkah 2: Laksanakan pemberitahuan yang berbeza

Seterusnya, kami mencipta dua pelaksanaan antara muka Pemberitahu: satu untuk menghantar pemberitahuan e-mel dan satu lagi untuk menghantar pemberitahuan SMS.

Pelaksanaan Pemberitahu E-mel:

type ErrorLogger interface {
    Logger
    LogError(err error)
}

Pelaksanaan Pemberitahu SMS:

type ConsoleLogger struct{}

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

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

Langkah 3: Buat perkhidmatan pemberitahuan

Kini, kami mencipta Perkhidmatan Pemberitahuan yang akan menggunakan antara muka Pemberitahu. Perkhidmatan ini akan bertanggungjawab untuk menghantar pemberitahuan.

type Notifier interface {
    Send(message string) error
}

Langkah 4: Gunakan suntikan kebergantungan dalam fungsi utama

Dalam fungsi utama, kami akan mencipta contoh pemberitahuan dan menyuntiknya ke dalam Perkhidmatan Pemberitahuan.

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
}

Faedah kaedah ini

• Penyahgandingan: Perkhidmatan Pemberitahuan tidak bergantung pada pelaksanaan khusus pemberi maklumat. Ia hanya bergantung pada antara muka Pemberitahu, jadi mudah untuk menambah kaedah pemberitahuan baharu pada masa hadapan.
• Kestabilan: Anda boleh membuat pelaksanaan olok-olok antara muka Pemberitahu dengan mudah untuk ujian unit Perkhidmatan Pemberitahuan.
• Fleksibiliti: Jika anda ingin menambah kaedah pemberitahuan baharu (seperti pemberitahuan tolak), anda boleh mencipta struct baharu yang melaksanakan antara muka Pemberitahu tanpa menukar kod Perkhidmatan Pemberitahuan.

Memahami masa untuk menggunakan struct dan masa untuk menggunakan antara muka adalah penting untuk menulis kod Go yang bersih, boleh diselenggara dan boleh diuji.

Dengan menggunakan kedua-dua konsep ini bersama suntikan kebergantungan, kami boleh mencipta aplikasi yang fleksibel dan berkuasa.

Untuk membaca blog penuh, sila layari Blog Canopas kami.

Jika anda suka kandungan artikel ini, sila klik butang ? - Sebagai pengarang, ini amat bermakna bagi saya!

Jangan ragu untuk berkongsi pendapat anda di bahagian komen di bawah. Komen anda bukan sahaja memperkayakan kandungan kami, tetapi juga memberi inspirasi kepada kami untuk mencipta artikel yang lebih berharga dan bermaklumat untuk anda.

Selamat pengaturcaraan! ?

Atas ialah kandungan terperinci Golang: Struktur, Antara Muka Dan Suntikan Ketergantungan(DI). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!