gin-vue-admin-7

思考并回答以下问题：

api

api/v1/system/sys_initdb.go

package system

import (
    "github.com/flipped-aurora/gin-vue-admin/server/global"
    "github.com/flipped-aurora/gin-vue-admin/server/model/common/response"
    "github.com/flipped-aurora/gin-vue-admin/server/model/system/request"
    "go.uber.org/zap"

    "github.com/gin-gonic/gin"
)

type DBApi struct{}

// InitDB
// @Tags     InitDB
// @Summary  初始化用户数据库
// @Produce  application/json
// @Param    data  body      request.InitDB                  true  "初始化数据库参数"
// @Success  200   {object}  response.Response{data=string}  "初始化用户数据库"
// @Router   /init/initdb [post]
func (i *DBApi) InitDB(c *gin.Context) {
    if global.GVA_DB != nil {
        global.GVA_LOG.Error("已存在数据库配置!")
        response.FailWithMessage("已存在数据库配置", c)
        return
    }
    var dbInfo request.InitDB
    if err := c.ShouldBindJSON(&dbInfo); err != nil {
        global.GVA_LOG.Error("参数校验不通过!", zap.Error(err))
        response.FailWithMessage("参数校验不通过", c)
        return
    }
    if err := initDBService.InitDB(dbInfo); err != nil {
        global.GVA_LOG.Error("自动创建数据库失败!", zap.Error(err))
        response.FailWithMessage("自动创建数据库失败，请查看后台日志，检查后在进行初始化", c)
        return
    }
    response.OkWithMessage("自动创建数据库成功", c)
}

// CheckDB
// @Tags     CheckDB
// @Summary  初始化用户数据库
// @Produce  application/json
// @Success  200  {object}  response.Response{data=map[string]interface{},msg=string}  "初始化用户数据库"
// @Router   /init/checkdb [post]
func (i *DBApi) CheckDB(c *gin.Context) {
    var (
        message  = "前往初始化数据库"
        needInit = true
    )

    if global.GVA_DB != nil {
        message = "数据库无需初始化"
        needInit = false
    }
    global.GVA_LOG.Info(message)
    response.OkWithDetailed(gin.H{"needInit": needInit}, message, c)
}

service

service/system/sys_initdb.go

package system

import (
    "context"
    "database/sql"
    "errors"
    "fmt"
    "github.com/flipped-aurora/gin-vue-admin/server/global"
    "github.com/flipped-aurora/gin-vue-admin/server/model/system/request"
    "gorm.io/gorm"
    "sort"
)

const (
    Mysql           = "mysql"
    Pgsql           = "pgsql"
    InitSuccess     = "\n[%v] --> 初始数据成功!\n"
    InitDataExist   = "\n[%v] --> %v 的初始数据已存在!\n"
    InitDataFailed  = "\n[%v] --> %v 初始数据失败! \nerr: %+v\n"
    InitDataSuccess = "\n[%v] --> %v 初始数据成功!\n"
)

const (
    InitOrderSystem   = 10
    InitOrderInternal = 1000
    InitOrderExternal = 100000
)

var (
    ErrMissingDBContext        = errors.New("missing db in context")
    ErrMissingDependentContext = errors.New("missing dependent value in context")
    ErrDBTypeMismatch          = errors.New("db type mismatch")
)

// SubInitializer 提供 source/*/init() 使用的接口，每个 initializer 完成一个初始化过程
type SubInitializer interface {
    InitializerName() string // 不一定代表单独一个表，所以改成了更宽泛的语义
    MigrateTable(ctx context.Context) (next context.Context, err error)
    InitializeData(ctx context.Context) (next context.Context, err error)
    TableCreated(ctx context.Context) bool
    DataInserted(ctx context.Context) bool
}

// TypedDBInitHandler 执行传入的 initializer
type TypedDBInitHandler interface {
    EnsureDB(ctx context.Context, conf *request.InitDB) (context.Context, error) // 建库，失败属于 fatal error，因此让它 panic
    WriteConfig(ctx context.Context) error                                       // 回写配置
    InitTables(ctx context.Context, inits initSlice) error                       // 建表 handler
    InitData(ctx context.Context, inits initSlice) error                         // 建数据 handler
}

// orderedInitializer 组合一个顺序字段，以供排序
type orderedInitializer struct {
    order int
    SubInitializer
}

// initSlice 供 initializer 排序依赖时使用
type initSlice []*orderedInitializer

var (
    initializers initSlice
    cache        map[string]*orderedInitializer
)

// RegisterInit 注册要执行的初始化过程，会在 InitDB() 时调用
func RegisterInit(order int, i SubInitializer) {
    if initializers == nil {
        initializers = initSlice{}
    }
    if cache == nil {
        cache = map[string]*orderedInitializer{}
    }
    name := i.InitializerName()
    if _, existed := cache[name]; existed {
        panic(fmt.Sprintf("Name conflict on %s", name))
    }
    ni := orderedInitializer{order, i}
    initializers = append(initializers, &ni)
    cache[name] = &ni
}

/* ---- * service * ---- */

type InitDBService struct{}

// InitDB 创建数据库并初始化 总入口
func (initDBService *InitDBService) InitDB(conf request.InitDB) (err error) {
    ctx := context.TODO()
    if len(initializers) == 0 {
        return errors.New("无可用初始化过程，请检查初始化是否已执行完成")
    }
    sort.Sort(&initializers) // 保证有依赖的 initializer 排在后面执行
    // Note: 若 initializer 只有单一依赖，可以写为 B=A+1, C=A+1; 由于 BC 之间没有依赖关系，所以谁先谁后并不影响初始化
    // 若存在多个依赖，可以写为 C=A+B, D=A+B+C, E=A+1;
    // C必然>A|B，因此在AB之后执行，D必然>A|B|C，因此在ABC后执行，而E只依赖A，顺序与CD无关，因此E与CD哪个先执行并不影响
    var initHandler TypedDBInitHandler
    switch conf.DBType {
    case "mysql":
        initHandler = NewMysqlInitHandler()
        ctx = context.WithValue(ctx, "dbtype", "mysql")
    case "pgsql":
        initHandler = NewPgsqlInitHandler()
        ctx = context.WithValue(ctx, "dbtype", "pgsql")
    default:
        initHandler = NewMysqlInitHandler()
        ctx = context.WithValue(ctx, "dbtype", "mysql")
    }
    ctx, err = initHandler.EnsureDB(ctx, &conf)
    if err != nil {
        return err
    }

    db := ctx.Value("db").(*gorm.DB)
    global.GVA_DB = db

    if err = initHandler.InitTables(ctx, initializers); err != nil {
        return err
    }
    if err = initHandler.InitData(ctx, initializers); err != nil {
        return err
    }

    if err = initHandler.WriteConfig(ctx); err != nil {
        return err
    }
    initializers = initSlice{}
    cache = map[string]*orderedInitializer{}
    return nil
}

// createDatabase 创建数据库（ EnsureDB() 中调用 ）
func createDatabase(dsn string, driver string, createSql string) error {
    db, err := sql.Open(driver, dsn)
    if err != nil {
        return err
    }
    defer func(db *sql.DB) {
        err = db.Close()
        if err != nil {
            fmt.Println(err)
        }
    }(db)
    if err = db.Ping(); err != nil {
        return err
    }
    _, err = db.Exec(createSql)
    return err
}

// createTables 创建表（默认 dbInitHandler.initTables 行为）
func createTables(ctx context.Context, inits initSlice) error {
    next, cancel := context.WithCancel(ctx)
    defer func(c func()) { c() }(cancel)
    for _, init := range inits {
        if init.TableCreated(next) {
            continue
        }
        if n, err := init.MigrateTable(next); err != nil {
            return err
        } else {
            next = n
        }

    }
    return nil
}

/* -- sortable interface -- */

func (a initSlice) Len() int {
    return len(a)
}

func (a initSlice) Less(i, j int) bool {
    return a[i].order < a[j].order
}

func (a initSlice) Swap(i, j int) {
    a[i], a[j] = a[j], a[i]
}

service/system/sys_initdb_mysql.go

package system

import (
    "context"
    "errors"
    "fmt"
    "path/filepath"

    "github.com/flipped-aurora/gin-vue-admin/server/config"
    "github.com/gookit/color"

    "github.com/flipped-aurora/gin-vue-admin/server/utils"

    "github.com/flipped-aurora/gin-vue-admin/server/global"
    "github.com/flipped-aurora/gin-vue-admin/server/model/system/request"
    "github.com/gofrs/uuid"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

type MysqlInitHandler struct{}

func NewMysqlInitHandler() *MysqlInitHandler {
    return &MysqlInitHandler{}
}

// WriteConfig mysql回写配置
func (h MysqlInitHandler) WriteConfig(ctx context.Context) error {
    c, ok := ctx.Value("config").(config.Mysql)
    if !ok {
        return errors.New("mysql config invalid")
    }
    global.GVA_CONFIG.System.DbType = "mysql"
    global.GVA_CONFIG.Mysql = c
    global.GVA_CONFIG.JWT.SigningKey = uuid.Must(uuid.NewV4()).String()
    cs := utils.StructToMap(global.GVA_CONFIG)
    for k, v := range cs {
        global.GVA_VP.Set(k, v)
    }
    return global.GVA_VP.WriteConfig()
}

// EnsureDB 创建数据库并初始化 mysql
func (h MysqlInitHandler) EnsureDB(ctx context.Context, conf *request.InitDB) (next context.Context, err error) {
    if s, ok := ctx.Value("dbtype").(string); !ok || s != "mysql" {
        return ctx, ErrDBTypeMismatch
    }

    c := conf.ToMysqlConfig()
    next = context.WithValue(ctx, "config", c)
    if c.Dbname == "" {
        return ctx, nil
    } // 如果没有数据库名, 则跳出初始化数据

    dsn := conf.MysqlEmptyDsn()
    createSql := fmt.Sprintf("CREATE DATABASE IF NOT EXISTS `%s` DEFAULT CHARACTER SET utf8mb4 DEFAULT COLLATE utf8mb4_general_ci;", c.Dbname)
    if err = createDatabase(dsn, "mysql", createSql); err != nil {
        return nil, err
    } // 创建数据库

    var db *gorm.DB
    if db, err = gorm.Open(mysql.New(mysql.Config{
        DSN:                       c.Dsn(), // DSN data source name
        DefaultStringSize:         191,     // string 类型字段的默认长度
        SkipInitializeWithVersion: true,    // 根据版本自动配置
    }), &gorm.Config{DisableForeignKeyConstraintWhenMigrating: true}); err != nil {
        return ctx, err
    }
    global.GVA_CONFIG.AutoCode.Root, _ = filepath.Abs("..")
    next = context.WithValue(next, "db", db)
    return next, err
}

func (h MysqlInitHandler) InitTables(ctx context.Context, inits initSlice) error {
    return createTables(ctx, inits)
}

func (h MysqlInitHandler) InitData(ctx context.Context, inits initSlice) error {
    next, cancel := context.WithCancel(ctx)
    defer func(c func()) { c() }(cancel)
    for _, init := range inits {
        if init.DataInserted(next) {
            color.Info.Printf(InitDataExist, Mysql, init.InitializerName())
            continue
        }
        if n, err := init.InitializeData(next); err != nil {
            color.Info.Printf(InitDataFailed, Mysql, init.InitializerName(), err)
            return err
        } else {
            next = n
            color.Info.Printf(InitDataSuccess, Mysql, init.InitializerName())
        }
    }
    color.Info.Printf(InitSuccess, Mysql)
    return nil
}