Dalam pengaturcaraan GO, bagaimana untuk menguruskan sambungan dan melepaskan sumber antara MySQL dan Redis dengan betul?

Pengurusan yang berkesan MySQL dan Redis Connection Resources dalam Bahasa Go

Dalam pembangunan bahasa Go, terutamanya apabila berurusan dengan pangkalan data (seperti MySQL) dan cache (seperti Redis), adalah penting untuk menguruskan sumber yang berkaitan dengan cekap. Artikel ini akan meneroka cara memulakan, menggunakan, dan melepaskan sambungan MySQL dan Redis dengan betul untuk mengelakkan kebocoran sumber.

Pertama, mari kita lihat salah faham pengurusan sumber umum. Ramai pemaju digunakan untuk membuat pangkalan data global atau sambungan cache apabila program ini dimulakan dan digunakan semula sepanjang kitaran hayat aplikasi. Walaupun kaedah ini mudah, mudah untuk menyebabkan masalah yang sumber tidak dapat dikeluarkan apabila permohonan ditutup.

Pengurusan Sambungan Redis

Katakan anda menggunakan pakej github.com/go-redis/redis . Ia tidak disyorkan untuk menggunakan pembolehubah global untuk terus memegang sambungan klien Redis. Pendekatan yang lebih baik adalah menggunakan kolam sambungan dan dapatkan sambungan dari kolam jika diperlukan dan mengembalikannya selepas digunakan. Ini dapat mengawal jumlah sambungan dan mengelakkan keletihan sumber.

Contoh kod (menggunakan kolam sambungan):

 import (
    "Konteks"
    "github.com/go-redis/redis/v8"
)

var redispool *redis.client

funculredispool () {
    redispool = redis.newClient (& redis.Options {
        // ... parameter sambungan ...
    })
}

Func GetRedisclient (ctx context.context) (*redis.client, error) {
    kembali redispool, nil // memudahkan contoh, aplikasi praktikal mungkin memerlukan pengurusan kolam yang lebih kompleks}

Funce setRedisValue (ctx context.context, rentetan kunci, antara muka nilai {}) error {
    Pelanggan, Err: = GetRedisclient (CTX)
    jika err! = nil {
        kembali err
    }
    menangguhkan klien.close () // pastikan sambungan dikeluarkan kembali client.set (ctx, kunci, nilai, 0) .err ()
}

Pengurusan Sambungan MySQL

Bagi MySQL, ia juga tidak disyorkan untuk memegang sambungan pangkalan data secara global apabila menggunakan rangka kerja ORM (seperti Gorm). Gorm sendiri menyediakan mekanisme penyatuan sambungan, tetapi ia masih perlu menutup sambungan pada masa yang tepat. Amalan yang lebih baik ialah membuka sambungan dalam setiap fungsi pengendali yang diminta dan menutup sambungan pada akhir fungsi. Ini memastikan bahawa setiap permintaan mempunyai sambungan pangkalan data bebas, mengelakkan isu -isu konkurensi, dan secara automatik melepaskan sumber selepas permintaan selesai.

Kod Contoh (berdasarkan Gorm, satu sambungan setiap permintaan):

 import (
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

Func handlerequest (w http.responseWriter, r *http.request) {
    db, err: = gorm.open (mysql.open ("yur_dsn"), & gorm.config {})
    jika err! = nil {
        // ralat mengendalikan}
    menangguhkan db.close () // pastikan sambungan dikeluarkan // ... operasi pangkalan data ...

    sqldb, err: = db.db ()
    jika err! = nil {
        // ralat mengendalikan}
    menangguhkan sqldb.close () // pastikan sambungan asas dikeluarkan}

Meringkaskan

Sama ada Redis atau MySQL, anda harus mengelakkan menggunakan pembolehubah global untuk terus memegang sambungan. Menggunakan kolam sambungan atau membuat dan melepaskan sambungan dalam setiap permintaan dapat mengawal sumber yang lebih baik, mengelakkan kebocoran, dan meningkatkan kestabilan dan prestasi aplikasi. Apabila permohonan ditutup, adalah perlu untuk menutup kolam sambungan secara jelas atau semua sambungan terbuka. Ingat bahawa pengurusan sumber yang berkesan adalah kunci untuk menulis aplikasi GO yang mantap dan cekap.

Atas ialah kandungan terperinci Dalam pengaturcaraan GO, bagaimana untuk menguruskan sambungan dan melepaskan sumber antara MySQL dan Redis dengan betul?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!