[GO] [Los] Ich möchte Endpunkte durch Lesen / Schreiben in die Datenbank trennen

Einführung

Um die Replikation zu unterstützen, haben wir beschlossen, den DB-Endpunkt durch Lesen / Schreiben zu teilen. Ich habe untersucht, wie man mit Go / Gorm2 damit umgeht.

Nutzungsumgebung

• Go: 1.15.2
• Gorm2: v1.20.1
• Echo: v4.1.17

Aus der Schlussfolgerung

Jede Gorm-Methode ist in einen Typ eingeschlossen, der für jeden Endpunkt mehrere Verbindungen hat. Auf diese Weise kann die Seite, die die Verbindung verwendet, die Datenbank betreiben, ohne den Endpunkt zu kennen.

db/connect.go

package db

import (
	"os"

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

type SqlHandler struct {
	ReadConn  *gorm.DB
	WriteConn *gorm.DB
}

func Connect() *SqlHandler {
	readConn, err := gorm.Open(GetDBConfig("read"))
	if err != nil {
		panic(err.Error())
	}

	writeConn, err := gorm.Open(GetDBConfig("write"))
	if err != nil {
		panic(err.Error())
	}

	sqlHandler := SqlHandler{
		ReadConn:  readConn,
		WriteConn: writeConn,
	}

	return &sqlHandler
}

func GetDBConfig(endpoint string) (gorm.Dialector, *gorm.Config) {
	USER := "myUser"
	PASS := "hoge1234"
	PROTOCOL := "tcp(" + endpoint + ":5050)"
	DBNAME := "myDB"
	OPTION := "charset=utf8&parseTime=True&loc=Local"

	mysqlConfig := mysql.Config{
		DSN: USER + ":" + PASS + "@" + PROTOCOL + "/" + DBNAME + "?" + OPTION,
	}

	config := &gorm.Config{}

	return mysql.New(mysqlConfig), config
}

func (handler *SqlHandler) Find(out interface{}, where ...interface{}) *gorm.DB {
	return handler.ReadConn.Find(out, where...)
}

func (handler *SqlHandler) Exec(sql string, values ...interface{}) *gorm.DB {
	return handler.WriteConn.Exec(sql, values...)
}

func (handler *SqlHandler) First(out interface{}, where ...interface{}) *gorm.DB {
	return handler.ReadConn.Find(out, where...)
}

func (handler *SqlHandler) Raw(sql string, values ...interface{}) *gorm.DB {
	return handler.WriteConn.Raw(sql, values...)
}

func (handler *SqlHandler) Create(value interface{}) *gorm.DB {
	return handler.WriteConn.Create(value)
}

func (handler *SqlHandler) Save(value interface{}) *gorm.DB {
	return handler.WriteConn.Save(value)
}

func (handler *SqlHandler) Delete(value interface{}) *gorm.DB {
	return handler.WriteConn.Delete(value)
}

func (handler *SqlHandler) Where(query interface{}, args ...interface{}) *gorm.DB {
	return handler.WriteConn.Where(query, args...)
}

Reproduzieren

ist, was

[Replikation](https://ja.wikipedia.org/wiki/%E3%83%AC%E3%83%97%E3%83%AA%E3%82%B1%E3%83%BC%E3%82 % B7% E3% 83% A7% E3% 83% B3)

Orte der Besorgnis

Für die Teile, die von der Abfrage selbst ausgegeben werden können, wie z. B. "func Exec" und "func Raw", besteht die Möglichkeit sowohl des Lesens als auch des Schreibens, und es ist schwierig zu entscheiden, welche verwendet werden sollen. Dieses Mal habe ich es zum Schreiben zugewiesen. Benutzer möchten es so weit wie möglich verwenden können, ohne die Endpunkte zu kennen ...

abschließend

Ich habe mich für CQRS entschieden und bin der Meinung, dass SQL Solid Writing in erster Linie zunehmen wird. Die Bedeutung der Verwendung von Gorm ist etwas geringer, aber ich würde es gerne sehen, wenn ich die Zuordnung zu Type als ORM betrachte. Ich denke, es wäre gut, nur den Mapping-Teil selbst zu machen! !!

Referenz

• Golang - Erstellen einer API für saubere Architektur mit Echo und GORM