gin-vue-admin-4

发表于 | 更新于 | 分类于
本文字数： 59k | 阅读时长 ≈ 53 分钟

思考并回答以下问题：

config

config/config.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package config

type Server struct {
    JWT     JWT     `mapstructure:"jwt" json:"jwt" yaml:"jwt"`
    Zap     Zap     `mapstructure:"zap" json:"zap" yaml:"zap"`
    Redis   Redis   `mapstructure:"redis" json:"redis" yaml:"redis"`
    Email   Email   `mapstructure:"email" json:"email" yaml:"email"`
    System  System  `mapstructure:"system" json:"system" yaml:"system"`
    Captcha Captcha `mapstructure:"captcha" json:"captcha" yaml:"captcha"`
    // auto
    AutoCode Autocode `mapstructure:"autocode" json:"autocode" yaml:"autocode"`
    // gorm
    Mysql  Mysql           `mapstructure:"mysql" json:"mysql" yaml:"mysql"`
    Mssql  Mssql           `mapstructure:"mssql" json:"mssql" yaml:"mssql"`
    Pgsql  Pgsql           `mapstructure:"pgsql" json:"pgsql" yaml:"pgsql"`
    Oracle Oracle          `mapstructure:"oracle" json:"oracle" yaml:"oracle"`
    DBList []SpecializedDB `mapstructure:"db-list" json:"db-list" yaml:"db-list"`
    // oss
    Local      Local      `mapstructure:"local" json:"local" yaml:"local"`
    Qiniu      Qiniu      `mapstructure:"qiniu" json:"qiniu" yaml:"qiniu"`
    AliyunOSS  AliyunOSS  `mapstructure:"aliyun-oss" json:"aliyun-oss" yaml:"aliyun-oss"`
    HuaWeiObs  HuaWeiObs  `mapstructure:"hua-wei-obs" json:"hua-wei-obs" yaml:"hua-wei-obs"`
    TencentCOS TencentCOS `mapstructure:"tencent-cos" json:"tencent-cos" yaml:"tencent-cos"`
    AwsS3      AwsS3      `mapstructure:"aws-s3" json:"aws-s3" yaml:"aws-s3"`

    Excel Excel `mapstructure:"excel" json:"excel" yaml:"excel"`
    Timer Timer `mapstructure:"timer" json:"timer" yaml:"timer"`

    // 跨域配置
    Cors CORS `mapstructure:"cors" json:"cors" yaml:"cors"`
}

config/gorm_mysql.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package config

type Mysql struct {
    GeneralDB `yaml:",inline" mapstructure:",squash"`
}

func (m *Mysql) Dsn() string {
    return m.Username + ":" + m.Password + "@tcp(" + m.Path + ":" + m.Port + ")/" + m.Dbname + "?" + m.Config
}

func (m *Mysql) GetLogMode() string {
    return m.LogMode
}

config/system.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package config

type System struct {
    Env           string `mapstructure:"env" json:"env" yaml:"env"`                                  // 环境值
    Addr          int    `mapstructure:"addr" json:"addr" yaml:"addr"`                               // 端口值
    DbType        string `mapstructure:"db-type" json:"db-type" yaml:"db-type"`                      // 数据库类型:mysql(默认)|sqlite|sqlserver|postgresql
    OssType       string `mapstructure:"oss-type" json:"oss-type" yaml:"oss-type"`                   // Oss类型
    UseMultipoint bool   `mapstructure:"use-multipoint" json:"use-multipoint" yaml:"use-multipoint"` // 多点登录拦截
    UseRedis      bool   `mapstructure:"use-redis" json:"use-redis" yaml:"use-redis"`                // 使用redis
    LimitCountIP  int    `mapstructure:"iplimit-count" json:"iplimit-count" yaml:"iplimit-count"`
    LimitTimeIP   int    `mapstructure:"iplimit-time" json:"iplimit-time" yaml:"iplimit-time"`
    RouterPrefix  string `mapstructure:"router-prefix" json:"router-prefix" yaml:"router-prefix"`
}

config/auto_code.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package config

type Autocode struct {
    TransferRestart bool   `mapstructure:"transfer-restart" json:"transfer-restart" yaml:"transfer-restart"`
    Root            string `mapstructure:"root" json:"root" yaml:"root"`
    Server          string `mapstructure:"server" json:"server" yaml:"server"`
    SApi            string `mapstructure:"server-api" json:"server-api" yaml:"server-api"`
    SPlug           string `mapstructure:"server-plug" json:"server-plug" yaml:"server-plug"`
    SInitialize     string `mapstructure:"server-initialize" json:"server-initialize" yaml:"server-initialize"`
    SModel          string `mapstructure:"server-model" json:"server-model" yaml:"server-model"`
    SRequest        string `mapstructure:"server-request" json:"server-request"  yaml:"server-request"`
    SRouter         string `mapstructure:"server-router" json:"server-router" yaml:"server-router"`
    SService        string `mapstructure:"server-service" json:"server-service" yaml:"server-service"`
    Web             string `mapstructure:"web" json:"web" yaml:"web"`
    WApi            string `mapstructure:"web-api" json:"web-api" yaml:"web-api"`
    WForm           string `mapstructure:"web-form" json:"web-form" yaml:"web-form"`
    WTable          string `mapstructure:"web-table" json:"web-table" yaml:"web-table"`
}

global

global/global.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package global

import (
    "sync"

    "github.com/flipped-aurora/gin-vue-admin/server/utils/timer"
    "github.com/songzhibin97/gkit/cache/local_cache"

    "golang.org/x/sync/singleflight"

    "go.uber.org/zap"

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

    "github.com/go-redis/redis/v8"
    "github.com/spf13/viper"
    "gorm.io/gorm"
)

var (
    GVA_DB     *gorm.DB
    GVA_DBList map[string]*gorm.DB
    GVA_REDIS  *redis.Client
    GVA_CONFIG config.Server
    GVA_VP     *viper.Viper
    // GVA_LOG    *oplogging.Logger
    GVA_LOG                 *zap.Logger
    GVA_Timer               timer.Timer = timer.NewTimerTask()
    GVA_Concurrency_Control             = &singleflight.Group{}

    BlackCache local_cache.Cache
    lock       sync.RWMutex
)

// GetGlobalDBByDBName 通过名称获取db list中的db
func GetGlobalDBByDBName(dbname string) *gorm.DB {
    lock.RLock()
    defer lock.RUnlock()
    return GVA_DBList[dbname]
}

// MustGetGlobalDBByDBName 通过名称获取db 如果不存在则panic
func MustGetGlobalDBByDBName(dbname string) *gorm.DB {
    lock.RLock()
    defer lock.RUnlock()
    db, ok := GVA_DBList[dbname]
    if !ok || db == nil {
        panic("db no init")
    }
    return db
}

global/model.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package global

import (
    "time"

    "gorm.io/gorm"
)

type GVA_MODEL struct {
    ID        uint           `gorm:"primarykey"` // 主键ID
    CreatedAt time.Time      // 创建时间
    UpdatedAt time.Time      // 更新时间
    DeletedAt gorm.DeletedAt `gorm:"index" json:"-"` // 删除时间
}

initialize

initialize/gorm.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package initialize

import (
    "os"

    "github.com/flipped-aurora/gin-vue-admin/server/global"
    "github.com/flipped-aurora/gin-vue-admin/server/model/example"
    "github.com/flipped-aurora/gin-vue-admin/server/model/system"

    "go.uber.org/zap"
    "gorm.io/gorm"
)

// Gorm 初始化数据库并产生数据库全局变量
// Author SliverHorn
func Gorm() *gorm.DB {
    switch global.GVA_CONFIG.System.DbType {
    case "mysql":
        return GormMysql()
    case "pgsql":
        return GormPgSql()
    case "oracle":
        return GormOracle()
    case "mssql":
        return GormMssql()
    default:
        return GormMysql()
    }
}

// RegisterTables 注册数据库表专用
// Author SliverHorn
func RegisterTables() {
    db := global.GVA_DB
    err := db.AutoMigrate(
        // 系统模块表
        system.SysApi{},
        system.SysUser{},
        system.SysBaseMenu{},
        system.JwtBlacklist{},
        system.SysAuthority{},
        system.SysDictionary{},
        system.SysOperationRecord{},
        system.SysAutoCodeHistory{},
        system.SysDictionaryDetail{},
        system.SysBaseMenuParameter{},
        system.SysBaseMenuBtn{},
        system.SysAuthorityBtn{},
        system.SysAutoCode{},
        system.SysChatGptOption{},

        example.ExaFile{},
        example.ExaCustomer{},
        example.ExaFileChunk{},
        example.ExaFileUploadAndDownload{},
    )
    if err != nil {
        global.GVA_LOG.Error("register table failed", zap.Error(err))
        os.Exit(0)
    }
    global.GVA_LOG.Info("register table success")
}

initialize/gorm_mysql.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package initialize

import (
    "github.com/flipped-aurora/gin-vue-admin/server/config"
    "github.com/flipped-aurora/gin-vue-admin/server/global"
    "github.com/flipped-aurora/gin-vue-admin/server/initialize/internal"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

// GormMysql 初始化Mysql数据库
// Author [piexlmax](https://github.com/piexlmax)
// Author [SliverHorn](https://github.com/SliverHorn)
func GormMysql() *gorm.DB {
    m := global.GVA_CONFIG.Mysql
    if m.Dbname == "" {
        return nil
    }
    mysqlConfig := mysql.Config{
        DSN:                       m.Dsn(), // DSN data source name
        DefaultStringSize:         191,     // string 类型字段的默认长度
        SkipInitializeWithVersion: false,   // 根据版本自动配置

    }
    if db, err := gorm.Open(mysql.New(mysqlConfig), internal.Gorm.Config(m.Prefix, m.Singular)); err != nil {
        return nil
    } else {
        db.InstanceSet("gorm:table_options", "ENGINE="+m.Engine)
        sqlDB, _ := db.DB()
        sqlDB.SetMaxIdleConns(m.MaxIdleConns)
        sqlDB.SetMaxOpenConns(m.MaxOpenConns)
        return db
    }
}

// GormMysqlByConfig 初始化Mysql数据库用过传入配置
func GormMysqlByConfig(m config.Mysql) *gorm.DB {
    if m.Dbname == "" {
        return nil
    }
    mysqlConfig := mysql.Config{
        DSN:                       m.Dsn(), // DSN data source name
        DefaultStringSize:         191,     // string 类型字段的默认长度
        SkipInitializeWithVersion: false,   // 根据版本自动配置
    }
    if db, err := gorm.Open(mysql.New(mysqlConfig), internal.Gorm.Config(m.Prefix, m.Singular)); err != nil {
        panic(err)
    } else {
        db.InstanceSet("gorm:table_options", "ENGINE=InnoDB")
        sqlDB, _ := db.DB()
        sqlDB.SetMaxIdleConns(m.MaxIdleConns)
        sqlDB.SetMaxOpenConns(m.MaxOpenConns)
        return db
    }
}

initialize/redis.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
package initialize

import (
    "net/http"

    "github.com/flipped-aurora/gin-vue-admin/server/docs"
    "github.com/flipped-aurora/gin-vue-admin/server/global"
    "github.com/flipped-aurora/gin-vue-admin/server/middleware"
    "github.com/flipped-aurora/gin-vue-admin/server/router"
    "github.com/gin-gonic/gin"
    ginSwagger "github.com/swaggo/gin-swagger"
    "github.com/swaggo/gin-swagger/swaggerFiles"
)

// 初始化总路由

func Routers() *gin.Engine {
    Router := gin.Default()
    InstallPlugin(Router) // 安装插件
    systemRouter := router.RouterGroupApp.System
    exampleRouter := router.RouterGroupApp.Example
    // 如果想要不使用nginx代理前端网页，可以修改 web/.env.production 下的
    // VUE_APP_BASE_API = /
    // VUE_APP_BASE_PATH = http://localhost
    // 然后执行打包命令 npm run build。在打开下面4行注释
    // Router.LoadHTMLGlob("./dist/*.html") // npm打包成dist的路径
    // Router.Static("/favicon.ico", "./dist/favicon.ico")
    // Router.Static("/static", "./dist/assets")   // dist里面的静态资源
    // Router.StaticFile("/", "./dist/index.html") // 前端网页入口页面

    Router.StaticFS(global.GVA_CONFIG.Local.StorePath, http.Dir(global.GVA_CONFIG.Local.StorePath)) // 为用户头像和文件提供静态地址
    // Router.Use(middleware.LoadTls())  // 如果需要使用https 请打开此中间件 然后前往 core/server.go 将启动模式 更变为 Router.RunTLS("端口","你的cre/pem文件","你的key文件")
    // 跨域，如需跨域可以打开下面的注释
    // Router.Use(middleware.Cors()) // 直接放行全部跨域请求
    // Router.Use(middleware.CorsByRules()) // 按照配置的规则放行跨域请求
    //global.GVA_LOG.Info("use middleware cors")
    docs.SwaggerInfo.BasePath = global.GVA_CONFIG.System.RouterPrefix
    Router.GET(global.GVA_CONFIG.System.RouterPrefix+"/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))
    global.GVA_LOG.Info("register swagger handler")
    // 方便统一添加路由组前缀 多服务器上线使用

    PublicGroup := Router.Group(global.GVA_CONFIG.System.RouterPrefix)
    {
        // 健康监测
        PublicGroup.GET("/health", func(c *gin.Context) {
            c.JSON(http.StatusOK, "ok")
        })
    }
    {
        systemRouter.InitBaseRouter(PublicGroup) // 注册基础功能路由 不做鉴权
        systemRouter.InitInitRouter(PublicGroup) // 自动初始化相关
    }
    PrivateGroup := Router.Group(global.GVA_CONFIG.System.RouterPrefix)
    PrivateGroup.Use(middleware.JWTAuth()).Use(middleware.CasbinHandler())
    {
        systemRouter.InitApiRouter(PrivateGroup, PublicGroup)    // 注册功能api路由
        systemRouter.InitJwtRouter(PrivateGroup)                 // jwt相关路由
        systemRouter.InitUserRouter(PrivateGroup)                // 注册用户路由
        systemRouter.InitMenuRouter(PrivateGroup)                // 注册menu路由
        systemRouter.InitSystemRouter(PrivateGroup)              // system相关路由
        systemRouter.InitCasbinRouter(PrivateGroup)              // 权限相关路由
        systemRouter.InitAutoCodeRouter(PrivateGroup)            // 创建自动化代码
        systemRouter.InitAuthorityRouter(PrivateGroup)           // 注册角色路由
        systemRouter.InitSysDictionaryRouter(PrivateGroup)       // 字典管理
        systemRouter.InitAutoCodeHistoryRouter(PrivateGroup)     // 自动化代码历史
        systemRouter.InitSysOperationRecordRouter(PrivateGroup)  // 操作记录
        systemRouter.InitSysDictionaryDetailRouter(PrivateGroup) // 字典详情管理
        systemRouter.InitAuthorityBtnRouterRouter(PrivateGroup)  // 字典详情管理
        systemRouter.InitChatGptRouter(PrivateGroup)             // chatGpt接口

        exampleRouter.InitCustomerRouter(PrivateGroup)              // 客户路由
        exampleRouter.InitFileUploadAndDownloadRouter(PrivateGroup) // 文件上传下载功能路由

    }

    global.GVA_LOG.Info("router register success")
    return Router
}

internal

initialize/internal/gorm.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package internal

import (
    "gorm.io/gorm/schema"
    "log"
    "os"
    "time"

    "github.com/flipped-aurora/gin-vue-admin/server/global"
    "gorm.io/gorm"
    "gorm.io/gorm/logger"
)

type DBBASE interface {
    GetLogMode() string
}

var Gorm = new(_gorm)

type _gorm struct{}

// Config gorm 自定义配置
// Author [SliverHorn](https://github.com/SliverHorn)
func (g *_gorm) Config(prefix string, singular bool) *gorm.Config {
    config := &gorm.Config{
        NamingStrategy: schema.NamingStrategy{
            TablePrefix:   prefix,
            SingularTable: singular,
        },
        DisableForeignKeyConstraintWhenMigrating: true,
    }
    _default := logger.New(NewWriter(log.New(os.Stdout, "\r\n", log.LstdFlags)), logger.Config{
        SlowThreshold: 200 * time.Millisecond,
        LogLevel:      logger.Warn,
        Colorful:      true,
    })
    var logMode DBBASE
    switch global.GVA_CONFIG.System.DbType {
    case "mysql":
        logMode = &global.GVA_CONFIG.Mysql
    case "pgsql":
        logMode = &global.GVA_CONFIG.Pgsql
    case "oracle":
        logMode = &global.GVA_CONFIG.Oracle
    default:
        logMode = &global.GVA_CONFIG.Mysql
    }

    switch logMode.GetLogMode() {
    case "silent", "Silent":
        config.Logger = _default.LogMode(logger.Silent)
    case "error", "Error":
        config.Logger = _default.LogMode(logger.Error)
    case "warn", "Warn":
        config.Logger = _default.LogMode(logger.Warn)
    case "info", "Info":
        config.Logger = _default.LogMode(logger.Info)
    default:
        config.Logger = _default.LogMode(logger.Info)
    }
    return config
}

initialize/internal/logger.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package internal

import (
    "fmt"

    "github.com/flipped-aurora/gin-vue-admin/server/global"
    "gorm.io/gorm/logger"
)

type writer struct {
    logger.Writer
}

// NewWriter writer 构造函数
// Author [SliverHorn](https://github.com/SliverHorn)
func NewWriter(w logger.Writer) *writer {
    return &writer{Writer: w}
}

// Printf 格式化打印日志
// Author [SliverHorn](https://github.com/SliverHorn)
func (w *writer) Printf(message string, data ...interface{}) {
    var logZap bool
    switch global.GVA_CONFIG.System.DbType {
    case "mysql":
        logZap = global.GVA_CONFIG.Mysql.LogZap
    case "pgsql":
        logZap = global.GVA_CONFIG.Pgsql.LogZap
    }
    if logZap {
        global.GVA_LOG.Info(fmt.Sprintf(message+"\n", data...))
    } else {
        w.Writer.Printf(message, data...)
    }
}

0%