Bijih: Pakej Suntikan Ketergantungan Lanjutan untuk Go

Ore: Pakej suntikan kebergantungan lanjutan untuk bahasa Go

Tapak Web Dokumentasi Bijih

Repositori GitHub

Bahasa Go terkenal dengan kesederhanaan dan prestasi tinggi, tetapi pembangun sering menghadapi cabaran apabila ia berkaitan dengan pengurusan pergantungan. Walaupun bahasa Go tidak mempunyai rangka kerja DI terbina dalam seperti beberapa bahasa lain, terdapat banyak perpustakaan pihak ketiga yang boleh membantu. Ore ialah pakej yang menyediakan penyelesaian yang ringan dan cekap untuk suntikan pergantungan (DI) dalam aplikasi Go.

Ore direka untuk memudahkan dan meningkatkan kecekapan DI tanpa memperkenalkan overhed prestasi yang ketara. Tidak seperti kebanyakan perpustakaan DI lain, Ore menggunakan Go Generics dan bukannya refleksi atau penjanaan kod, memastikan aplikasi anda kekal pantas dan selamat jenis. Ini menjadikan Ore sesuai untuk pembangun yang mencari penyelesaian DI yang cekap dan mudah digunakan. Dalam artikel ini, kami akan memperkenalkan ciri utama Ore dan cara ia boleh membantu anda mengurus kebergantungan dalam Go. Kami juga akan menunjukkan beberapa contoh kod asas untuk menunjukkan cara Ore boleh digunakan dalam aplikasi sebenar.

---

Ciri utama Ore

1.

Suntikan pergantungan berasaskan generik

Ore menggunakan

Go generik

untuk mendaftar dan menyelesaikan kebergantungan. Pilihan reka bentuk ini mengelakkan overhed prestasi yang biasanya dikaitkan dengan refleksi dan penjanaan kod. Dengan menggunakan generik, Ore memastikan bahawa resolusi pergantungan adalah selamat jenis dan cekap, tanpa sebarang jenis pemeriksaan masa jalan. Pendekatan ini menjadikan Ore sebagai penyelesaian DI berprestasi tinggi kerana ia mengelakkan perangkap refleksi dan penjanaan kod yang biasa dalam banyak rangka kerja DI lain.

2.

Pendaftaran yang mudah dan fleksibel

Ore menyediakan pelbagai cara untuk mendaftar perkhidmatan, membolehkan anda memilih secara fleksibel mengikut kitaran hayat perkhidmatan (contohnya, tunggal, skop, sementara). Sama ada anda memerlukan satu contoh, contoh berskop untuk konteks tertentu, atau contoh sementara yang dibuat pada setiap permintaan, Ore telah melindungi anda.

3.

Perkhidmatan Kunci

Ore membolehkan anda mendaftar dan menyelesaikan berbilang pelaksanaan antara muka yang sama menggunakan

perkhidmatan berkunci

. Ciri ini berguna apabila anda perlu mengurus berbilang versi perkhidmatan atau perlu melaksanakan gelagat berbeza berdasarkan syarat tertentu. Sebagai contoh, anda boleh membuat berbilang pelaksanaan perkhidmatan untuk persekitaran yang berbeza (cth., ujian, pengeluaran) atau konfigurasi yang berbeza (cth., berdasarkan peranan pengguna).

4.

Perkhidmatan Pemegang Tempat

Ore juga menyokong

Perkhidmatan Pemegang Tempat

, membolehkan anda mendaftarkan perkhidmatan dengan kebergantungan tidak dapat diselesaikan yang boleh diisi pada masa jalan. Ciri ini berguna apabila beberapa nilai atau perkhidmatan tidak tersedia pada masa pendaftaran, tetapi tersedia kemudian. Sebagai contoh, anda boleh mendaftarkan perkhidmatan yang memerlukan nilai konfigurasi dan kemudian menyediakan konfigurasi sebenar secara dinamik berdasarkan konteks (cth., peranan pengguna atau persekitaran).

5. Pengesahan

Ore termasuk terbina dalam Pengesahan Pendaftaran yang menangkap isu biasa seperti:

• Hilang tanggungan: Pastikan semua perkhidmatan yang diperlukan didaftarkan.
• Kebergantungan Pekeliling: Kesan dan cegah rantai pergantungan bulat.
• Ketakpadanan kitaran hayat: Pastikan perkhidmatan dengan kitaran hayat yang lebih panjang tidak bergantung pada perkhidmatan dengan kitaran hayat yang lebih pendek.

Pengesahan ini berlaku secara automatik apabila anda menggunakan ore.Get atau ore.GetList untuk menyelesaikan perkhidmatan, tetapi anda juga boleh mencetuskan pengesahan secara manual menggunakan ore.Validate(). Ini memastikan graf pergantungan anda betul dan mengelakkan ralat masa jalan akibat salah konfigurasi.

Selain itu, anda boleh melumpuhkan pengesahan atas sebab prestasi atau mengelak bekas untuk mengelakkan pengubahsuaian selanjutnya selepas mendaftarkan semua perkhidmatan.

6. Prestasi tinggi

Prestasi adalah pertimbangan utama dalam Ore. Dengan mengelakkan refleksi dan penjanaan kod, Ore kekal pantas, walaupun dalam aplikasi besar dengan graf pergantungan yang kompleks. Keputusan penanda aras Ore menunjukkan kecekapannya, dengan operasi tertentu mengambil masa hanya beberapa nanosaat untuk diselesaikan. Ini menjadikan Ore pilihan yang sangat baik untuk aplikasi Go berprestasi tinggi yang memerlukan DI yang cekap tanpa overhed tambahan.

7. Pemodularan dan Bekas Skop

Ore menyokong bekas modular, membolehkan anda mentakrifkan bekas berasingan untuk bahagian aplikasi anda yang berbeza. Ini amat berguna untuk aplikasi modular, di mana komponen atau modul yang berbeza mempunyai kebergantungan yang berbeza. Anda boleh menentukan bekas berskop untuk kes penggunaan yang berbeza, menjadikan pengurusan pergantungan anda lebih teratur dan lebih mudah diselenggara.

---

Contoh Kod

Untuk lebih memahami cara Ore berfungsi, mari lihat beberapa contoh mudah menggunakan bekas Ore lalai.

Contoh 1: Pendaftaran dan penyelesaian Perkhidmatan Asas

package main

import (
    "context"
    "fmt"
    "github.com/firasdarwish/ore"
)

// 定义一个接口
type Greeter interface {
    Greet() string
}

// 定义一个服务实现
type FriendlyGreeter struct{}

func (g *FriendlyGreeter) Greet() string {
    return "Hello, world!"
}

func main() {
    // 使用默认Ore容器注册服务
    ore.RegisterFunc[Greeter](ore.Singleton, func(ctx context.Context) (Greeter, context.Context) {
        return &FriendlyGreeter{}, ctx
    })

    // 从默认Ore容器解析服务
    greeter, _ := ore.Get[Greeter](context.Background())
    fmt.Println(greeter.Greet()) // 输出：Hello, world!
}

Contoh ini menunjukkan pendaftaran perkhidmatan. Di sini, kami mentakrifkan antara muka Greeter dan pelaksanaan FriendlyGreeter, mendaftarkannya sebagai singleton, dan kemudian menyelesaikannya menggunakan bekas Ore lalai.

Contoh 2: Perkhidmatan berkunci digunakan dalam berbilang pelaksanaan

package main

import (
    "context"
    "fmt"
    "github.com/firasdarwish/ore"
)

// 定义一个接口
type Greeter interface {
    Greet() string
}

// 定义多个实现
type FriendlyGreeter struct{}

func (g *FriendlyGreeter) Greet() string {
    return "Hello, friend!"
}

type FormalGreeter struct{}

func (g *FormalGreeter) Greet() string {
    return "Good day, Sir/Madam."
}

func main() {
    // 使用键注册多个实现
    ore.RegisterKeyedFunc[Greeter](ore.Singleton, func(ctx context.Context) (Greeter, context.Context) {
        return &FriendlyGreeter{}, ctx
    }, "friendly")

    ore.RegisterKeyedFunc[Greeter](ore.Singleton, func(ctx context.Context) (Greeter, context.Context) {
        return &FormalGreeter{}, ctx
    }, "formal")

    // 根据键解析特定实现
    greeter, _ := ore.GetKeyed[Greeter](context.Background(), "friendly")
    fmt.Println(greeter.Greet()) // 输出：Hello, friend!

    greeter, _ = ore.GetKeyed[Greeter](context.Background(), "formal")
    fmt.Println(greeter.Greet()) // 输出：Good day, Sir/Madam.
}

Dalam contoh ini, kami mendaftarkan dua pelaksanaan antara muka Greeter dengan kekunci ("mesra" dan "formal") dan menyelesaikannya berdasarkan kekunci yang diperlukan. Fleksibiliti ini membolehkan anda mengurus pelaksanaan yang berbeza dengan mudah.

---

Kesimpulan

Ore menyediakan penyelesaian suntikan pergantungan yang ringkas, mudah dan cekap untuk Go. Dengan menggunakan Go generik, Ore menyediakan resolusi pergantungan cepat dan jenis-selamat tanpa overhed prestasi refleksi. Ia fleksibel dan mudah digunakan serta termasuk ciri seperti Perkhidmatan Berkunci, Perkhidmatan Pemegang Tempat dan Pengesahan untuk memastikan permohonan anda kekal teguh.

Tapak Web Dokumentasi Bijih

Repositori GitHub

Atas ialah kandungan terperinci Bijih: Pakej Suntikan Ketergantungan Lanjutan untuk Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!