Udostępnianie zdefiniowanego globalnie db conn z wieloma pakietami w Golang

Question

Przeczytałem kilka odpowiedzi StackOverflow na sposób obsługi połączenia db. Ponieważ jest to pula, możemy ją zdefiniować globalnie i używać jej w wielu goroutinach i jest bezpieczna.

Problem, który mam, polega na tym, że podzieliłem mój interfejs REST API na wiele pakietów. Każdy z tych pakietów wymaga połączenia db, więc otwieram połączenie z bazą danych podczas uruchamiania. Ale nawet jeśli definiuję połączenie globalnie, jest to tylko na poziomie pakietu. Co mogę zrobić, aby potencjalnie udostępnić go w wielu pakietach?

Dla niektórych kontekstów używam sterownika PostgreSQL i gin-gonic w mojej aplikacji.

Answer 1

Istnieje również możliwość utworzenia innego pakietu do przechowywania ustawień związanych z połączeniem z bazą danych. Może wtedy mieć globalny poziom pakietu, który można zainicjować w main i użyć go w każdym pakiecie, który go importuje.

W ten sposób można wyraźnie zobaczyć, że pakiet bazy danych jest importowany. Oto przykładowy kod.

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

Prosta odpowiedź: przekazanie zainicjowanej puli połączeń do swoich globalnych pakietów.

np.

// 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. 
} 

Definiujemy globalnych pakiet poziomie, upewnij się one eksportowane (kapitalizowane), a następnie przekazać wskaźnik do naszej puli połączeń do nich.

To jest "w porządku", ale może maskować "gdzie" rzeczy są używane. Jeśli patrzysz na handler'a, może nie być jasne, , z którego pochodzi, zwłaszcza w miarę wzrostu paczki. Bardziej skalowalne podejście może wyglądać jak poniżej:

// 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. 
    } 
} 

Jeśli masz więcej niż tylko połączenia DB jako zależność (np config params, hostów, etc.), owinąć je w things.Env struct lub stuff.Env struct dla każdej paczki.

Przykładem może być funkcja things.New("deps...") *Env, która zwraca skonfigurowany *things.Env, który zawiera zależności używane przez pakiet things.