Study Golang「3」 - Zsm's blog

study golang / demo5#

后端：mongodb+gorm+MVC+gin+air 前端：vue+vite+ts 仓库：https://github.com/LTX-GOD/study-golang-demo

项目架构#

1
demo5/
2
├── main.go
3
├── .air.toml
4
├── ecommerce-sys
5
├── go.mod
6
├── go.sum
7
├── controllers/
8
│   ├── address.go
9
│   ├── cart.go
10
│   └── controllers.go
11
├── database/
12
│   ├── cart.go
13
│   └── databasesetup.go
14
├── middleware/
15
│   └── middleware.go
16
├── models/
17
│   └── models.go
18
├── routes/
19
│   └── routes.go
20
├── tokens/
21
│   └── tokengen.go
22
├── tmp/
23
│   ├── build-errors.log
24
│   └── main
25
└── static/
26
    ├── form.html
27
    └── index.html

关于Air包#

1
go install github.com/air-verse/air@latest //拉包
2
air init //初始化
3
air //启动热重载

关于mongodb#

这里本地包docker上去的

1
docker exec -it mongodb sh
2
use gotest

关于后端项目#

router & main#

路由文件中我只存了关于用户的，其他的存在了main.go里面，原因是这个练手项目的作者第一开始没写完，我后面自己补完的，包括前端的内容。

然后在main里面，我没有把端口写死，选择环境变量注入的方法

1
  // 获取环境变量PORT的值, 如果不存在则赋值8000
2
  port := os.Getenv("PORT")
3
  if port == "" {
4
    port = "8000"
5
  }

这样的好处是包docker的时候灵活一点

因为项目是前后端分离，加上前端后还需要解决跨域问题

1
  // 配置CORS
2
  config := cors.DefaultConfig()
3
  config.AllowOrigins = []string{"http://localhost:5173", "http://localhost:3000", "http://localhost:8080"}
4
  config.AllowMethods = []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"}
5
  config.AllowHeaders = []string{"Origin", "Content-Type", "Accept", "Authorization", "X-Requested-With", "token"}
6
  config.AllowCredentials = true
7
  router.Use(cors.New(config))

models#

这里定义的有点多

1
type User struct {
2
  ID            primitive.ObjectID `json:"_id" bson:"_id"`
3
  Name          *string            `json:"name" validate:"required,min=6,max=30"`
4
  Password      *string            `json:"password" validate:"required,min=6,max=30"`
5
  Email         *string            `json:"email" validate:"email,required"`
6
  Phone         *string            `json:"phone" validate:"required"`
7
  Token         *string            `json:"token" `
8
  Refresh_Token *string            `json:"refresh_token"`
9
  Created_At    time.Time          `json:"created_at"`
10
  Updated_At    time.Time          `json:"updated_at"`
11
  User_ID       string             `json:"user_id"`
12
  // 切片本身已经是一个引用类型，能够提供对底层数据的引用，因此不加*号
13
  UserCart        []ProductUser `json:"usercart" bson:"usercart"`
14
  Address_Details []Address     `json:"address" bson:"address"`
15
  Order_Status    []Order       `json:"order" bson:"order"`
16
}
17

18
type Product struct {
19
  Product_ID   primitive.ObjectID `json:"_id" bson:"_id"`
20
  Product_Name *string            `json:"product_name"`
21
  Price        *string            `json:"price"`
22
  Rating       *string            `json:"rating"`
23
  Image        *string            `json:"image"`
24
}
25

26
type ProductUser struct {
27
  Product_ID   primitive.ObjectID `json:"_id" bson:"_id"`
28
  Product_Name *string            `json:"product_name"`
29
  Price        *string            `json:"price"`
30
  Rating       *string            `json:"rating"`
31
  Image        *string            `json:"image"`
32
}
33

34
type Address struct {
35
  Address_id primitive.ObjectID `bson:"_id"`
36
  House      *string            `json:"house_name" bson:"house_name"`
37
  Street     *string            `json:"street_name" bson:"street_name"`
38
  City       *string            `json:"city_name" bson:"city_name"`
39
  PostalCode *string            `json:"postalcode" bson:"postalcode"`
40
}
41

42
type Order struct {
43
  Order_ID       primitive.ObjectID `bson:"_id"`
44
  Order_Cart     []ProductUser      `json:"order_list" bson:"order_list"`
45
  Ordered_At     time.Time          `json:"ordered_at" bson:"ordered_at"`
46
  Price          int                `json:"price" bson:"price"`
47
  Discount       *int               `json:"discount" bson:"discount"`
48
  Payment_Method Payment            `json:"payment_method" bson:"payment_method"`
49
}
50

51
type Payment struct {
52
  Digital bool
53
  COD     bool
54
}

结构体中字段为什么是首字母大写 在go中，首字母大写的含义是这些字段是导出的，可以在包外部访问，就有点像其他语言中的public

加入首字母小写，就类似private，在外部无权限访问

结构体中json和bson的不同

json 标签：用于指定当结构体字段被序列化为 JSON 时，使用的字段名。例如：

1
type User struct {
2
    Name  string  `json:"name"`
3
}

即使定义的是Name，在json输出中也会被序列化成name

bson 标签：用于指定当结构体字段被序列化为 BSON（MongoDB 的文档格式）时，使用的字段名。例如：

1
type User struct {
2
    ID  primitive.ObjectID  `bson:"_id"`
3
}

这个例子中，ID 字段会被映射到 MongoDB 文档的 _id 字段，这是 MongoDB 中常用的主键字段名。

database#

这里分成两个文件进行编写，分别是databasesetup.go和cart.go

databasesetup.go 主要用来处理数据库连接还有获取用户和产品的集合，稍微多加的一点就是写了个连接数据库时的超时限制，其他的都是很简单的内容

1
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
2
defer cancel()

cart.go 这里先定义了一些报错，然后写业务逻辑主要任务有：
1. 将指定产品添加到用户的购物车
2. 从用户购物车中移除指定产品
3. 处理用户购物车的购买过程
4. 立即购买代码太长就不放了bro

controllers#

这里写的也比较乱

controllers.go：处理密码哈希、注册、密码校验、登录、添加商品、购物车逻辑(增、删、查、购买、下单)
cart.go：提供接口处理功能，比如加购物车、移除商品、查看购物车、下单等，也就是main.go哪里的api接口
addre.go：提供用户地址接口，实现增加、编辑、删除的功能

代码很多，就不放了，部分还不是特别完善，像后面两个都是自己实现的，比较潦草

middleware#

这里主要用来实现中间件鉴权

1
func Authentication() gin.HandlerFunc {
2
  return func(c *gin.Context) {
3
    ClientToken := c.Request.Header.Get("token")
4
    if ClientToken == "" {
5
      c.JSON(http.StatusInternalServerError, gin.H{"error": "No authorization header founded"})
6
      c.Abort()
7
      return
8
    }
9
    claims, err := token.ValidateToken(ClientToken)
10
    if err != "" {
11
      c.JSON(http.StatusInternalServerError, gin.H{"error": err})
12
      c.Abort()
13
      return
14
    }
15

16
    c.Set("email", claims.Email)
17
    c.Set("uid", claims.Uid)
18
    c.Next()
19
  }
20
}

tokens#

生成jwttoken

1
type SignedDetails struct {
2
  Email string
3
  Name  string
4
  Uid   string
5
  jwt.StandardClaims
6
}
7

8
// UserData 是存储用户数据的 MongoDB 集合引用
9
var UserData *mongo.Collection = database.UserData(database.Client, "Users")
10

11
// 从环境变量中读取JWT的签名和认证
12
var SECRET_KEY = os.Getenv("SECRET_KEY")
13

14
// TokenGenerator 生成一个签名的访问令牌和一个签名的刷新令牌。
15
func TokenGenerator(email string, name string, uid string) (signedtoken string, signedrefeshtoken string, err error) {
16
  claims := &SignedDetails{
17
    Email: email,
18
    Name:  name,
19
    Uid:   uid,
20
    StandardClaims: jwt.StandardClaims{
21
      ExpiresAt: time.Now().Local().Add(time.Hour * time.Duration(24)).Unix(), // 令牌有效期为24小时
22
    },
23
  }
24

25
  //创建一个仅包含过期时间的声明，用来刷新令牌
26
  refreshclaims := &SignedDetails{
27
    StandardClaims: jwt.StandardClaims{
28
      ExpiresAt: time.Now().Local().Add(time.Hour * time.Duration(24*7)).Unix(), //刷新有效七天
29
    },
30
  }
31

32
  //HS256访问令牌
33
  token, err := jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString([]byte(SECRET_KEY))
34
  if err != nil {
35
    return "", "", err
36
  }
37

38
  //刷新
39
  refreshtoken, err := jwt.NewWithClaims(jwt.SigningMethodHS384, refreshclaims).SignedString([]byte(SECRET_KEY))
40
  if err != nil {
41
    log.Panic(err)
42
    return
43
  }
44

45
  return token, refreshtoken, err
46
}

实现校验功能

1
func ValidateToken(signedtoken string) (claims *SignedDetails, msg string) {
2
  // 解析并验证签名令牌，使用提供的密钥和声明类型
3
  token, err := jwt.ParseWithClaims(signedtoken, &SignedDetails{}, func(token *jwt.Token) (interface{}, error) {
4
    return []byte(SECRET_KEY), nil // 使用SECRET_KEY作为签名密钥
5
  })
6
  if err != nil {
7
    msg = err.Error() // 如果解析过程中出现错误，设置错误信息并返回
8
    return
9
  }
10

11
  // 断言token.Claims为*SignedDetails类型，并进行类型检查
12
  claims, ok := token.Claims.(*SignedDetails)
13
  if !ok {
14
    msg = "Invalid token" // 如果断言失败，说明令牌无效，设置错误信息并返回
15
    return
16
  }
17

18
  // 检查令牌的过期时间
19
  if claims.ExpiresAt < time.Now().Local().Unix() {
20
    msg = "Token expired" // 如果令牌已过期，设置错误信息并返回
21
    return
22
  }
23

24
  // 如果所有检查都通过，返回令牌中的声明和一个空消息
25
  return claims, ""
26
}

实现刷新功能

1
func UpdateAllTokens(signedtoken string, signedrefreshtoken string, userid string) {
2

3
  // 创建一个带有超时的上下文，超时时间为100秒
4
  var ctx, cancel = context.WithTimeout(context.Background(), 100*time.Second)
5
  defer cancel() // 确保函数返回时取消上下文
6

7
  var updateobj primitive.D
8

9
  // 构建更新对象，包括访问令牌、刷新令牌和更新时间
10
  updateobj = append(updateobj, bson.E{Key: "token", Value: signedtoken})
11
  updateobj = append(updateobj, bson.E{Key: "refresh_token", Value: signedrefreshtoken})
12
  updated_at, _ := time.Parse(time.RFC3339, time.Now().Format(time.RFC3339)) // 格式化当前时间为RFC3339格式
13

14
  updateobj = append(updateobj, bson.E{Key: "updated_at", Value: updated_at})
15

16
  // 设置Upsert选项，表示如果用户不存在则插入新记录
17
  upsert := true
18
  filter := bson.M{"user_id": userid} // 设置过滤条件，匹配指定的用户ID
19
  opt := options.UpdateOptions{
20
    Upsert: &upsert,
21
  }
22

23
  // 执行更新操作，将更新对象应用到符合过滤条件的文档中
24
  _, err := UserData.UpdateOne(ctx, filter, bson.D{
25
    {Key: "$set", Value: updateobj},
26
  }, &opt)
27

28
  // 处理更新操作中的错误
29
  if err != nil {
30
    log.Panic(err) // 记录错误并引发恐慌
31
    return
32
  }
33
}

study golang / demo6#

后端：mysql+redis+gorm+MVC+gin+air+viper 前端：vue+vite+ts 仓库：https://github.com/LTX-GOD/study-golang-demo

项目架构#

1
demo6/
2
├── main.go
3
├── .air.toml
4
├── go.mod
5
├── go.sum
6
├── readme.md
7
├── config/
8
│   ├── config.go
9
│   ├── config.yml
10
│   ├── db.go
11
│   └── redis.go
12
├── controllers/
13
│   ├── article_controller.go
14
│   ├── auth_controller.go
15
│   ├── exchange_rate_controller.go
16
│   └── like_controller.go
17
├── global/
18
│   └── global.go
19
├── middlewares/
20
│   └── auth_middleware.go
21
├── models/
22
│   ├── article.go
23
│   ├── exchange_rate.go
24
│   └── user.go
25
├── routes/
26
│   └── routes.go
27
├── utils/
28
│   └── utils.go
29
└── tmp/

redis && mysql#

这边都用docker去启动，然后先不建库，后面都现场用

关于后端项目#

编写习惯#

这里用viper编写资源管理项
写路由，并且定义每个地方的函数
写数据库models层
写数据库配置文件，mysql和redis
写config.go
写utils和middlewares

关于viper#

1
app:
2
  name: CurrencyExchangeApp
3
  port: ":8000"
4

5
database:
6
  dsn: root:password@tcp(127.0.0.1:3306)/gotest?charset=utf8mb4&parseTime=True&loc=Local
7
  MaxIdleConns: 11
8
  MaxOpenCons: 114
9

10
redis:
11
  addr: localhost:6379
12
  DB: 0
13
  Password: ""

这里去定义端口、数据库连接还有数量

在config.go里面，把这个viper的规则引入

1
viper.SetConfigName("config")
2
viper.SetConfigType("yml")
3
viper.AddConfigPath("./config")

global.go的作用#

这个的作用是让这个全局文件都可以访问数据库和redis，在其他的项目中也经常使用这种方法

1
package global
2

3
import (
4
  "github.com/go-redis/redis"
5
  "gorm.io/gorm"
6
)
7

8
var (
9
  Db      *gorm.DB
10
  RedisDB *redis.Client
11
)

关于routes.go#

这里稍微的严谨了一点，登录和注册是不用token判断的，但是其他的接口都需要，这样就更加规范了

1
  auth := r.Group("/api/auth")
2
  {
3
    auth.POST("/login", controllers.Login)
4

5
    auth.POST("/register", controllers.Register)
6
  }
7

8
  api := r.Group("/api")
9
  api.GET("/exchangeRates", controllers.GetExchangeRates)
10
  api.Use(middlewares.AuthMiddleWare())
11
  {
12
    api.POST("/exchangeRates", controllers.CreateExchangeRate)
13
    api.POST("/articles", controllers.CreateArticle)
14
    api.GET("/articles", controllers.GetArticles)
15
    api.GET("/articles/:id", controllers.GetArticleByID)
16

17
    api.POST("/articles/:id/like", controllers.LikeArticle)
18
    api.GET("/articles/:id/like", controllers.GetArticleLikes)
19
  }
20
  return r

a ctfer on the load

study golang / demo5#

项目架构#

关于Air包#

关于mongodb#

关于后端项目#

router & main#

models#

database#

controllers#

middleware#

tokens#

study golang / demo6#

项目架构#

redis && mysql#

关于后端项目#

编写习惯#

关于viper#

global.go的作用#

关于routes.go#