MisakaDB-kv型小型数据库 | 记录5

对 map 的使用方法和底层机制进行记录，以下内容基于 go1.22.1 版本。



Go 中的 map 就是哈希表，比较类似的就是 python 的dict。

### 1 使用方法

增删改查示例代码：

``` go
testMap := make(map[string]string, 10) // 初始化
testMap["test1"] = "test1" // 增
testMap["test1"] = "test2" // 改
delete(testMap, "test1") // 删 删除的键不存在也不会报错
if value, ok := testMap["test1"]; ok { // 查
        fmt.Println(value)
}
```

有几个注意点:

1. 向一个没有 make 初始化过的，实质为 nil 的 map 写入数据会引发 panic，但是查找和删除并不会引发 panic，访问其长度会返回0。
2. 即使 map 中没有对应的键，delete 也不会报错，查询也会返回对应类型的零值。
3. make 一个新的 map 时，可以顺带指定其容量，当然不指定也行，但是在有数据预期的情况下，指定容量会减少 map 扩容的次数，加快速度。
4. 查数据的时候，建议带上 ok，方便很多。
5. map 并不支持并发读写，如果底层检测到了读写冲突，会直接引发 panic。

### 2 底层实现

![image.png](https://www.misaka19327.cc/static/img/3e4db04d7ee82d84ea99391672a95370.image.png)

~~偷一张现成的图~~

map 相关的底层数据结构如下：

``` go
// src/runtime/map.go
// A header for a Go map.
type hmap struct {
	// Note: the format of the hmap is also encoded in cmd/compile/internal/reflectdata/reflect.go.
	// Make sure this stays in sync with the compiler's definition.
	count     int // # live cells == size of map.  Must be first (used by len() builtin)
        // map 保存的键值对数量
	flags     uint8
	B         uint8  // log_2 of # of buckets (can hold up to loadFactor * 2^B items)
        // bucket 数组长度为2的 B 次方
	noverflow uint16 // approximate number of overflow buckets; see incrnoverflow for details
	hash0     uint32 // hash seed

	buckets    unsafe.Pointer // array of 2^B Buckets. may be nil if count==0.
        // 当前使用的 bucket 数组
	oldbuckets unsafe.Pointer // previous bucket array of half the size, non-nil only when growing
        // 扩容后的旧的等待数组迁移的 bucket 数组
	nevacuate  uintptr        // progress counter for evacuation (buckets less than this have been evacuated)

	extra *mapextra // optional fields
}

// mapextra holds fields that are not present on all maps.
type mapextra struct {
	// If both key and elem do not contain pointers and are inline, then we mark bucket
	// type as containing no pointers. This avoids scanning such maps.
	// However, bmap.overflow is a pointer. In order to keep overflow buckets
	// alive, we store pointers to all overflow buckets in hmap.extra.overflow and hmap.extra.oldoverflow.
	// overflow and oldoverflow are only used if key and elem do not contain pointers.
	// overflow contains overflow buckets for hmap.buckets.
	// oldoverflow contains overflow buckets for hmap.oldbuckets.
	// The indirection allows to store a pointer to the slice in hiter.
        // 如果键值都不是指针 那么这个 map 会被标记为没有指针 以避免 gc 扫描整个 map
        // 但是 bmap.overflow 是一个指针
        // 为了保证其存活 将所有的 overflow 指向的 bucket 全部存储到 hmap.extra.overflow 和 hmap.extra.oldoverflow
        // 这间接地允许在 hiter 里存储指向切片的指针
        // 注 hiter 是针对 map 的迭代器 不是这里的讨论重点
	overflow    *[]*bmap
	oldoverflow *[]*bmap

	// nextOverflow holds a pointer to a free overflow bucket.
	nextOverflow *bmap
}
```

``` go
// src/cmd/compile/reflectdata/reflect.go
// Builds a type representing a Bucket structure for
// the given map type. This type is not visible to users -
// we include only enough information to generate a correct GC
// program for it.
// Make sure this stays in sync with runtime/map.go.
//
// 该类型对用户不可见 只确保在 gc 里面正确即可
//
//	A "bucket" is a "struct" {
//	      tophash [BUCKETSIZE]uint8 // bucket 存储的键的 hash 值的高8位
//	      keys [BUCKETSIZE]keyType // 键
//	      elems [BUCKETSIZE]elemType // 值
//	      overflow *bucket // 指向下一个 bucket 的指针
//	    }

// src/runtime/map.go
// A bucket for a Go map.
// 这个就是 bucket 的对用户可见的版本
type bmap struct {
	// tophash generally contains the top byte of the hash value
	// for each key in this bucket. If tophash[0] < minTopHash,
	// tophash[0] is a bucket evacuation state instead.
	tophash [bucketCnt]uint8
	// Followed by bucketCnt keys and then bucketCnt elems.
	// NOTE: packing all the keys together and then all the elems together makes the
	// code a bit more complicated than alternating key/elem/key/elem/... but it allows
	// us to eliminate padding which would be needed for, e.g., map[int64]int8.
	// Followed by an overflow pointer.
        // 这段注释解释了为什么 bucket 里面键和值是分开存储的
        // 注释说 虽然这样会加重代码复杂性 但是利于消除间隔
        // 我认为 这个 “消除间隔”（eliminate padding）指的是内存对齐
}
```

> 后两个成员变量实质上并不存在，在访问时是通过指针偏移来访问。

1. 总结一下，map 的底层结构是这样的：hmap 用数组存储一系列 bucket，**每个 bucket 代表着一种 hash 匹配结果，并且存储着 hash 低位值相同的键值对（实质上就是发生了哈希冲突的键值对）**。当一个 bucket 存储的冲突的键值对太多，一个bucket存储不过来，那么会创建一个新的 bucket，老的 bucket 的 overflow 指向新的 bucket，形成一个 **bucket 链表结构**。
2. 引入一个新的概念：**负载因子**，它通过计算 map 存储的键值对数量和底层的 bucket 数量得到。如果负载因子过大，说明哈希冲突严重；如果负载因子过小，说明键值对过于分散，没有有效利用内存。而后者这个情况一般会出现在 map 被大量删除键值对后出现。

> 负载因子这个概念，在采用了相同方法实现的哈希表中是通用的，比如 redis。

4. 当负载因子超过6.5时，说明平均一个 bucket 里面存储了超过6.5个键值对，会触发 rehash，包括对 bucket 数组进行扩容，申请更多的 bucket 并且重新组织所有的键值对。
5. 除了负载因子过高这种情况外，如果通过 overflow 组织的 bucket 数量达到$$2^{min(15, B)}$$时，也会触发 bucket 数组的扩容。因为这种情况说明哈希冲突非常严重，bucket 链表长度过长，可能影响读写效率。
6. 扩容分为两种：增量扩容和等量扩容。

    - 增量扩容是这样的：oldbuckets 指针指向即将要替换的那个老 bucket 数组，创建一个长度等于老 bucket 数组的两倍的新 bucket 数组。如果 map 存储的数据量极其大，那么这次扩容并不会将所有 bucket 全部写入新的数组，而是在每次读写的时候向新的数组写入两个 bucket，直到旧的数组的 bucket 的数据全部搬到新的数组里面之后 释放旧数组的内存空间。
    - 等量扩容是为了应对负载因子过低这种情况的，它会重新组织 bucket，回收没有用到的 bucket，加快查询速度。

> 注意，如果旧数组内还有 bucket，查询的时候都会优先进旧的 bucket 进行查询。

9. 对于增删改查来说，本质都是根据键值找到正确的 bucket 和对应的 value。第一步是计算键值的哈希值，得到的哈希值的低位与 `hmap.B` 取模得到 bucket 在 buckets 数组内的位置，哈希值的高位用于在 bucket 内的 tophash 数组查找对应的下标（一个 bucket 找不到的话会继续沿着 bucket 链表继续找下去）。

![image.png](https://www.misaka19327.cc/static/img/fa40d57cd6051ef455f931353995481f.image.png)

10. 注意，如果 map 处于 bucket 搬迁的过程中，添加/更新键值对也会和查询一样，从旧的 bucket 数组开始查，但是最终如果是添加而不是更新键值对的话，添加一定是添加到新的 bucket 数组中。
11. 以上的内容都没有提到的是 hmap 的 extra 字段。它是一个可选字段，当 map 的键值对全部不是指针类型时启用，以避免触发 gc 时扫描整个 map 降低 gc 的速度。这些在注释中都说了，但是有一点没有说全：如何解决`bmap.overflow`是个指针？

``` go
// src/cmd/compile/reflectdata/reflect.go
// MapBucketType 为 map 创建一个给定类型的 bucket
// MapBucketType makes the map bucket type given the type of the map.
func MapBucketType(t *types.Type) *types.Type {
	if t.MapType().Bucket != nil { // 复用
		return t.MapType().Bucket
	}
	
	...
	
	// If keys and elems have no pointers, the map implementation
	// can keep a list of overflow pointers on the side so that
	// buckets can be marked as having no pointers.
	// Arrange for the bucket to have no pointers by changing
	// the type of the overflow field to uintptr in this case.
	// See comment on hmap.overflow in runtime/map.go.
	otyp := types.Types[types.TUNSAFEPTR]
	if !elemtype.HasPointers() && !keytype.HasPointers() {
		otyp = types.Types[types.TUINTPTR]
	}
	overflow := makefield("overflow", otyp)
	field = append(field, overflow)
	
	...
	return bucket
}
```

看注释，在 map 的键值都不是指针的情况下，`hmap.overflow`就是 uintptr 类型（一个数值类型而不是指针类型）而不是指针类型。

> 关于 gc（垃圾回收）机制，以后会写。

### * 参考链接

[CSDN | golang map 底层实现源码解析](https://blog.csdn.net/Jeff_fei/article/details/134052696)

Go底层/特性解析 | Map

MisakaOJ项目，第七次记录内容



### 1 将分类信息更新进Redis里

``` go
func RefreshCategoryIdAndName() {
	categories := make([]*models.Category, 0)
	e := models.GetCategoryByColumn("", nil).Find(&categories).Error
	if e != nil {
		zap.L().Error("Cron",
			zap.Error(e),
		)
		return
	}
	
	for i := range categories {
		e = models.RDB.HSet(context.Background(), "CategoryIdAndName", categories[i].Name, strconv.Itoa(int(categories[i].ID))).Err()
		if e != nil {
			zap.L().Error("Redis-Write",
				zap.String("method", "HSet"),
				zap.String("key", "CategoryIdAndName"),
				zap.String("field", categories[i].Name),
				zap.Any("value", strconv.Itoa(int(categories[i].ID))),
				zap.Error(e),
			)
			return
		}
	}
}
```

在对应的 Handler 里面更新写法：

``` go
// AddQuestion
//	@Tags		管理员接口
//	@Summary	提交新的题目
//	@Param		authorization	header		string		true	"authorization"
//	@Param		title			formData	string		true	"title"
//	@Param		content			formData	string		true	"content"
//	@Param		max_runtime		formData	int			true	"max_runtime"
//	@Param		max_mem			formData	int			true	"max_mem"
//	@Param		categories		formData	[]string	true	"categories"	collectionFormat(multi)
//	@Param		test_cases		formData	[]string	true	"test_cases"	collectionFormat(multi)
//	@Success	200				{data}		json		"{"code": "200", "message": ""}"
//	@Router		/admin/add_question [post]
func AddQuestion(c *gin.Context) {
	...
	
	// 先查分类 把分类id拿到 并且写成QuestionCategory类型的
	questionCategoryArray := make([]*models.QuestionCategory, 0)
	var questionCategory *models.QuestionCategory
	var categoryIdString string
	var categoryId int
	for i := range categoryArrayFromUser {
		// 初始化
		questionCategory = &models.QuestionCategory{}
		
		// 查询
		categoryIdString, e = models.RDB.HGet(context.Background(), "CategoryIdAndName", categoryArrayFromUser[i]).Result()
		if e != nil {
			ErrorHandler(c, errors.Join(constants.RedisHGetErr, e).Error())
			return
		}
		categoryId, e = strconv.Atoi(categoryIdString)
		if e != nil {
			ErrorHandler(c, e.Error())
			return
		}
		
		// 放结果
		questionCategory.CategoryId = uint(categoryId)
		questionCategoryArray = append(questionCategoryArray, questionCategory)
	}
	...
}
```

MisakaOJ | 第七次记录

对 slice 的使用方法和底层机制进行记录，以下内容基于 go1.22.1 版本。



slice 是 go 语言中类似 list 的存在，正式名字叫切片。**注意切片和数组不是一个东西**！

### 1 使用方法

1. 调用 make 函数进行初始化：`a := make([]int, 10, 20)`，这会创建一个长度为10，容量为20的切片，切片里的每个值会被初始化为对应类型的默认值。如果一个切片变量只声明不 make：`var a []int`，那么变量值 a 为 nil。
2. append 函数用于向切片中添加元素，len 函数用于访问切片长度，cap 函数用于访问切片容量。后两个函数全部是 $$O1$$ 的时间复杂度。
3. 切片支持通过类似`a := b[start:end]`的，名叫简单表达式的方式得到一个新的切片，两个切片共享内存空间，对 a 的修改也会影响 b（包括没有切到的，但实际还在 b 容量内的部分也会被影响），反之亦然。**注意 start 和 end 的取值范围是0到 b 的容量而不是长度**。切取的内容是包括`b[start]`，但不包括`b[end]`的。

> 另外一提，字符串也支持这样的切取，但是字符串不会共享内存空间。

4. 切片还支持通过类似`a := b[start:end:max]`的名叫扩展表达式的方式得到一个新的切片，该新切片和通过`a := b[start:end]`得到的切片最大的不同是，前者的 cap 被锁死为`max - end`。如果到达容量上限后再 append，会重新分配内存，而不影响原切片的内容。
5. 简单表达式中 start 和 end 都是可以被省略的，其默认值为0和 b 的长度。但是扩展表达式中只有 start 可被省略。
6. 切片还支持 copy，会将老切片的所有内容一个一个拷贝进新切片，拷贝取两个切片长度的最小值。

### 2 底层实现

切片的底层实现是这样的：

``` go
type slice struct {
	array unsafe.Pointer
	len   int
	cap   int
}
```

可以明显看出，切片实质上就是对数组指针的封装，所以**函数可以放心传切片而不是切片指针**。

1. 在创建一个切片时，会创建一个长度为 cap 的数组，slice 的指针指向该数组，len划定了其中的有效值（这只是一个概念，意思是该值是可以被用户直接操作的）范围。
2. 在通过表达式获取一个新的切片时，这个新的切片实质上就是其指针指向旧切片的 start 位置，同时指定 len 和 cap 的值。
3. 注意，如果频繁使用表达式获取新的切片的话，很有可能出现几个切片共同指向内存中的同一个数组，每个切片各自维护各自的 len 和 cap，通过这俩来确定各自的切片有哪些元素。
4. append 实质上要执行的有这么几条：
    - 尝试向数组写入内容。
    - 如果数组已满，即写入的内容数量已经到达 cap，那么 append 会采用`runtime.nextslicemap`函数为策略进行扩容（实际扩容函数为`runtime.growslice`）（扩容的时候也会进行内存对齐）。
    - 向扩容后的数组写入内容。

> 内存对齐是为了 CPU 访问内存次数更少设置的。因为内存是按字长进行存储和读取的，所以既然每次读写内存都是固定长度的数据，假设字长为8位，一个相同的，长度为10位的变量被切到3个字长里面（1位，8位，1位）和被切到2个字长（8位，2位）里面，当然是后者更有优势。这就是内存对齐的工作。
> 
> 从这个机制出发，结构体成员变量的排列也能够影响其实际占据内存的大小，当然影响其实微乎其微，这一点会在结构体底层/特性解析中会说。

`runtime.nextslicemap`函数如下：

``` go
// nextslicecap 根据需求的新的长度和 slice 旧的容量 计算出扩容的目标容量
// 这个需求的新的长度 即为当前切片的容量加上追加元素的数量
// nextslicecap computes the next appropriate slice length.
func nextslicecap(newLen, oldCap int) int {
	newcap := oldCap
	doublecap := newcap + newcap
	if newLen > doublecap { // 如果需求的新的长度超过两倍的现有的容量 直接返回新的长度作为容量
		return newLen
	}

	const threshold = 256
	if oldCap < threshold {
		return doublecap // 如果现有的容量小于256 那么直接返回两倍现有的容量作为新容量
	}
	for {
		// Transition from growing 2x for small slices
		// to growing 1.25x for large slices. This formula
		// gives a smooth-ish transition between the two.
                // 对于小切片 容量增长速度应当是两倍
                // 对于大切片 容量增长速度应当是1.25倍
                // 下面的公式 中和了上面两个原则 并且使容量增长曲线更平滑
                // 下面的公式在代码下面会用 LaTex 写出
		newcap += (newcap + 3*threshold) >> 2

		// We need to check `newcap >= newLen` and whether `newcap` overflowed.
		// newLen is guaranteed to be larger than zero, hence
		// when newcap overflows then `uint(newcap) > uint(newLen)`.
		// This allows to check for both with the same comparison.
                // 检查 newcap 是否大于 newLen 的同时 检查 newcap 是否发生了溢出
                // 因为 newcap 是大于0的 所以当 uint(newcap) > uint(newLen) 时 可以认为 newcap 发生了溢出
                // 注意 一个 int 存储的数字如果到达上限 再往上加就会发生溢出 值变为负数
                // 溢出是越加 读到的值的绝对值越来越小
                // 所以溢出时 用 uint 读到的值会非常非常大 配合下面的检查 newcap 本身是否小于0 即可判断 newcap 是否溢出
		if uint(newcap) >= uint(newLen) {
			break
		}
	}

	// Set newcap to the requested cap when
	// the newcap calculation overflowed.
        // 如果 newcap 发生了溢出 直接返回 newLen 作为容量
	if newcap <= 0 {
		return newLen
	}
	return newcap
}
```

$$
newcap = \frac{newcap + 3 * threshold}{4}
$$

5. copy 的过程不会触发底层数组的扩容。

Go底层/特性解析 | Slice

MisakaOJ项目，第六次记录内容



前五次记录已经把接口实现的差不多了，没实现的接口无非都是增删改查，没有本质上的区别，之后还是想着能不能加一些技术栈，加一两个拓展板块，或者别的能够加快访问速度的东西。

还能加的板块可以是题目的题解信息，题目评论区一类的，这俩可以加。

### 1 引入第三方 Logger

这次选择引入的是第三方库`Zap`。

``` shell
go get -u go.uber.org/zap
go get -u moul.io/zapgorm2
```

第一个是`Zap`库，第二个是针对 gorm 的，配合`Zap`库使用的 logger 第三方库。

先说这个 logger 怎么初始化。

``` go
var logger *zap.Logger

func ZapInit() error {
	// 创建 log 文件 并且从 io.Writer 类型转换到 WriteSyncer 其实就是保证该文件对应的数据结构一定有一个 Sync 方法 使其能够被 zapcore.NewCore 使用
	logFile, e := os.Create(config.GlobalConfig.LoggerFilePath + time.Now().Format("2006.01.02-15.04.05") + ".json")
	if e != nil {
		return e
	}
	logFileSyncer := zapcore.AddSync(logFile)
	
	/*
	lumberJackLogger := &lumberjack.Logger{
	        Filename:   filename,  // 文件位置
	        MaxSize:    maxsize,   // 进行切割之前,日志文件的最大大小(MB为单位)
	        MaxAge:     maxAge,    // 保留旧文件的最大天数
	        MaxBackups: maxBackup, // 保留旧文件的最大个数
	        Compress:   false,     // 是否压缩/归档旧文件
	    }
	
	logFileSyncer := zapcore.AddSync(lumberJackLogger)
	
	这是给分片 log 文件用的 避免 log 文件过大 当然这里感觉不是很有这个必要
	 */
	
	// 获取一个 Production 下的 Encoder 开始自定义格式
	encoderConfig := zap.NewProductionEncoderConfig()
	// 时间对应的键
	encoderConfig.TimeKey = "time"
	// 时间格式化 2022-09-01T19:11:35.921+0800
	encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
	// log 等级全部大写
	encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
	// 打印堆栈信息的时候用的 这个只显示代码所在文件的文件名和行号 不写完整路径 和它对着来的就是 FullCallerEncoder
	encoderConfig.EncodeCaller = zapcore.ShortCallerEncoder
	// 打印出来的是 json 格式 如果需要控制台格式的就是 NewConsoleEncoder
	jsonEncoder := zapcore.NewJSONEncoder(encoderConfig)
	
	// 和输出到文件对应的 设置到控制台的输出
	consoleSyncer := zapcore.AddSync(os.Stdout)
	// 控制台格式 Encoder
	consoleEncoder := zapcore.NewConsoleEncoder(encoderConfig)
	
	// 将到文件和控制台的输出合并
	core := zapcore.NewTee(
		zapcore.NewCore(jsonEncoder, logFileSyncer, zapcore.DebugLevel),
		zapcore.NewCore(consoleEncoder, consoleSyncer, zapcore.DebugLevel),
	)
	
	// 正式获取 logger
	logger = zap.New(core, zap.AddCaller())
	//logger = zap.New(core, zap.AddCaller(), zap.AddStacktrace(zapcore.ErrorLevel))
	// 上面这一行是在原来的基础上加了一些配置
	// zap.AddCaller 给每个 log 附加调用者信息
	// zap.AddStackTrace(zapcore.ErrorLevel) 在 log 等级达到 Error 时 自动附加堆栈信息
	
	// 使其能够在全局通过 zap.L 函数获取 logger
	zap.ReplaceGlobals(logger)
	
	return nil
}
```

任何初始化需要用到的参数基本都写在注释里了，之后是把这个 logger 嵌入到 Gin 里面。

``` go
func GinLogger(logger *zap.Logger) gin.HandlerFunc {
	return func(c *gin.Context) {
		start := time.Now()
		path := c.Request.URL.Path
		query := c.Request.URL.RawQuery
		
		c.Next()
		
		cost := time.Since(start)
		logger.Info("GIN",
			zap.Int("status", c.Writer.Status()),
			zap.String("method", c.Request.Method),
			zap.String("path", path),
			zap.String("query", query),
			zap.String("client_ip", c.ClientIP()),
			zap.String("user_agent", c.Request.UserAgent()),
			zap.String("error", c.Errors.ByType(gin.ErrorTypePrivate).String()),
			zap.Duration("time_cost", cost),
			
			/*
				注意那个 error 它所捕获的是不会返回给客户端的 只在开发阶段出现的 这样出现的错误
			
				c.Error(gin.Error{
						Type:  gin.ErrorTypePrivate,
						Err:   errors.New("This is a private error"),
						Meta:  "Some additional info",
					})
			*/
		)
	}
}

func GinRecovery(logger *zap.Logger, needStackInfo bool) gin.HandlerFunc {
	return func(c *gin.Context) {
		defer func() {
			if e := recover(); e != nil {
				
				// 这段来自 gin 的源码 具体是检查这个 panic 是否是系统爆出来的 向一个已经关闭的管道写入内容 或者 连接已被对方重置 的错误
				// 如果是 那其实没有必要再试图向客户端发送 InternalError 状态码 直接 c.Abort 然后 return 出去就好
				var brokenPipe bool
				if ne, ok := e.(*net.OpError); ok {
					var se *os.SyscallError
					if errors.As(ne, &se) {
						seStr := strings.ToLower(se.Error())
						if strings.Contains(seStr, "broken pipe") ||
							strings.Contains(seStr, "connection reset by peer") {
							brokenPipe = true
						}
					}
				}
				
				// 这也是来自源码
				// 将请求转换为 HTTP1.x 版本的 便于打印 转换完了就变成字节数组了 注意即使是 HTTP2 也会被转换为 HTTP1.x 而不是它们自己的二进制形式
				httpRequest, _ := httputil.DumpRequest(c.Request, false)
				
				if brokenPipe {
					logger.Error("GIN-Recovery From Panic",
						zap.String("path", c.Request.URL.Path),
						zap.Any("error", e),
						zap.String("request", string(httpRequest)),
					)
					c.Error((e).(error))
					c.Abort()
					return
				}
				
				if needStackInfo {
					logger.Error("GIN-Recovery From Panic",
						zap.Any("error", e),
						zap.String("request", string(httpRequest)),
						zap.Stack("stack_info"),
					)
				} else {
					logger.Error("GIN-Recovery From Panic",
						zap.Any("error", e),
						zap.String("request", string(httpRequest)),
					)
				}
				
				c.AbortWithStatus(http.StatusInternalServerError)
			}
		}()
		c.Next()
	}
}
```

要写的都写注释里了，之后是到 router 那里注册 logger 中间件。

``` go
func Router() *gin.Engine {
	r := gin.New()
	
	// 启用 zap 作为 logger
	r.Use(logger.GinLogger(zap.L()), logger.GinRecovery(zap.L(), true))
        ...
}
```

注意这里一定要调用`gin.New()`函数而不是`gin.Default()`，因为`gin.Default()`里面默认会启用自己的 logger 和 recover：

``` go
// gin 源码
// Default returns an Engine instance with the Logger and Recovery middleware already attached.
func Default(opts ...OptionFunc) *Engine {
	debugPrintWARNINGDefault()
	engine := New()
	engine.Use(Logger(), Recovery()) // 看这里
	return engine.With(opts...)
}
```

最后是嵌入到 gorm 中。注意 import，看看对应的是哪个包。

``` go
package models

import (
	"database/sql"
	"fmt"
	"github.com/redis/go-redis/v9"
	"go.uber.org/zap"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	logger2 "gorm.io/gorm/logger"
	"moul.io/zapgorm2"
	"time"
)

var DB *gorm.DB

func InitMysql() error {
	logger := zapgorm2.New(zap.L())
	logger.SlowThreshold = 2 * time.Second // 慢 sql 阈值 如果一个 sql 语句执行时间超过阈值 log 等级为 WARN 而不是 INFO
	logger.LogMode(logger2.Info) // 全局Debug模式
	db, e := gorm.Open(mysql.Open("root:123456@tcp(127.0.0.1:19327)/misaka_oj?charset=utf8mb4&parseTime=True&loc=Local"),
		&gorm.Config{
			DisableForeignKeyConstraintWhenMigrating: true,       // 禁止自动创建关联对应的外键
			Logger:                                   logger,
		})
	...
}
```

注意，这里需要控制，数据库必须在 logger 初始化之后开始连接，所以这里修改了初始化方式，没有再自动调用函数，而是交给 main 搞定。

``` go
func main() {
	e := config.LoadConfig("./config.json")
	if e != nil {
		panic(e)
	}
	
	e = logger.ZapInit()
	if e != nil {
		panic(e)
	}
	defer func(l *zap.Logger) {
		_ = l.Sync()
	}(zap.L())
	
	e = models.InitMysql()
	if e != nil {
		panic(e)
	}
	models.InitRedis()
	
	gin.SetMode(gin.ReleaseMode)
	r := router.Router()
	e = r.Run(config.GlobalConfig.ServerAddr)
	if e != nil {
		panic(e)
	}
}
```

这样，`Zap`就作为 logger 嵌入项目中了：

``` go
func HandleExecCodeRemoteRequest() {
	for {
		requestWithCallback := <-execCodeRequestChan
		client := <-availableClientChan
		
		go func(req *ExecCodeRequestWithCallBack, client *ClientWithConn) {
			response, e := client.client.ExecCodeRemote(context.Background(), requestWithCallback.request)
			
			// 错误处理 规定如果服务端执行代码过程中的所有错误全部定义为 Internal
			if e != nil {
				zap.L().Error("ExecCodeRemote",
					zap.String("response", response.String()),
					zap.Error(e),
				)
                                ...
                 }
             }
}                                
```

### 2 读取配置文件

``` go
type Config struct {
	ServerAddr string `json:"server_addr"` // 监听地址+端口
	
	DefaultPage int `json:"default_page"` // 查询问题列表时 默认查询页数
	DefaultSize int `json:"default_size"` // 查询问题列表时 默认查询问题个数
	
	JwtExpiredTime int    `json:"jwt_expired_time"` // Token默认过期时间 单位为分钟
	JwtRefreshTime int    `json:"jwt_refresh_time"` // Token自动刷新时间 单位为分钟
	JwtKey         string `json:"jwt_key"`          // jwt所用的密钥
	
	EmailAddr           string `json:"email_addr"`             // 使用的邮箱帐号
	EmailSender         string `json:"email_sender"`           // 发出邮件的发信人
	EmailSMTPHostName   string `json:"email_smtp_host_name"`   // QQ邮箱的SMTP服务器域名
	EmailSMTPAuthCode   string `json:"email_smtp_auth_code"`   // SMTP授权码 在QQ邮箱中当密码用
	EmailSMTPServerPort string `json:"email_smtp_server_port"` // SMTP服务器端口 587端口也可用
	
	SubmitCodeSavePath string `json:"submit_code_save_path"` // 用户提交的代码的保存位置
	
	ExecCodeRemotely         bool   `json:"exec_code_remotely"`          // 是否远程执行代码
	RegisterRemoteServerPort string `json:"register_remote_server_port"` // 注册远程执行代码服务端口
}

var GlobalConfig *Config

func LoadConfig(configFilePath string) error {
	file, e := os.Open(configFilePath)
	if e != nil {
		return e
	}
	defer func(file *os.File) {
		_ = file.Close()
	}(file)
	
	fileBytes, e := io.ReadAll(file)
	if e != nil {
		return e
	}
	var result *Config
	e = json.Unmarshal(fileBytes, result)
	if e != nil {
		return e
	}
	GlobalConfig = result
	return nil
}
```

等到要用的时候，就大概类似这样：

``` go
func main() {
	e := config.LoadConfig("./config.json")
	if e != nil {
		panic(e)
	}
	r := router.Router()
	e = r.Run(config.GlobalConfig.ServerAddr)
	if e != nil {
		panic(e)
	}
}
```

配置文件示例如下：

``` json
{
  "server_addr": "127.0.0.1:8060",

  "default_page": 1,
  "default_size": 20,

  "jwt_expired_time": 60,
  "jwt_refresh_time": 30,
  "jwt_key": "jwt_key",

  "email_addr": "misaka19327@qq.com",
  "email_sender": "Misaka19327",
  "email_smtp_host_name": "smtp.qq.com",
  "email_smtp_auth_code": "email_smtp_auth_code",
  "email_smtp_server_port": ":465",

  "submit_code_save_path": "./code/",

  "exec_code_remotely": false,
  "register_remote_server_port": ":22332"
}
```

### 3 注册定时任务

使用第三方 Cron 包来运行定时任务。

``` shell
go get github.com/robfig/cron/v3@v3.0.0
```

假设这块有个什么任务：

``` go
func Something() {...}
```

初始化这个定时任务，假设它一个小时一次：

``` go
func TaskInit() (e error) {
	C = cron.New()
	
	// 添加任务
	_, e = C.AddFunc("@every 1h", Something)
	if e != nil {
		return e
	}
	
	// 立即执行一次的任务
	Something()
	
	return nil
}
```

添加任务有两种：一个就是上面这个函数型的，还有一个 Job，需要一个结构体实现 Run 方法再传给 Cron。定时也有两种方式，一种是上面的比较好懂的，另一种是按这个格式指定一个时间点：`分 时 日 月 周历（即星期几）`，比如`0 0 1 1 *`即为每个1月1日的0时0分触发。当然这个格式可以自己自定义，这个需要的时候再查也行。

注意，Cron 初始化的时候，对于每一个小时触发一次这种，并不会立即触发一次任务。因为这个“每一个小时触发一次”，实质上就是`0 * * * *`。

对于 Zap 来说，要想嵌入 Cron，只需要实现两个函数即可：

``` go
var C *cron.Cron

type CronLogger struct {
	l *zap.Logger
}

func (c *CronLogger) Info(msg string, keysAndValues ...interface{}) {
	c.l.Info("Cron",
		zap.String("msg", msg),
		zap.Any("key_and_values", keysAndValues),
	)
}

func (c *CronLogger) Error(e error, msg string, keysAndValues ...interface{}) {
	c.l.Error("Cron-Error",
		zap.Error(e),
		zap.String("msg", msg),
		zap.Any("key_and_values", keysAndValues),
	)
}

func TaskInit() (e error) {
	cronLogger := &CronLogger{
		l: zap.L(),
	}
	C = cron.New(cron.WithChain(cron.Recover(cronLogger)), cron.WithLogger(cronLogger))
	
	// 添加任务
	_, e = C.AddFunc("@every 1h", Something)
	if e != nil {
		return e
	}
	
	return nil
}
```

### 4 优化查询用户排行榜接口

把前50名用户的数据通过定时任务实时更新到 Redis 中，访问接口的时候直接从 Redis 拿数据即可。

先说定时任务：

``` go
func RefreshUserRankListTop50() {
	var e error
	data := make([]*models.User, 50)
	
	e = models.GetUserDetailByColumn("", "").
		Order("finish_question_num DESC, submit_num ASC").Limit(50).
		Find(&data).Error
	if e != nil {
		zap.L().Error("Cron",
			zap.Error(e),
		)
		return
	}
	for i := range data {
		bytes, e := json.Marshal(data[i])
		if e != nil {
			zap.L().Error("Cron",
				zap.Error(e),
			)
			return
		}
                // hset key field value
		e = models.RDB.HSet(context.Background(), "UserRankTop50", strconv.Itoa(i), bytes).Err()
		if e != nil {
			zap.L().Error("Redis-Write",
				zap.String("method", "HSet"),
				zap.String("key", "UserRankTop50"),
				zap.String("field", strconv.Itoa(i)),
				zap.Any("value", string(bytes)),
				zap.Error(e),
			)
			return
		}
	}
}

func TaskInit() (e error) {
        ...
	
	// 添加任务
	_, e = C.AddFunc("@every 1h", RefreshUserRankListTop50)
	if e != nil {
		return e
	}
	
	...
}
```

然后修改 Handler：

``` go
// GetRankList
//	@Tags		公共方法
//	@Summary	获取用户排行榜列表
//	@Param		page	query	int		false	"page"
//	@Param		size	query	int		false	"size"
//	@Success	200		{data}	json	"{"code": "200", "data": ""}"
//	@Router		/rank_list [get]
func GetRankList(c *gin.Context) {
	page, e := strconv.Atoi(c.DefaultQuery("page", strconv.Itoa(config.GlobalConfig.DefaultPage)))
	if e != nil {
		ErrorHandler(c, "Get Param page Error: "+e.Error())
		return
	}
	size, e := strconv.Atoi(c.DefaultQuery("size", strconv.Itoa(config.GlobalConfig.DefaultSize)))
	if e != nil {
		ErrorHandler(c, "Get Param size Error: "+e.Error())
		return
	}
	page = (page - 1) * size // page到offset的转换
	
	var count int64 = 0
	data := make([]*models.User, 0)
	
	// 看情况是从 Redis 里面取数据还是从数据库里面拿数据
	// 拿数据的范围是从 page 到 page + size 之间的用户
	if page + size <= 49 {
		// 如果是前50 从 Redis 里面拿
		var r string
		rUser := &models.User{}
		for i := page; i <= page + size; i++ {
			r, e = models.RDB.HGet(context.Background(), "UserRankTop50", strconv.Itoa(i)).Result()
			if e != nil {
				if errors.Is(e, redis.Nil) {
					break
				}
				ErrorHandler(c, errors.Join(constants.RedisHGetErr, e).Error())
				return
			}
			_ = json.Unmarshal([]byte(r), rUser)
			data = append(data, rUser)
			count += 1
		}
	} else {
		// 从数据库里拿
		e = models.GetUserDetailByColumn("", "").Count(&count).
			Order("finish_question_num DESC, submit_num ASC").
			Offset(page).Limit(size).
			Find(&data).Error
		if e != nil {
			ErrorHandler(c, errors.Join(constants.DataBaseQueryErr, e).Error())
			return
		}
	}
	
	
	c.JSON(http.StatusOK, gin.H{
		"code": 200,
		"data": map[string]any{
			"count": count,
			"list":  data,
		},
	})
}
```

从 log 来看确实快了不少（左侧是 Redis，右侧是把 Redis 部分删了，单位是秒，Zap 的默认对 Duration 的编码就是编码为以秒的小数）：

![image.png](https://www.misaka19327.cc/static/img/65999298f7bd20f639b32701e237a1f7.image.png)