EasyGoAdmin_Gin_EleVue-1

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

思考并回答以下问题：

源代码

目录

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
├── app             // 应用目录
│   ├── controller  // 控制器
│   ├── dto         // DTO层
│   ├── middleware  // 中间件层
│   ├── model       // 模型层
│   └── service     // 服务层
│   └── vo          // VO视图层
├── boot
├── config          // 系统配置
├── document        // 文档目录
├── i18n            // 国际化
├── library         // 类库
├── packed
├── public          // 资源目录
├── router          // 路由
├── templates       // 自定义模板
├── utils           // 工具类库
├── Dockerfile
├── go.mod
└── main.go

main.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
/**
 * 系统入口文件
 * @File : main
 */
package main

import (
    _ "easygoadmin/boot"
    "easygoadmin/library/cfg"
    _ "easygoadmin/router"
    _ "easygoadmin/utils"
    "fmt"
    "github.com/gin-gonic/gin"
)

func main() {
    // 开始调试模式
    gin.SetMode("debug")

    // 实例化配置
    config := cfg.Instance()
    if config == nil {
        fmt.Printf("参数错误")
        return
    }
}

library

library/cfg/cfg.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
/**
 * 配置工具
 * @File : cfg
 */
package cfg

import (
    "github.com/BurntSushi/toml"
    "os"
    "sync"
)

var (
    instance *config
    once     sync.Once
)

// 获取配置文档实例
func Instance() *config {
    once.Do(func() {
        var conf config
        path, _ := os.Getwd()
        filePath := path + "/config/config.toml"
        if _, err := toml.DecodeFile(filePath, &conf); err != nil {
            return
        }
        instance = &conf
    })

    return instance
}

type config struct {
    Database    database
    Logger      logger
    EasyGoAdmin easygoadmin
}

type database struct {
    Master string
    Slave  string
    Debug  bool
    Log    string
}

type logger struct {
    Path   string
    Level  uint32
    Stdout bool
}

// 自定义配置
type easygoadmin struct {
    Version string
    Debug   bool
    Image   string
    Uploads string
}

library/db.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
80
81
82
83
84
85
86
87
88
89
90
91
92
package library

import (
    "easygoadmin/library/cfg"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
    "github.com/go-xorm/xorm"
    "strings"
    "sync"
    "xorm.io/core"
)

type dbEngine struct {
    master *xorm.Engine //主数据库
    slave  *xorm.Engine //从数据库
}

var (
    instance *dbEngine
    once     sync.Once
)

//初始化数据操作 driver为数据库类型
func Instance(driver ...string) *dbEngine {
    once.Do(func() {

        driverName := "mysql"

        if len(driver) > 0 {
            driverName = driver[0]
        }

        var db dbEngine
        config := cfg.Instance()
        //没有配置从数据库
        if len(config.Database.Slave) == 0 {
            engine, err := xorm.NewEngine(driverName, config.Database.Master)
            if err != nil {
                fmt.Printf("数据库连接错误:%v", err.Error())
                return
            }
            err = engine.Ping()
            if err != nil {
                fmt.Printf("数据库连接错误:%v", err.Error())
                return
            }
            if cfg.Instance().Database.Debug {
                engine.ShowSQL(cfg.Instance().Database.Debug)
                engine.Logger().SetLevel(core.LOG_DEBUG)
            }
            db.master = engine
            instance = &db
        } else {
            master, err := xorm.NewEngine(driverName, config.Database.Master)
            if err != nil {
                return
            }
            if cfg.Instance().Database.Debug {
                master.ShowSQL(cfg.Instance().Database.Debug)
                master.Logger().SetLevel(core.LOG_DEBUG)
            }

            slave, err := xorm.NewEngine(driverName, config.Database.Slave)
            if err != nil {
                return
            }
            slaves := []*xorm.Engine{slave}
            group, err := xorm.NewEngineGroup(master, slaves)
            if cfg.Instance().Database.Debug {
                group.ShowSQL(cfg.Instance().Database.Debug)
                group.Logger().SetLevel(core.LOG_DEBUG)
            }
            db.master = group.Master()
            db.slave = group.Slave()
            instance = &db
        }
    })
    return instance
}

//获取操作实例 如果传入slave 并且成功配置了slave 返回slave orm引擎 否则返回master orm引擎
func (db *dbEngine) Engine(dbType ...string) *xorm.Engine {
    if dbType != nil && len(dbType) > 0 {
        if strings.EqualFold(dbType[0], "slave") {
            if db.slave != nil {
                return db.slave
            }
        }
    }
    return db.master
}

0%