ClearSky Drizzle
初识Golang-Gin
ClearSky Drizzle Lv4
  2023-08-12 12:24:13   2025-01-20 16:05:57    

go拉取包命令

1
2
go get
go get -u github.com/gin-gonic/gin  #拉取gin包

Gin接口

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
93
94
95
96
package main

import (
	"encoding/json"
	"github.com/gin-gonic/gin"
	"log"
	"net/http"
)

// 自定义Go中间件 拦截器

func myHandler() gin.HandlerFunc {
	return func(context *gin.Context) {
		context.Set("usersession", "userid-1")
		context.Next() //放行
		//context.Abort() //阻止
	}
}
func main() {
	ginServer := gin.Default()
	//ginServer.Use(myHandler()) //注册中间件之后全局使用
	ginServer.GET("/hello", func(context *gin.Context) {
		context.JSON(200, gin.H{"msg": "hello,gin"})
	})

	//加载静态页面
	ginServer.LoadHTMLGlob("../templates/*")

	ginServer.GET("/index", func(context *gin.Context) {
		context.HTML(http.StatusOK, "index.html", gin.H{
			"msg": "This is go give message",
		})
	})

	//接受前端传过来的参数
	ginServer.GET("/user/Info", myHandler(), func(context *gin.Context) {

		//取出中间件的值
		usersession := context.MustGet("usersession").(string)
		log.Println(usersession)

		userid := context.Query("userid")
		username := context.Query("username")
		context.JSON(http.StatusOK, gin.H{
			"userid":   userid,
			"username": username,
		})
	})

	//接受参数
	ginServer.GET("/user/Info/:userid/:username", func(context *gin.Context) {
		userid := context.Param("userid")
		username := context.Param("username")
		context.JSON(http.StatusOK, gin.H{
			"userid":   userid,
			"username": username,
		})
	})

	//json序列化
	ginServer.POST("/json", func(context *gin.Context) {
		data, _ := context.GetRawData()
		var m map[string]interface{}
		_ = json.Unmarshal(data, &m)
		context.JSON(http.StatusOK, m)
	})

	//表单传递
	//支持函数式编程
	ginServer.POST("/user/add", func(context *gin.Context) {
		username := context.PostForm("username")
		password := context.PostForm("password")
		context.JSON(http.StatusOK, gin.H{
			"msg":      "ok",
			"username": username,
			"password": password,
		})
	})

	//重定向
	ginServer.GET("/test", func(context *gin.Context) {
		context.Redirect(http.StatusMovedPermanently, "https://lllcnm.cn")
	})

	//路由组
	//userGroup := ginServer.Group("/user")
	//{
	//	userGroup.GET("/add")
	//	userGroup.GET("/login")
	//	userGroup.GET("/logout", func(context *gin.Context) {
	//		//处理请求
	//	})
	//}
	//服务器端口
	ginServer.Run(":8082")
}

开启多线程

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
package main

import (
	"fmt"
	"time"
)

/*
*
@author LJN
@dev 多线程
*/
func main() {
	//go的多线程-协程
	go goRun()

	for i := 0; i < 1000; i++ {
		fmt.Println("main ========>", i)
	}

	time.Sleep(time.Second * 3)
}

func goRun() {
	for i := 0; i < 1000; i++ {
		fmt.Println("goRun ========>", i)
	}
}

Gin连接数据库

  • 下载mysql驱动包
    1
    go get -u github.com/go-sql-driver/mysql
    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
    package dao

    import (
    	"database/sql"
    	"fmt"
    	_ "github.com/go-sql-driver/mysql"
    )

    const (
    	username = "root"
    	password = "fdsafdfa"
    	host     = "localhost"
    	port     = 3306
    	dbname   = "test"
    )

    type User2 struct {
    	ID       int    `json:"id"`
    	Name     string `json:"name"`
    	Password string `json:"password"`
    }

    func ConnectToDb() (*sql.DB, error) {
    	dataSourceName := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s", username, password, host, port, dbname)
    	db, err := sql.Open("mysql", dataSourceName) // 打开名为 MySQL 的SQL数据库
    	if err != nil {
    		return nil, err
    	}
    	err = db.Ping() // 检查连接是否建立，以确保连接存活
    	if err != nil {
    		return nil, err
    	}
    	return db, nil
    }

Gin数据库增删改查

使用原生sql语句进行增删改查

  1. 在UserController中编写增删改查方法
    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
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    package controller

    import (
    	"database/sql"
    	"github.com/gin-gonic/gin"
    	"log"
    	"main/dao"
    	"net/http"
    )

    type UserController struct {
    	BaseController
    }

    /*
    *
    查询单个用户
    */
    func (this *UserController) GetUser(ctx *gin.Context) {
    	// 获取数据库连接
    	db, err := dao.ConnectToDb()
    	if err != nil {
    		log.Println("Database connection error:", err)
    		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Database error"})
    		return
    	}
    	defer db.Close()

    	var (
    		user   dao.User2
    		result gin.H
    	)
    	id := ctx.Param("id")
    	log.Println("获取到的id", id)

    	// 查询用户
    	row := db.QueryRow("SELECT * FROM user2 WHERE id = ?", id)
    	err = row.Scan(&user.ID, &user.Name, &user.Password)
    	if err != nil {
    		if err == sql.ErrNoRows {
    			result = gin.H{
    				"message": "User not found",
    			}
    			ctx.JSON(http.StatusNotFound, result)
    		} else {
    			log.Println("Error retrieving user:", err)
    			ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Error retrieving user"})
    		}
    	} else {
    		result = gin.H{"data": user}
    		ctx.JSON(http.StatusOK, result)
    	}
    }

    // 查询所有用户
    func (this *UserController) GetAllUser(ctx *gin.Context) {
    	db, err := dao.ConnectToDb()
    	if err != nil {
    		log.Println("Database find error ....", err)
    		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Database error"})
    		return
    	}
    	defer db.Close()
    	var (
    		users  []dao.User2
    		result gin.H
    	)
    	rows, err := db.Query("SELECT * FROM user2")
    	if err != nil {
    		log.Println("Error retrieving users:", err)
    		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Error retrieving users"})
    		return
    	}
    	defer rows.Close()
    	for rows.Next() {
    		var user dao.User2
    		err := rows.Scan(&user.ID, &user.Name, &user.Password)
    		if err != nil {
    			log.Println("Error scanning user data:", err)
    			continue
    		}
    		users = append(users, user)
    	}

    	result = gin.H{"data": users}
    	ctx.JSON(http.StatusOK, result)
    }

    // 添加用户
    func (this *UserController) AddUser(ctx *gin.Context) {
    	db, err := dao.ConnectToDb()
    	if err != nil {
    		log.Println("database connect error", err)
    		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Database error"})
    		return
    	}
    	defer db.Close()

    	var newUser dao.User2
    	if err := ctx.ShouldBindJSON(&newUser); err != nil {
    		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
    		return
    	}
    	// 插入用户到数据库
    	_, err = db.Exec("INSERT INTO user2(name,password) VALUES (?,?)", newUser.Name, newUser.Password)
    	if err != nil {
    		log.Println("Error adding user:", err)
    		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Error adding User"})
    		return
    	}
    	ctx.JSON(http.StatusCreated, gin.H{"message": "User added successfully"})
    }

    // 更新用户
    func (this *UserController) UpdateUser(ctx *gin.Context) {
    	db, err := dao.ConnectToDb()
    	if err != nil {
    		log.Println("databse connection error", err)
    		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Database error"})
    		return
    	}
    	defer db.Close()

    	id := ctx.Param("id")

    	var updateUser dao.User2
    	if err := ctx.ShouldBindJSON(&updateUser); err != nil {
    		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
    		return
    	}

    	_, err = db.Exec("UPDATE user2 SET name = ?,password = ? WHERE id = ?",
    		updateUser.Name, updateUser.Password, id)
    	if err != nil {
    		log.Println("Error adding user:", err)
    		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Error adding User"})
    		return
    	}
    	ctx.JSON(http.StatusCreated, gin.H{"message": "Update User is Succefully"})
    }

    func (this *UserController) DeleteUser(ctx *gin.Context) {
    	db, err := dao.ConnectToDb()
    	if err != nil {
    		log.Println("databse connection error", err)
    		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Database error"})
    		return
    	}
    	defer db.Close()
    	id := ctx.Param("id")

    	_, err = db.Exec("DELETE FROM user2 WHERE id = ?", id)
    	if err != nil {
    		log.Println("Error adding user:", err)
    		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Error adding User"})
    		return
    	}
    	ctx.JSON(http.StatusOK, gin.H{"message": "Delete User is Succefully"})
    }
    2.在router目录下UserRouter文件中注册路由
    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
    package router

    import (
    	"github.com/gin-gonic/gin"
    	"main/controller"
    )

    func UserRouterInit(r *gin.Engine) {
    	user := &controller.UserController{}
    	userGroup := r.Group("/user")
    	{
    		userGroup.GET("/getUser/:id", func(context *gin.Context) {
    			user.GetUser(context)
    		})
    		userGroup.GET("/getAllUser", func(context *gin.Context) {
    			user.GetAllUser(context)
    		})
    		userGroup.POST("/addUser", func(context *gin.Context) {
    			user.AddUser(context)
    		})
    		userGroup.POST("/updateUser/:id", func(context *gin.Context) {
    			user.UpdateUser(context)
    		})
    		userGroup.DELETE("/deleteUser/:id", func(context *gin.Context) {
    			user.DeleteUser(context)
    		})
    	}
    }
    3.在main.go文件中引入注册路由
1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import (
	"github.com/gin-gonic/gin"
	"main/router"
)

func main() {
	r := gin.Default()
	router.StudyRouterInit(r)
	router.UserRouterInit(r)
	r.Run(":8082")
}

上面是原生sql语句执行增删改查的方法,下面我们将介绍gorm增删改查

GORM增删改查

官方文档
教学文档

  • 先来了解一下orm

    ORM（Object Relational Mapping，对象关系映射）框架是一种将数据库表与对象模型之间进行映射的技术。它允许开发者使用面向对象的方式操作数据库，而无需直接编写SQL语句

  • 引入gorm包
    1
    go get -u github.com/jinzhu/gorm

1.在UserGormController添加增删改查方法

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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
package controller

import (
	"github.com/gin-gonic/gin"
	"log"
	"main/dao"
	"net/http"
)

type UserGormController struct {
	BaseController
}

/*
*
查询单个用户
*/
func (ctrl *UserGormController) SearchUser(ctx *gin.Context) {
	db, err := dao.ConnectDataBase()
	if err != nil {
		log.Println("Database connection error:", err)
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Database error"})
		return
	}
	userID := ctx.Param("id")
	var user dao.User2
	if err := db.Where("id = ?", userID).First(&user).Error; err != nil {
		log.Println("User not found:", err)
		ctx.JSON(http.StatusNotFound, gin.H{"error": "User not found"})
		return
	}

	ctx.JSON(http.StatusOK, user)
}

// 查询所有用户
func (ctrl *UserGormController) SearchAllUser(ctx *gin.Context) {
	db, err := dao.ConnectDataBase()
	if err != nil {
		log.Println("Database connection error:", err)
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Database error"})
		return
	}
	var users []dao.User2
	if err := db.Find(&users).Error; err != nil {
		log.Println("User not found:", err)
		ctx.JSON(http.StatusNotFound, gin.H{"error": "User not found"})
		return
	}
	ctx.JSON(http.StatusOK, users)
}

// 更新用户
func (ctrl *UserGormController) UpdateUser(ctx *gin.Context) {
	db, err := dao.ConnectDataBase()
	if err != nil {
		log.Println("Database connection error:", err)
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Database error"})
		return
	}

	// 获取要更新的用户ID
	userID := ctx.Param("id")

	// 解析请求体中的用户名和密码
	var user dao.User2
	if err := ctx.ShouldBindJSON(&user); err != nil {
		log.Println("Invalid request body:", err)
		ctx.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request body"})
		return
	}

	// 更新用户信息
	if err := db.Model(&dao.User2{}).Where("id = ?", userID).Updates(user).Error; err != nil {
		log.Println("Error updating user:", err)
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Error updating user"})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{"message": "User updated successfully"})
}

// 创建字段
func (ctrl *UserGormController) AddUser(ctx *gin.Context) {
	db, err := dao.ConnectDataBase()
	if err != nil {
		log.Println("Database connection error:", err)
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Database error"})
		return
	}
	var user dao.User2
	if err := ctx.ShouldBindJSON(&user); err != nil {
		log.Println("Invalid request body:", err)
		ctx.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request body"})
		return
	}
	if err := db.Create(&user).Error; err != nil {
		log.Println("Add User Error !", err)
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Add User Error"})
		return
	}
	ctx.JSON(http.StatusCreated, gin.H{"message": "Add User is successfully"})
}

// 删除字段
func (ctrl *UserGormController) DeleteUser(ctx *gin.Context) {
	db, err := dao.ConnectDataBase()
	if err != nil {
		log.Println("Database connection error:", err)
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Database error"})
		return
	}
	userID := ctx.Param("id")
	if err := db.Where("id = ?", userID).Delete(&dao.User2{}).Error; err != nil {
		log.Println("Delete User Error !", err)
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Delete User Error"})
		return
	}
	ctx.JSON(http.StatusOK, gin.H{"message": "Delete User is successfully"})
}

2.在UserGormRouter注册方法路由

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
package router

import (
	"github.com/gin-gonic/gin"
	"main/controller"
)

func UserGormInit(r *gin.Engine) {
	user := controller.UserGormController{}
	userGroup := r.Group("/gorm")
	{
		userGroup.GET("/searchUser/:id", func(context *gin.Context) {
			user.SearchUser(context)
		})
		userGroup.GET("/searchAllUser", func(context *gin.Context) {
			user.SearchAllUser(context)
		})
		userGroup.POST("/updateUser/:id", func(context *gin.Context) {
			user.UpdateUser(context)
		})
		userGroup.POST("/addUser", func(context *gin.Context) {
			user.AddUser(context)
		})
		userGroup.DELETE("/deleteUser/:id", func(context *gin.Context) {
			user.DeleteUser(context)
		})
	}
}
  1. 在main.go文件中执行该路由组
    1
    router.UserGormInit(r)

Gin邮件服务

  • 下载依赖包
    1
    go get gopkg.in/gomail.v2
    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
    package service

    import (
    	"fmt"
    	"gopkg.in/gomail.v2"
    	"gopkg.in/ini.v1"
    	"log"
    	"os"
    )

    type MailService struct {
    }

    var (
    	username string
    	password string
    	host     string
    )

    func InitMail() {
    	cfg, err := ini.Load("D:\\Go-Web\\Blog-go\\main\\config\\config.ini")
    	if err != nil {
    		fmt.Println("读取失败:", err)
    		os.Exit(1)
    	}

    	username = cfg.Section("Mail").Key("username").String()
    	password = cfg.Section("Mail").Key("password").String()
    	host = cfg.Section("Mail").Key("host").String()
    	log.Println("==========================>邮件配置构建")
    }

    func SendEmail(to string, sub string, body string) bool {
    	m := gomail.NewMessage()
    	m.SetHeader("From", username)
    	m.SetHeader("To", to)
    	m.SetHeader("Subject", sub)
    	m.SetBody("text/plain", body)
    	d := gomail.NewDialer(host, 465, username, password)

    	if err := d.DialAndSend(m); err != nil {
    		log.Println(err)
    		return false
    	}
    	return true
    }

Gin加载ini配置文件

  • 加载依赖包
    1
    go get gopkg.in/ini.v1
  • config.ini文件
    1
    2
    3
    4
    5
    6
    7
    8
    [Mail]
    username = 1323231313@qq.com
    password = fdsfasfdafdsfdf
    port = 465
    host = smtp.qq.com

    [Mysql]
    url = root:fdfsfaliu@/personblog?charset=utf8&parseTime=True&loc=Local
  • 获取配置文件内容
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    func InitMail() {
    	cfg, err := ini.Load("D:\\Go-Web\\Blog-go\\main\\config\\config.ini")
    	if err != nil {
    		fmt.Println("读取失败:", err)
    		os.Exit(1)
    	}

    	username = cfg.Section("Mail").Key("username").String()
    	password = cfg.Section("Mail").Key("password").String()
    	host = cfg.Section("Mail").Key("host").String()
    	log.Println("==========================>邮件配置构建")
    }

Gin Redis

  • redis基础用法
    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
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    func InitRDB() {
    	cfg, err := ini.Load("D:\\Go-Web\\Blog-go\\main\\config\\config.ini")
    	if err != nil {
    		fmt.Println("读取失败:", err)
    		os.Exit(1)
    	}
    	host = cfg.Section("Redis").Key("host").String()
    	password = cfg.Section("Redis").Key("password").String()
    	strdb := cfg.Section("Redis").Key("db").String()
    	db, _ = strconv.Atoi(strdb)
    	rdb = redis.NewClient(&redis.Options{
    		Addr:     host,
    		Password: password,
    		DB:       db,
    	})
    	log.Println("=========================>Redis配置文件构建")
    }
    func SetCache(key string, value string, expiration time.Duration) {
    	err := rdb.Set(ctx, key, value, expiration).Err()
    	if err != nil {
    		panic(err)
    	} else {
    		log.Println("缓存设置成功")
    	}
    }
    func Get(key string) (string, error) {
    	val, err := rdb.Get(ctx, key).Result()
    	if err != nil {
    		return "", err
    	}
    	return val, nil
    }
    func Delete(key string) bool {
    	err := rdb.Del(ctx, key).Err()
    	log.Println("删除成功")
    	if err != nil {
    		return false
    	}
    	return true
    }
    func SetHashField(hashKey string, field string, value string) {
    	err := rdb.HSet(ctx, hashKey, field, value).Err()
    	if err != nil {
    		log.Println("设置哈希表字段失败:", err)
    	} else {
    		log.Println("设置哈希表字段成功")
    	}
    }

    func GetHashField(hashKey string, field string) (string, error) {
    	val, err := rdb.HGet(ctx, hashKey, field).Result()
    	if err == redis.Nil {
    		log.Println("哈希表字段不存在:", field)
    		return "", nil
    	} else if err != nil {
    		return "", err
    	}
    	return val, nil
    }
    func AddToListLeft(listKey string, values ...string) {
    	err := rdb.LPush(ctx, listKey, values).Err()
    	if err != nil {
    		log.Println("向列表左端添加元素失败:", err)
    	} else {
    		log.Println("向列表左端添加元素成功")
    	}
    }

    func AddToListRight(listKey string, values ...string) {
    	err := rdb.RPush(ctx, listKey, values).Err()
    	if err != nil {
    		log.Println("向列表右端添加元素失败:", err)
    	} else {
    		log.Println("向列表右端添加元素成功")
    	}
    }

    func GetListRange(listKey string, start, stop int64) ([]string, error) {
    	vals, err := rdb.LRange(ctx, listKey, start, stop).Result()
    	if err != nil {
    		return nil, err
    	}
    	return vals, nil
    }
    func AddJSONToListLeft(listKey string, item Item) {
    	itemJSON, err := json.Marshal(item)
    	if err != nil {
    		log.Println("JSON 序列化失败:", err)
    		return
    	}

    	err = rdb.LPush(ctx, listKey, itemJSON).Err()
    	if err != nil {
    		log.Println("向列表左端添加 JSON 元素失败:", err)
    	} else {
    		log.Println("向列表左端添加 JSON 元素成功")
    	}
    }

    func GetJSONListRange(listKey string, start, stop int64) ([]Item, error) {
    	vals, err := rdb.LRange(ctx, listKey, start, stop).Result()
    	if err != nil {
    		return nil, err
    	}

    	var items []Item
    	for _, val := range vals {
    		var item Item
    		err := json.Unmarshal([]byte(val), &item)
    		if err != nil {
    			log.Println("JSON 反序列化失败:", err)
    		} else {
    			items = append(items, item)
    		}
    	}

    	return items, nil
    }
初识Golang-Gin
2023/08/12/web/初识Golang-Gin/
Author
ClearSky Drizzle
Published
2023-08-12 12:24
License
 Comments
Comment plugin failed to load
Loading comment plugin
  1. 1. go拉取包命令
  2. 2. Gin接口
  3. 3. 开启多线程
  4. 4. Gin连接数据库
  5. 5. Gin数据库增删改查
    1. 5.1. 使用原生sql语句进行增删改查
    2. 5.2. 上面是原生sql语句执行增删改查的方法,下面我们将介绍gorm增删改查
  6. 6. GORM增删改查
  7. 7. Gin邮件服务
  8. 8. Gin加载ini配置文件
  9. 9. Gin Redis
© 2022 - 2025    ClearSky Drizzle
Powered by Hexo & Theme Keep
This site is deployed on
Unique Visitor Page View
  1. 1. go拉取包命令
  2. 2. Gin接口
  3. 3. 开启多线程
  4. 4. Gin连接数据库
  5. 5. Gin数据库增删改查
    1. 5.1. 使用原生sql语句进行增删改查
    2. 5.2. 上面是原生sql语句执行增删改查的方法,下面我们将介绍gorm增删改查
  6. 6. GORM增删改查
  7. 7. Gin邮件服务
  8. 8. Gin加载ini配置文件
  9. 9. Gin Redis