## 安装 Gin

[文档 | Gin Web Framework (gin-gonic.com)](https://gin-gonic.com/zh-cn/docs/)

打开命令行窗口，输入

```bash
go get -u github.com/gin-gonic/gin
```

大概率可能安装不上，一般这里就需要配置 Go 代理

## 使用

创建文件夹 GinTest，进入目录输入命令`go mod init GinTest`来管理项目的包

创建文件 main.go 内容为

```go title="main.go"
package main

import "github.com/gin-gonic/gin"

func main() {
	r := gin.Default()

	r.GET("/", func(c *gin.Context) {
		c.String(200, "你好,gin")
	})

	r.Run()
}
```

通过`go run "f:\GO\GinTest\main.go"`即可运行 go 服务。

![image-20210831045351327](https://img.kuizuo.cn/image-20210831045351327.png)

通过浏览器访问`http:127.0.0.1:8080`便可输出`你好,gin`

### 热加载

由于每次更改代码后都需要重新启动，通过热加载可以省去每次手动编译的过程

### Fresh

这边使用的是 fresh，还有其他的热加载工具，例如 Air，bee，gin 等等

```bash
go get github.com/pilu/fresh
```

接着输入 fresh 即可

![image-20210831061629685](https://img.kuizuo.cn/image-20210831061629685.png)

同时还会在当前目录下创建 tmp 文件夹，有个编译好的可执行文件。

### 返回数据格式

上面代码所演示的`c.String()` 返回的是文本格式，但有时候要返回的可能是一个 JSON 类型，或者是一个 HTML 或 XML 格式。这时候的话就需要使用其他方法了

### JSON

```go title="main.go"
r.GET("/json", func(c *gin.Context) {
	c.JSON(200, map[string]interface{}{
		"code": 200,
		"msg":  "成功",
	})
})
```

浏览器访问http://127.0.0.1:8080/json显示如下数据

```json
{ "code": 200, "msg": "成功" }
```

> 注: msg 属性后，必须要有,号

其中`map[string]interface{}`可以简写为`gin.H`

也可通过定义结构体

```go title="main.go"
type Article struct {
	Title   string `json:"title"`
	Desc    string `json:"desc"`
	Content string `json:"content"`
}

r.GET("/json3", func(c *gin.Context) {
	a := &Article{
		Title:   "这是标题",
		Desc:    "描述",
		Content: "测试内容",
	}

	c.JSON(200, a)
})
```

得到数据

```json
{ "title": "这是标题", "desc": "描述", "content": "测试内容" }
```

JSONP 与 XML 数据就不做介绍，顺便提一下，这年头还有人用 JSONP 来跨域吗？

### HTML

要发送 HTML 的话，首先在根目录下创建文件夹`templates`，再创建一个文件`test.html`，其中`<body>`内容为

```html title="/templates/test.html"
<body>
  <h2>{{.title}}</h2>
</body>
```

接着在 main.go 中配置 Html 模板文件，如下

```go title="main.go"
r := gin.Default()
r.LoadHTMLFiles("templates/*")
```

重启下服务，然后就可以在路由中返回 HTML 文件，如

```go title="main.go"
r.GET("/html", func(c *gin.Context) {

	c.HTML(200, "test.html", gin.H{
		"title": "一个标题而已",
	})
})
```

结果就不放图了，就是将`一个标题而已`填入至 h2 标签处

### 配置静态 Web 目录

和配置 html 模板一样，先在根目录下创建一个静态 web 目录 static，然后添加

```go title="main.go"
r.Static("/static", "./static")
```

访问 `http://127.0.0.1:8080/static` 就能访问静态文件夹下的资源

### 获取 Query 参数

```go title="main.go"
r.GET("/query", func(c *gin.Context) {
	username := c.Query("username")
	page := c.DefaultQuery("page", "1")

	c.String(200, username+page)
})
```

浏览器请求 `http://127.0.0.1:8080/query?username=kuizuo` 便可输出 `kuizuo1`

### 获取 Post 数据

```go title="main.go"
r.POST("/add", func(c *gin.Context) {
    username := c.PostForm("username")
    password := c.PostForm("password")

    c.String(200, username+password)
})
```

使用 api 请求工具发送 post 数据便可输出相应数据

### Post 传值绑定到结构体

```go title="main.go"
type UserInfo struct {
	Username string `json:"username" form:"username"`
	Password string `json:"password" form:"password"`
}

r.POST("/add1", func(c *gin.Context) {
	user := &UserInfo{}

	if err := c.ShouldBind(&user); err == nil {
		c.JSON(200, user)
	} else {
		c.JSON(400,gin.H{
			"err":err.Error()
		})
	}
})
```

同样使用 api 请求工具，发送 post 数据，就可直接通过 user 获取信息

### 动态路由传值

```go title="main.go"
r.GET("/list/:id", func(c *gin.Context) {
    id := c.Param("id")
    c.String(200, id)
})
```

浏览器请求http://127.0.0.1:8080/list/123 id 便可赋值为 123

### 路由分组

在根目录下创建文件夹`routers`，里面创建路由文件，如`apiRouters.go`，内容如下

```go title="/routers/apiRouters.go"
package routers

import "github.com/gin-gonic/gin"

func ApiRoutersInit(r *gin.Engine) {
	apiRouters := r.Group("/api")
	{
		apiRouters.GET("/json", func(c *gin.Context) {
			c.JSON(200, gin.H{
				"code": 200,
				"msg":  "成功",
			})
		})
	}
}
```

接着在`main.go`文件中，导入 routers

```go title="main.go"
import (
	"GinTest/routers"
	"github.com/gin-gonic/gin"
)
```

同时输入

```go title="main.go"
r := gin.Default()

routers.ApiRoutersInit(r)
```

访问 [http://127.0.0.1:8080/api/json](http://127.0.0.1:8080/api/json)，显示`{"code":200,"msg":"成功"}`

### 控制器

在根目录下创建文件夹`controllers`，里面创建控制器文件，如`userController.go`，内容如下

```go title="/controllers/user/userController.go"
package user

import "github.com/gin-gonic/gin"

type UserController

func UserList(c *gin.Context) {
	c.String(200, "用户列表")
}

func UserAdd(c *gin.Context) {
	c.String(200, "添加用户")
}

func UserEdit(c *gin.Context) {
	c.String(200, "编辑用户")
}
```

```go title="/routers/userRouters.go"
package routers

import (
	"GinTest/controllers/user"
	"github.com/gin-gonic/gin"
)

func UserRoutersInit(r *gin.Engine) {
	userRouters := r.Group("/user")
	{
		userRouters.GET("/list", user.UserList)
		userRouters.GET("/add", user.UserAdd)
		userRouters.GET("/edit", user.UserEdit)
	}
}
```

分别访问对应三个路由，都可得到对应结果

也可以通过控制器结构体优化成如下

```go title="/controllers/user/userController.go"
package user

import "github.com/gin-gonic/gin"

type UserController struct {
}

func (con UserController) List(c *gin.Context) {
	c.String(200, "用户列表")
}

func (con UserController) Add(c *gin.Context) {
	c.String(200, "添加用户")
}

func (con UserController) Edit(c *gin.Context) {
	c.String(200, "编辑用户")
}
```

```go title="/routers/userRouters.go"
package routers

import (
	"GinTest/controllers/user"

	"github.com/gin-gonic/gin"
)

func UserRoutersInit(r *gin.Engine) {
	userRouters := r.Group("/user")
	{
		userRouters.GET("/list", user.UserController{}.List)
		userRouters.GET("/add", user.UserController{}.Add)
		userRouters.GET("/edit", user.UserController{}.Edit)
	}
}
```

### 中间件

中间件本质上就是一个函数，路由执行的时候可以在对应的地方添加中间件执行，如

#### 局部中间件

```go title="main.go"
func initMiddleware(c *gin.Context) {
	fmt.Println("1-中间件")

	c.Next()

	fmt.Println("2-中间件")
}

r.GET("/", initMiddleware, func(c *gin.Context) {
    c.String(200, "你好,gin")
})
```

访问[http://127.0.0.1:8080](http://127.0.0.1:8080) 便会输出 `1-中间件` `2-中间件`

#### 全局中间件

```go title="main.go"
r.Use(initMiddleware)
```

这样就需要给每个路由添加中间件配置，所有路由请求后都将会输出。

#### 分组中间件

与全局中间件使用一样，如

```go title="/routers/apiRouters.go"
apiRouters := r.Group("/api",initMiddleware)

// 或
apiRouters := r.Group("/api")
apiRouters.Use(initMiddleware)
```

可以创建中间件目录`middlewares`，创建文件`init.go`，内容

```go title="/middleware/init.go"
package middlewares

import (
	"fmt"
	"github.com/gin-gonic/gin"
)

func InitMiddleware(c *gin.Context) {
	fmt.Println("1-中间件")

	c.Next()

	fmt.Println("2-中间件")
}
```

使用如下（前提需要导入中间件的包）

```go title="/routers/apiRouters.go"
apiRouters.Use(middlewares.InitMiddleware)
```

#### 取消默认中间件

gin.Default()默认使用了 Logger 和 Recovery 中间件

```go
// Default returns an Engine instance with the Logger and Recovery middleware already attached.
func Default() *Engine {
	debugPrintWARNINGDefault()
	engine := New()
	engine.Use(Logger(), Recovery())
	return engine
}
```

如果需要上面两个默认的中间件，可以使用 gin.New()新建一个没有任何中间件的路由

#### 中间件中使用 goroutine 协程

```go title="/middleware/init.go"
func InitMiddleware(c *gin.Context) {
	fmt.Println("1-中间件")

	cCp := c.Copy()
	go func() {
		time.Sleep(2 * time.Second)
        fmt.Println("path: " + cCp.Request.URL.Path)
	}()

	c.Next()

	fmt.Println("2-中间件")
}
```

请求完成两秒后，将会打印`path /`

### 文件上传

```go title="main.go"
r.MaxMultipartMemory = 8 << 20 // 8 MiB
r.POST("/upload", func(c *gin.Context) {
	// 单文件
	file, _ := c.FormFile("file")
	log.Println(file.Filename)

	// 上传文件至指定目录
	dst := path.Join("./static/upload", file.Filename)
	c.SaveUploadedFile(file, dst)

	c.String(200, fmt.Sprintf("'%s' uploaded!", file.Filename))
})
```

使用 curl，即可上传文件

```bash
curl -X POST http://localhost:8080/upload \
  -F "file=@/Users/appleboy/test.zip" \
  -H "Content-Type: multipart/form-data"
```

## 最终项目结构

![image-20210901033059576](https://img.kuizuo.cn/image-20210901033059576.png)

## 整体感受

说实话，我已经快一年没真正接触一门新的语言了，写 Js 和 Ts 代码也写了快一年了，初次体验 Gin 框架整体感受还算不错，大部分的后端框架路由基本都是这么写的，体验过 Express，Flask 路由写法大致相同。

仅仅只是初步体验，后续估计会考虑尝试上手 gin-vue-admin 项目

[自动化全栈后台管理系统 | Gin-Vue-Admin](https://www.gin-vue-admin.com/)

Gin框架初体验

提交规范主要是为了让开发者提交完整的更新信息，方便查阅。

目前最为流行的提交信息规范来自于 Angular 团队。

规范中，主要就是要求提交内容要进行分类并填写内容，更为严格的规定是要求标注开发模块，整个语法如下

```bash
type(scope?): subject  #scope is optional; multiple scopes are supported (current delimiter options: "/", "\" and ",")
```

| type     | commit 的类型                                            |
| -------- | -------------------------------------------------------- |
| feat     | 新功能、新特性                                           |
| fix      | 修改 bug                                                 |
| perf     | 更改代码，以提高性能                                     |
| refactor | 代码重构（重构，在不影响代码内部行为、功能下的代码修改） |
| docs     | 文档修改                                                 |
| style    | 代码格式修改, 注意不是 css 修改（例如分号修改）          |
| test     | 测试用例新增、修改                                       |
| build    | 影响项目构建或依赖项修改                                 |
| revert   | 恢复上一次提交                                           |
| ci       | 持续集成相关文件修改                                     |
| chore    | 其他修改（不在上述类型中的修改）                         |
| release  | 发布新版本                                               |
| workflow | 工作流相关文件修改                                       |

以下是一些示例：

| commit message                     | 描述                      |
| ---------------------------------- | ------------------------- |
| chore: init                        | 初始化项目                |
| chore: update deps                 | 更新依赖                  |
| chore: wording                     | 调整文字（措词）          |
| chore: fix typos                   | 修复拼写错误              |
| chore: release v1.0.0              | 发布 1.0.0 版本           |
| fix: icon size                     | 修复图标大小              |
| fix: value.length -> values.length | value 变量调整为 values   |
| feat(blog): add comment section    | blog 新增评论部分         |
| feat: support typescript           | 新增 typescript 支持      |
| feat: improve xxx types            | 改善 xxx 类型             |
| style(component): code             | 调整 component 代码样式   |
| refactor: xxx                      | 重构 xxx                  |
| perf(utils): random function       | 优化 utils 的 random 函数 |
| docs: xxx.md                       | 添加 xxx.md 文章          |

更多示例可以参考主流开源项目的 commit。

## 检查 commit 规范

要检查 commit message 是否符合要求，可以使用 [commitlint](https://github.com/conventional-changelog/commitlint) 工具，并配合 [husky](https://github.com/typicode/husky) 对每次提交的 commit 进行检查。

当然规范不是强求，但 commit message 一定要能简要说明本次代码的改动主要部分，有利于他人与自己后期查看代码记录。

git commit 规范

## 需求

需求是这样的，要统计每一周的各个商品的销售记录，使用 echarts 图表呈现，如下图

![image-20210830214556262](https://img.kuizuo.cn/image-20210830214556262.png)

说实话，一开始听到这个需求的时候，我是有点慌的，因为 MongoDB 的分组玩的比较少（Mysql 也差不多），又要按照对应的星期来进行分组，这在之前学习 MongoDB 的时候还没接触过，于是就准备写了这篇文章，来记录下我是如何进行分组的

## MongoDB 的一些时间操作符

时间操作符（专业术语应该不是这个，后文暂且使用这个来描述），**后面会用到的**

```
$dayOfYear: 返回该日期是这一年的第几天。（全年366天）
$dayOfMonth: 返回该日期是这一个月的第几天。（1到31）
$dayOfWeek: 返回的是这个周的星期几。（1：星期日，7：星期六）
$year: 返回该日期的年份部分
$month： 返回该日期的月份部分（between 1 and 12.）
$week： 返回该日期是所在年的第几个星期（between 0 and 53）
$hour： 返回该日期的小时部分
$minute: 返回该日期的分钟部分
$second: 返回该日期的秒部分（以0到59之间的数字形式返回日期的第二部分，但可以是60来计算闰秒。）
$millisecond：返回该日期的毫秒部分（between 0 and 999.）
$dateToString：{ $dateToString: { format: <formatString>, date: <dateExpression> } }
```

## 日期分组

[mongdb 聚合查询日期 统计每天数据](https://blog.csdn.net/wangshu_liang/article/details/95326578?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_baidulandingword~default-0.essearch_pc_relevant&spm=1001.2101.3001.4242)

关于日期分组的话，我是借鉴了这篇文章，也确实带我解惑了下如何按照日期分组。这里贴下我的代码

```js
let list = await this.goodsModel
  .aggregate([
    { $project: { date: { $dateToString: ['$created_at', 0, 10] } } },
    { $group: { _id: '$date', count: { $sum: 1 } } },
    { $project: { date: '$_id', _id: 0, count: 1 } }, // 再使用$project将_id改名为date
    { $sort: { date: -1 } }, // 根据日期倒序
  ])
  .exec();
```

或者使用时间操作符（更准确一点）

```js
let list = await this.goodsModel
  .aggregate([
    {
      $project: { date: { $dateToString: { format: '%Y-%m-%d', date: '$created_at' } } },
    },
    { $group: { _id: '$date', count: { $sum: 1 } } },
    { $project: { date: '$_id', _id: 0, count: 1 } }, // 再使用$project将_id改名为date
    { $sort: { date: -1 } }, // 根据日期倒序
  ])
  .exec();
```

通过

> 要注意的是，$group 里的属性必须为\_id，不然无法分组

获取到的数据如下（这里只显示一周）

```json
[
  { "count": 54, "date": "2021-08-30" },
  { "count": 29, "date": "2021-08-29" },
  { "count": 16, "date": "2021-08-28" },
  { "count": 17, "date": "2021-08-27" },
  { "count": 12, "date": "2021-08-26" },
  { "count": 6, "date": "2021-08-25" },
  { "count": 0, "date": "2021-08-24" }
]
```

如果只是日期和总商品的话，上面就足以显示对应的数据了，可我要根据星期进行分组的话，就需要替换 MongoDB 的时间转化函数了

## 星期分组

星期分组的话，其实也挺简单的，只需要把上面的

```js
$project: { day: { $dateToString: { format: "%Y-%m-%d", date: "$created_at" } } }
```

替换成

```js
$project: {
  week: {
    $dayOfWeek: {
      date: '$created_at';
    }
  }
}
```

完整代码如下

```js
// 要获取的是一周前的零点时间
let lastweekDay = dayjs(dayjs().add(-7, 'day').format('YYYY-MM-DD')).valueOf();

let list = await this.goodsModel
  .aggregate([
    { $match: { created_at: { $gte: new Date(lastweekDay) } } }, //范围时间
    { $project: { week: { $dayOfWeek: { date: '$created_at' } } } },
    { $group: { _id: '$week', count: { $sum: 1 } } },
    { $project: { week: '$_id', _id: 0, count: 1 } }, // 再使用$project将_id改名为week
    { $sort: { week: 1 } }, // 根据星期正序
  ])
  .exec();
```

获取的结果如下

```js
[
  { count: 29, week: 1 }, // 星期七(日)
  { count: 54, week: 2 }, // 星期一
  { count: 1, week: 3 }, // 星期二
  { count: 9, week: 4 }, // 星期三
  { count: 12, week: 5 }, // 星期四
  { count: 17, week: 6 }, // 星期五
  { count: 16, week: 7 }, // 星期六
];
```

但是，细心的你可能会发现，貌似数据对不上，注当天时间为 2021-08-30，星期一

```json
[
  { "count": 54, "date": "2021-08-30" }, // 星期一
  { "count": 29, "date": "2021-08-29" }, // 星期七(日)
  { "count": 16, "date": "2021-08-28" }, // 星期六
  { "count": 17, "date": "2021-08-27" }, // 星期五
  { "count": 12, "date": "2021-08-26" }, // 星期四
  { "count": 9, "date": "2021-08-25" }, // 星期三
  { "count": 1, "date": "2021-08-24" } // 星期二
]
```

其实只需要把星期向后排序一位就行，因为星期本来就是将星期日作为第一天的，至此，按照星期分组总商品就算完毕了。同理，要按照月份，年份，甚至小时，分钟，都可以直接利用时间操作符转化时间来进行分组。

## 多商品

上述只是获取了总商品了，要细分为多个商品的话，就需要再次利用聚合函数来进行分组了。

这里先演示分组多个商品先，就和正常分组一样

```
let list = await this.goodsModel.aggregate([
{ $group: { _id: "$type", count: { $sum: 1 } } },
]).exec()
```

结果如下（这里输出\_id，是因为没有进行$project 改别名，商品所采用的是数字表示）

```json
[
  { "_id": 1, "count": 111 },
  { "_id": 2, "count": 18 },
  { "_id": 4, "count": 2 },
  { "_id": 3, "count": 16 }
]
```

可以看到统计的是直接是所有商品的总和。

但问题来了，怎么样能分组星期的同时，又对每个商品所在星期进行分组，并且到底是优先分组星期期呢，还是优先分组商品呢，这让我陷入深深的思考。

## 最终实现

首先，绝对不可能使用两次`$group`，要么没有星期分组，要么没有商品分组，于是我就把思路放在`$project`与`$group`内，看看内部是否有其他方法可以实现。

其中`$group`可以将属性添加为数组，注意 `goods: { $push: "$goods" }`

```js
let list = await this.goodsModel
  .aggregate([
    { $match: { created_at: { $gte: new Date(lastweekDay) } } },
    { $project: { week: { $dayOfWeek: { date: '$created_at' } }, goods: 1 } },
    { $group: { _id: '$week', goods: { $push: '$goods' } } },
    { $project: { week: '$_id', _id: 0, goods: 1 } },
    { $sort: { week: 1 } },
  ])
  .exec();
```

可得到的数据却是这样的

```json
[
  {
    "goods": [4, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1],
    "week": 1
  },
  {
    "goods": [1, 1, 1, 1, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 4, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
    "week": 2
  },
  {
    "goods": [1],
    "week": 3
  },
  {
    "goods": [3, 3, 3, 3, 3, 3, 3, 3, 4],
    "week": 4
  },
  {
    "goods": [3, 1, 1, 1, 3, 4, 1, 1, 1, 1, 1, 1],
    "week": 5
  },
  {
    "goods": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 1, 1, 1, 1, 1],
    "week": 6
  },
  {
    "goods": [4, 3, 1, 1, 3, 3, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1],
    "week": 7
  }
]
```

数据很接近了，如果我能把对应的商品总和算起来就行了，但问题是怎么合起来。。。

待会，goods 既然是数组的话，那我能不能`$unwind`全部展开，然后我再来一次聚合，说干就干！

```js
let list = await this.goodsModel
  .aggregate([
    { $match: { created_at: { $gte: new Date(lastweekDay) } } },
    { $project: { week: { $dayOfWeek: { date: '$created_at' } }, goods: 1 } },
    { $group: { _id: '$week', goods: { $push: '$goods' } } },
    { $project: { week: '$_id', _id: 0, goods: 1 } },
    { $sort: { week: 1 } },
    { $unwind: '$goods' },
  ])
  .exec();
```

得到的数据（省略一堆）

```json
[
  { "goods": 4, "week": 1 },
  { "goods": 4, "week": 1 },
  { "goods": 1, "week": 1 },
  { "goods": 1, "week": 1 },
  { "goods": 1, "week": 2 },
  { "goods": 1, "week": 3 },
  { "goods": 1, "week": 4 }
]
```

然后我就卡住了，因为我无论如何都无法分组一个字段的时候，又加以限制条件，要么分组商品的时候，统计的是一周各商品总数据，要么就是分组星期的时候，统计的是总的商品数据。在搜索大量资料后，查看官方一些文档也未果，于是我决定自行写一个 js 函数来进行排序（实在是折腾不动了，能力有限 🥱）

最终完整代码

```js
let lastweekDay = dayjs(dayjs().add(-7, 'day').format('YYYY-MM-DD')).valueOf();

let list = await this.goodsModel
  .aggregate([
    { $match: { created_at: { $gte: new Date(lastweekDay) } } },
    { $project: { week: { $dayOfWeek: { date: '$created_at' } }, goods: 1 } },
    { $group: { _id: '$week', goods: { $push: '$goods' } } },
    { $project: { week: '$_id', _id: 0, goods: 1 } },
    { $sort: { week: 1 } },
    // { $unwind: "$goods" },
  ])
  .exec();

function getEleNums(data) {
  var map = {};
  data.forEach((e) => {
    if (map[e]) {
      map[e] += 1;
    } else {
      map[e] = 1;
    }
  });
  return map;
}

list = list.map((l) => {
  l.goods = getEleNums(l.goods);
  return l;
});
cosnole.log(list);
```

运行后的 list 结果为

```json
[
  { "goods": { "1": 26, "4": 3 }, "week": 1 },
  { "goods": { "1": 53, "4": 3, "5": 1 }, "week": 2 },
  { "goods": { "1": 1 }, "week": 3 },
  { "goods": { "3": 8, "4": 1 }, "week": 4 },
  { "goods": { "1": 9, "3": 2, "4": 1 }, "week": 5 },
  { "goods": { "1": 15, "3": 2 }, "week": 6 },
  { "goods": { "1": 9, "3": 6, "4": 1 }, "week": 7 }
]
```

如果是要 goods 为分组的话，只需要把上面聚合代码中 week 和 goods 替换一下便可。

## 另一种实现方式

专门新建一个表，用于统计每天的销售记录，然后分组的时候就根据该表就行了，具体代码就实现了，思路是挺简单的，但是需要新建一个表，增加记录的时候有需要增加代码，如果业务复杂的话。。。

MongoDB按时间分组

一个基于 Axios 封装 HTTP 类库

源代码 [kz-http](https://github.com/kuizuo/kz-http)

## 使用方法

npm 安装

```bash
npm i kz-http -S
```

### 请求

```javascript
import Http from 'kz-http'

let http = new Http()

http.get('https://www.example.com').then(res => {
  console.log(res)
})
```

## 能解决什么

axios 明明那么好用，为啥又要基于 axios 重新造一个轮子。首先不得否认的是 axios 确实好用，Github 能斩获近 90k 的 star，且基本已成为前端作为数据交互的必备工具。但是它对我所使用的环境下还是存在一定的问题，也就是我为什么要重新造一个轮子。

### Node 环境下无法自动封装 Set-Cookie

如果 axios 是运行在浏览器那还好说，就算你无论怎么请求，浏览器都会自动将你的所有请求中的响应包含 set-cookie 参数，提供给下一次同域下的请求。但是，Node 环境并不是浏览器环境，在 Node 环境中运行并不会自动保存 Cookie，还需要手动保存，并将 Cookie 添加至协议头给下一个请求。（如果是 Python 的话，request 有个 session 方法可以自动保存 cookie，十分方便）

一开始我是自行封装，将响应中的 set-cookie 全都存在实例对象 http.cookies 上，但封装的不彻底，如果有的网站

间请求存在跨域，那么会将携带不该属于该域下的 Cookies。于是乎，我在 github 仓库找到了一个库可达到我的目的

[3846masa/axios-cookiejar-support: Add tough-cookie support to axios. (github.com)](https://github.com/3846masa/axios-cookiejar-support)

具体安装可以直接点击链接查看，这里贴下我**之前**的封装代码

```javascript
const tough = require('tough-cookie');
const axiosCookieJarSupport = require('axios-cookiejar-support').default;
axiosCookieJarSupport(axios);

class Http {
  public cookieJar;
  public instance: AxiosInstance;
  construction() {
    this.cookieJar = new tough.CookieJar(null, { allowSpecialUseDomain: true });
    this.instance = axios.create({
      jar: this.cookieJar,
      ignoreCookieErrors: false,
      withCredentials: true,
    });
  }
}
```

这样 axios 就会自动将响应中的 set-cookie 封装起来，供下次使用

但是正是由于导入了这个包，导致每次请求都需要处理，就会导致请求速度变慢，实测大约是在 100ms 左右，同时导入这个包之后，实例化的对象都将会携带对应 cookies，想要删除又得对应 Url，于是决定自行封装相关代码可查看 request 方法，实测下来大约有 10ms 左右的差距（前提都通过创建实例来请求），不过有个缺陷，我封装的代码是不进行同源判断的，如何你当前站点请求的是 api1.test.com，获取到 cookie1，那么请求 api2.test.com 的时候也会将 cookie1 携带，这边不做判断是不想在请求的时候耗费时间，比如网页与手机协议，一般这种情况建议实例化两个对象，如

```javascript
let http_api1 = new Http()
let http_api2 = new Http()
```

### 请求失败无法自动重试

在高并发的情况下，偶尔会出现请求超时，请求拒绝的情况，但是默认下 axios 是不支持自动重试请求的，不过可以借助插件`axios-retry`来达到这个目的

```javascript
const axiosRetry = require('axios-retry')

class Http {
  constructor(retryConfig?) {
    this.instance = axios.create()

    if (retryConfig) {
      axiosRetry(this.instance, {
        retries: retryConfig.retry, // 设置自动发送请求次数
        retryDelay: (retryCount) => {
          return retryCount * retryConfig.delay // 重复请求延迟
        },
        shouldResetTimeout: true, // 重置超时时间
        retryCondition: (error) => {
          if (axiosRetry.isNetworkOrIdempotentRequestError(error)) {
            return true
          }

          if (error.code == 'ECONNABORTED' && error.message.indexOf('timeout') != -1) {
            return true
          }
          if (['ECONNRESET', 'ETIMEDOUT'].includes(error.code)) {
            // , 'ENOTFOUND'
            return true
          }
          return false
        },
      })
    }
  }
}
```

这边判断重新发送请求条件是连接拒绝，连接重置，和连接超时的情况。

### 配置拦截器

有时候一个网站的协议是这样的，每一条 Post 都自动将所有参数进行拼接，然后进行 MD5 加密，并添加为 sign 参数，于是，不得不给每一条请求都进行这样的操作，那么有没有什么能在每次请求的时候，都自动的对参数进行 MD5 加密。如果使用过 axios 来配置过 JWT 效验，那自然就会熟悉给每条请求协议头都携带 JWT 数值。同样的，这里的加密例子同样使用，具体配置实例对象 http 的请求拦截器即可，如

```javascript
let http = new Http()

// axios实例instance是公开的
http.instance.interceptors.request.use(
  config => {
    // 执行每条请求都要处理的操作
    return config
  },
  error => {},
)
```

同样的，响应拦截器也同理，例如请求返回的响应都进行加密处理，那么就可以通过响应拦截器进行统一解密，这里就不做过多描述，具体场景具体分析。

### 封装一些常用方法

比如设置伪造 IP（setFakeIP），自动补全 referer 和 orgin 参数，禁止重定向等等，更详细的查看源码便可

## 发布 npm 包

如果要让别人使用的话，总不可能让他去下载源码然后编译吧，这里就借助 npm。

:::tip

在使用 npm 之前，请先使用`npm install -g npm@latest`升级为最新版，否则可能会提示 **ERR! 426 Upgrade Required**。原文 [The npm registry is deprecating TLS 1.0 and TLS 1.1 | The GitHub Blog](https://github.blog/2021-08-23-npm-registry-deprecating-tls-1-0-tls-1-1/)

:::

创建 npm 账号，创建 package.json

```json title="package.json"
{
  "name": "kz-http",
  "version": "0.1.0",
  "description": "An HTTP class library based on axios",
  "main": "dist/index.js",
  "scripts": {
    "build": "tsc"
  },
  "author": "kuizuo",
  "license": "ISC",
  "dependencies": {
    "axios": "^0.21.1",
    "axios-retry": "^3.1.9"
  },
  "devDependencies": {
    "typescript": "^4.3.5"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/kuizuo/kz-http.git"
  },
  "keywords": ["node", "axios", "http"]
}
```

然后通过`npm login`登录 npm 账号，接着输入`npm publish --access public`发布即可

发布的是要注意以下几点

- 如果 npm 镜像必须是官方的，否则无法登录，镜像还原

  ```bash
  npm config set registry https://registry.npmjs.org/
  ```

  查看镜像配置地址

  ```bash
  npm get registry
  ```

- 如果包有重名，那么就无法发布，就必须要要改名

- 邮箱必须要验证（会接受一条下图邮箱），不然就会发布失败 ![image-20210826212258752](https://img.kuizuo.cn/image-20210826212258752.png)

- **请勿随意删包，否则同名的包将需要 24 小时后才能发布（亲测）**

  > npm ERR! 403 403 Forbidden - PUT http://registry.npmjs.org/kz-http - kz-http cannot be republished until 24 hours have passed.

发布完成后，别人只需要通过`npm i kz-http`就可成功将模块下载至本地 node_modules 文件夹下

基于Axios封装HTTP类库

博客地址: [愧怍的小站](https://kuizuo.cn/)

时隔近半年没好好整理文章，博客也写的不像个人样。:joy:

大半年没更新博客，一直忙着写项目（写到手软的那种），然后无意间在 B 站看到一个 Up 主 [峰华前端工程师](https://zxuqian.cn/) 基于 React 驱动的静态网站生成器搭建的个人博客。第一眼看到该站点的时候惊艳到我了，于是我在其基础上并魔改了一些页面功能，作为个人站点使用。

> 不过国内 docusaurus 的使用者是真的少，Vuepress 都快烂大街了...



## 安装

如果你想搭建一个类似的博客，可以 [fork 本项目](https://github.com/kuizuo/blog/fork)，修改个人信息，并将文章迁移过来。这里推荐使用 [Vercel 部署个人博客](https://kuizuo.cn/vercel-deploy-blog)，以下是本地安装示例。

```bash
git clone https://github.com/kuizuo/blog
cd blog
yarn
yarn start
```

关于主题魔改可以看 [Docusaurus 主题魔改](https://kuizuo.cn/docs/docusaurus-guides)

## 一些页面

### [博客页](/blog/)

![image-20230221120937768](https://img.kuizuo.cn/image-20230221120937768.png)

- 支持 3 种博文信息展示
- 博客个人信息卡片
- 可根据 `sticky` 字段对文章进行置顶推荐

### [归档页](/blog/archive)

![image-20220804052418993](https://img.kuizuo.cn/image-20220804052418993.png)

### [资源导航](/resources)

![image-20220804052016538](https://img.kuizuo.cn/image-20220804052016538.png)

- 在此分享所收藏的一些好用、实用网站。

### 评论

![image-20220804052746803](https://img.kuizuo.cn/image-20220804052746803.png)

- 接入 [giscus](https://giscus.app) 作为评论系统，支持 GitHub 登录。

### [项目](/project)

![image-20220804052117492](https://img.kuizuo.cn/image-20220804052117492.png)

- 存放你的项目，或是当做一个作品集用于展示。

## 部署

按传统的方式，你编写好一篇文章后，需要重新打包成静态文件（.html），然后将静态文件上传到服务器（需要自己准备）上，然后通过 nginx 配置域名访问。如今有了自动化部署，你只需要将代码 push 到 Github 上，然后通过 CI/CD 自动化部署到服务器上。可以参考 [ci.yml](https://github.com/kuizuo/blog/blob/main/.github/workflows/ci.yml) 配置文件。

这里推荐使用 [Vercel 部署个人博客](/blog/vercel-deploy-blog)，部署十分简单，你甚至不需要服务器，只需要有个 Github 账号，将你的博客项目添加为一个仓库中即可（也许需要科学上网）。

## 最后

博客的意义在于记录，记录自己的成长，记录自己的所思所想，记录自己的所学所得。希望更多的时间用在创作内容上，而不是在搭建博客上。

也就不浪费口舌了，博客搭建完毕，应该好好的去编写有意义的文章，才能够吸引他人的阅读。