Gemeinsame Nutzung einer global definierten db conn mit mehreren Paketen in Golang

Question

Ich habe ein paar StackOverflow-Antworten gelesen, wie wir die db-Verbindung handhaben. Da es sich um einen Pool handelt, können wir ihn global definieren und in mehreren Gruppen verwenden.

Das Problem, das ich habe, ist, dass ich meine REST API in mehrere Pakete aufgeteilt habe. Jedes dieser Pakete benötigt eine db-Verbindung, also öffne ich beim Start eine Datenbankverbindung. Aber selbst wenn ich die Verbindung global definiere, ist es nur auf der Paketebene. Was kann ich tun, um es unter mehreren Paketen zu teilen?

Für einige Kontext verwende ich den PostgreSQL-Treiber und Gin-gonic in meiner Anwendung.

Answer 1

Es besteht auch die Möglichkeit, ein anderes Paket zu erstellen, das die Einstellungen für die Datenbankverbindung enthält. Es kann dann eine globale Paketebene haben, die in main initialisiert und in jedem Paket verwendet werden kann, das es importiert.

Auf diese Weise können Sie explizit sehen, dass das Datenbankpaket importiert wird. Hier ist ein Beispielcode.

package database 

var (
    // DBCon is the connection handle 
    // for the database 
    DBCon *sql.DB 
) 

---

package main 

import "myApp/database" 

func main() { 

    var err error 
    database.DBCon, err = sql.Open("postgres", "user=myname dbname=dbname sslmode=disable") 

} 

---

package user 

import "myApp/database" 

func Index() { 
    // database handle is available here 
    database.DBCon 

    ... 
} 

Answer 2

Einfache Antwort: Übergeben Sie einen initialisierten Verbindungspool an die eigenen Globals Ihrer Pakete.

z.B.

// package stuff 

var DB *sql.DB 

func GetAllStuff() (*Stuff, error) { 
    err := DB.Query("...") 
    // etc. 
} 

// package things 

var DB *sql.DB 

func GetAllThings() (*Thing, error) { 
    err := DB.Query("...") 
    // etc. 
} 

// package main 

func main() { 
    db, err := sql.Open("...") 
    if err != nil { 
     log.Fatal(err) 
    } 

    stuff.DB = db 
    things.DB = db 

    // etc. 
} 

Wir definieren Paketebene Globals, stellen Sie sicher, dass sie exportiert (aktiviert) und dann einen Zeiger auf unsere Verbindungspool an sie weitergeben.

Dies ist "okay", aber kann "wo" Dinge verwendet werden maskieren. Wenn Sie einen Handler betrachten, ist es möglicherweise nicht klar wo die Verbindung herkommt, besonders wenn Ihr Paket wächst. Ein skalierbarer Ansatz könnte wie folgt aussehen:

// package stuff 

type DB struct { 
    *sql.DB 
} 

func New(db *sql.DB) (*DB, error) { 
    // Configure any package-level settings 
    return &DB{db}, nil 
} 

func (db *DB) GetAllStuff() (*Stuff, error) { 
    err := db.Query("...") 
    // etc. 
} 

// package things 

type DB struct { 
    *sql.DB 
} 

func New(db *sql.DB) (*DB, error) { 
    // Configure any package-level settings 
    return &DB{db}, nil 
} 

func (db *DB) GetAllThings() (*Thing, error) { 
    err := db.Query("...") 
    // etc. 
} 

// package main 

func main() { 
    db, err := sql.Open("...") 
    if err != nil { 
     log.Fatal(err) 
    } 

    stuffDB, err := stuff.New(db) 
    if err != nil { 
     log.Fatal(err) 
    } 

    thingsDB, err := things.New(db) 
    if err != nil { 
     log.Fatal(err) 
    } 

    // Simplified. 
    http.HandleFunc("/stuff/all", stuff.ShowStuffHandler(stuffDB)) 
    http.HandleFunc("/things/all", things.ShowThingsHandler(thingsDB)) 

    // etc. 
} 

func ShowStuffHandler(db *stuff.DB) http.HandlerFunc { 
    return func(w http.ResponseWriter, r *http.Request) { 
     // We can use our stuff.DB here 
     stuff, err := db.GetAllStuff() 
     // etc. 
    } 
} 

Wenn Sie mehr als nur die DB-Verbindung als Abhängigkeit (zB Konfigurationsparameter erstellt, Host-Namen, etc.), wickeln Sie sie in einer things.Env Struktur oder eine stuff.Env struct für jedes Paket.

Ein Beispiel wäre eine things.New("deps...") *Env Funktion, die eine konfigurierte *things.Env zurückgibt, die die Abhängigkeiten enthält, die von Ihrem things-Paket verwendet werden.