## 概述

上篇文章分享了 Gin 框架使用 Logrus 进行日志记录，这篇文章分享 Gin 框架的数据绑定与验证。

有读者咨询我一个问题，如何让框架的运行日志不输出控制台？

解决方案：

```
engine := gin.Default() //修改成如下
engine := gin.New() 
```

我是怎么知道的？看框架代码。

`Default()`：

```
func Default() *Engine {
	debugPrintWARNINGDefault()
	engine := New()
	engine.Use(Logger(), Recovery())
	return engine
}
```

`New()` 代码我就不贴了。

我们看到 `Default()` 使用了两个中间件 `Logger(), Recovery()`，如果不想使用，那就直接使用 `New()` 就可以了。


开始今天的文章。

比如，请求 `v1/member/add` 新增会员方法，`name`、`age` 为必填，同时 `name` 不能等于 admin 字符串，10 <= age <= 120。

直接看代码吧。

首先，先定义一个结构体。

**entity/member.go**

```
package entity

// 定义 Member 结构体
type Member struct {
	Name string `form:"name" json:"name" binding:"required,NameValid"`
	Age  int    `form:"age"  json:"age"  binding:"required,gt=10,lt=120"`
}
```

binding 中 `required`，这个是框架自带的，`NameValid`，这个是自己定义的。

问题一：框架自带的 binding 参数还有哪些？

问题二：自定义验证方法，怎么写？

接下来要说的就是问题二，写一个验证方法。

**validator/member/member.go**

```
package member

import (
	"gopkg.in/go-playground/validator.v8"
	"reflect"
)

func NameValid(
	v *validator.Validate, topStruct reflect.Value, currentStructOrField reflect.Value,
	field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string,
) bool {
	if s, ok := field.Interface().(string); ok {
		if s == "admin" {
			return false
		}
	}
	return true
}
```

接下来，在路由中绑定：

**router/router.go**

```
package router

import (
	"ginDemo/middleware/logger"
	"ginDemo/middleware/sign"
	"ginDemo/router/v1"
	"ginDemo/router/v2"
	"ginDemo/validator/member"
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	"gopkg.in/go-playground/validator.v8"
)

func InitRouter(r *gin.Engine)  {

	r.Use(logger.LoggerToFile())

	// v1 版本
	GroupV1 := r.Group("/v1")
	{
		GroupV1.Any("/product/add", v1.AddProduct)
		GroupV1.Any("/member/add", v1.AddMember)
	}

	// v2 版本
	GroupV2 := r.Group("/v2").Use(sign.Sign())
	{
		GroupV2.Any("/product/add", v2.AddProduct)
		GroupV2.Any("/member/add", v2.AddMember)
	}

	// 绑定验证器
	if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
		v.RegisterValidation("NameValid", member.NameValid)
	}
}
```

最后，看一下调用的代码。

**router/v1/member.go**

```
package v1

import (
	"ginDemo/entity"
	"github.com/gin-gonic/gin"
	"net/http"
)

func AddMember(c *gin.Context) {

	res := entity.Result{}
	mem := entity.Member{}

	if err := c.ShouldBind(&mem); err != nil {
		res.SetCode(entity.CODE_ERROR)
		res.SetMessage(err.Error())
		c.JSON(http.StatusForbidden, res)
		c.Abort()
		return
	}

	// 处理业务(下次再分享)

	data := map[string]interface{}{
		"name" : mem.Name,
		"age"  : mem.Age,
	}
	res.SetCode(entity.CODE_ERROR)
	res.SetData(data)
	c.JSON(http.StatusOK, res)
}
```

访问看看效果吧。

访问：`http://localhost:8080/v1/member/add`

```
{
    "code": -1,
    "msg": "Key: 'Member.Name' Error:Field validation for 'Name' failed on the 'required' tag\nKey: 'Member.Age' Error:Field validation for 'Age' failed on the 'required' tag",
    "data": null
}
```

访问：`http://localhost:8080/v1/member/add?name=1`

```
{
    "code": -1,
    "msg": "Key: 'Member.Age' Error:Field validation for 'Age' failed on the 'required' tag",
    "data": null
}
```

访问：`http://localhost:8080/v1/member/add?age=1`

```
{
    "code": -1,
    "msg": "Key: 'Member.Age' Error:Field validation for 'Age' failed on the 'required' tag",
    "data": null
}
```

访问：`http://localhost:8080/v1/member/add?name=admin&age=1`

```
{
    "code": -1,
    "msg": "Key: 'Member.Name' Error:Field validation for 'Name' failed on the 'NameValid' tag",
    "data": null
}
```

访问：`http://localhost:8080/v1/member/add?name=1&age=1`

```
{
    "code": -1,
    "msg": "Key: 'Member.Age' Error:Field validation for 'Age' failed on the 'gt' tag",
    "data": null
}
```

访问：`http://localhost:8080/v1/member/add?name=1&age=121`

```
{
    "code": -1,
    "msg": "Key: 'Member.Age' Error:Field validation for 'Age' failed on the 'lt' tag",
    "data": null
}
```

访问：`http://localhost:8080/v1/member/add?name=Tom&age=30`

```
{
    "code": 1,
    "msg": "",
    "data": {
        "age": 30,
        "name": "Tom"
    }
}
```

未避免返回信息过多，错误提示咱们也可以统一。

```
if err := c.ShouldBind(&mem); err != nil {
	res.SetCode(entity.CODE_ERROR)
	res.SetMessage("参数验证错误")
	c.JSON(http.StatusForbidden, res)
	c.Abort()
	return
}
```

这一次目录结构调整了一些，在这里说一下：

```
├─ ginDemo
│  ├─ common        //公共方法
│     ├── common.go
│  ├─ config        //配置文件
│     ├── config.go
│  ├─ entity        //实体
│     ├── ...
│  ├─ middleware    //中间件
│     ├── logger
│         ├── ...
│     ├── sign
│         ├── ...
│  ├─ router        //路由
│     ├── ...
│  ├─ validator     //验证器
│     ├── ...
│  ├─ vendor        //扩展包
│     ├── github.com
│         ├── ...
│     ├── golang.org
│         ├── ...
│     ├── gopkg.in
│         ├── ...
│  ├─ Gopkg.toml
│  ├─ Gopkg.lock
│  ├─ main.go
```

将 `sign` 和 `logger` 调整为中间件，并放到 `middleware` 中间件 目录。

新增了 `common` 公共方法目录。 

新增了 `validator` 验证器目录。

新增了 `entity` 实体目录。

具体代码我会放到 `GitHub`，有感兴趣的可以去看：https://github.com/xinliangnote/Go

上面还遗漏了问题一没解决，框架自带的 binding 参数还有哪些？

从框架源码了解到验证使用的是：

`gopkg.in/go-playground/validator.v8`

文档地址为：

https://godoc.org/gopkg.in/go-playground/validator.v8

去探索文档吧，里面有很多验证规则。

## 源码

**下载源码后，请先执行 `dep ensure` 下载依赖包！**

[查看源码](https://github.com/xinliangnote/Go/blob/master/01-Gin框架/codes/04-数据绑定和验证)


04-数据绑定和验证

## 概述

上篇文章分享了 Gin 框架的路由配置，这篇文章分享日志记录。

查了很多资料，Go 的日志记录用的最多的还是 `github.com/sirupsen/logrus`。

> Logrus is a structured logger for Go (golang), completely API compatible with the standard library logger.

Gin 框架的日志默认只会在控制台输出，咱们利用 `Logrus` 封装一个中间件，将日志记录到文件中。

这篇文章就是学习和使用 `Logrus` 。

## 日志格式

比如，我们约定日志格式为 Text，包含字段如下：

`请求时间`、`日志级别`、`状态码`、`执行时间`、`请求IP`、`请求方式`、`请求路由`。

接下来，咱们利用 `Logrus` 实现它。

## Logrus 使用

用 `dep` 方式进行安装。

在 `Gopkg.toml` 文件新增：

```
[[constraint]]
  name = "github.com/sirupsen/logrus"
  version = "1.4.2"
```

在项目中导入：

```
import "github.com/sirupsen/logrus"
```

在项目命令行执行：

```
dep ensure
```

这时，在 `vendor/github.com/` 目录中就会看到 `sirupsen` 目录。

准备上手用了，上手之前咱们先规划一下，将这个功能设置成一个中间件，比如：`logger.go`。

日志可以记录到 File 中，定义一个 `LoggerToFile` 方法。

日志可以记录到 MongoDB 中，定义一个 `LoggerToMongo` 方法。

日志可以记录到 ES 中，定义一个 `LoggerToES` 方法。

日志可以记录到 MQ 中，定义一个 `LoggerToMQ` 方法。

...

这次咱们先实现记录到文件， 实现 `LoggerToFile` 方法，其他的可以根据自己的需求进行实现。

这个 `logger` 中间件，创建好了，可以任意在其他项目中进行迁移使用。

废话不多说，直接看代码。

```
package middleware

import (
	"fmt"
	"ginDemo/config"
	"github.com/gin-gonic/gin"
	"github.com/sirupsen/logrus"
	"os"
	"path"
	"time"
)

// 日志记录到文件
func LoggerToFile() gin.HandlerFunc {

	logFilePath := config.Log_FILE_PATH
	logFileName := config.LOG_FILE_NAME

	//日志文件
	fileName := path.Join(logFilePath, logFileName)

	//写入文件
	src, err := os.OpenFile(fileName, os.O_APPEND|os.O_WRONLY, os.ModeAppend)
	if err != nil {
		fmt.Println("err", err)
	}

	//实例化
	logger := logrus.New()

	//设置输出
	logger.Out = src

	//设置日志级别
	logger.SetLevel(logrus.DebugLevel)

	//设置日志格式
	logger.SetFormatter(&logrus.TextFormatter{})

	return func(c *gin.Context) {
		// 开始时间
		startTime := time.Now()

		// 处理请求
		c.Next()

		// 结束时间
		endTime := time.Now()

		// 执行时间
		latencyTime := endTime.Sub(startTime)

		// 请求方式
		reqMethod := c.Request.Method

		// 请求路由
		reqUri := c.Request.RequestURI

		// 状态码
		statusCode := c.Writer.Status()

		// 请求IP
		clientIP := c.ClientIP()

		// 日志格式
		logger.Infof("| %3d | %13v | %15s | %s | %s |",
			statusCode,
			latencyTime,
			clientIP,
			reqMethod,
			reqUri,
		)
	}
}

// 日志记录到 MongoDB
func LoggerToMongo() gin.HandlerFunc {
	return func(c *gin.Context) {
		
	}
}

// 日志记录到 ES
func LoggerToES() gin.HandlerFunc {
	return func(c *gin.Context) {

	}
}

// 日志记录到 MQ
func LoggerToMQ() gin.HandlerFunc {
	return func(c *gin.Context) {

	}
}
```

日志中间件写好了，怎么调用呢？

只需在 main.go 中新增：

```
engine := gin.Default() //在这行后新增
engine.Use(middleware.LoggerToFile())
```

运行一下，看看日志：

```
time="2019-07-17T22:10:45+08:00" level=info msg="| 200 |      27.698µs |             ::1 | GET | /v1/product/add?name=a&price=10 |"
time="2019-07-17T22:10:46+08:00" level=info msg="| 200 |      27.239µs |             ::1 | GET | /v1/product/add?name=a&price=10 |"
```

**这个 `time="2019-07-17T22:10:45+08:00"`  ，这个时间格式不是咱们想要的，怎么办？**

时间需要格式化一下，修改 `logger.SetFormatter`

```
//设置日志格式
logger.SetFormatter(&logrus.TextFormatter{
	TimestampFormat:"2006-01-02 15:04:05",
})
```

执行以下，再看日志：

```
time="2019-07-17 22:15:57" level=info msg="| 200 |     185.027µs |             ::1 | GET | /v1/product/add?name=a&price=10 |"
time="2019-07-17 22:15:58" level=info msg="| 200 |      56.989µs |             ::1 | GET | /v1/product/add?name=a&price=10 |"
```

时间变得正常了。

**我不喜欢文本格式，喜欢 JSON 格式，怎么办？**

```
//设置日志格式
logger.SetFormatter(&logrus.JSONFormatter{
	TimestampFormat:"2006-01-02 15:04:05",
})
```

执行以下，再看日志：

```
{"level":"info","msg":"| 200 |       24.78µs |             ::1 | GET | /v1/product/add?name=a\u0026price=10 |","time":"2019-07-17 22:23:55"}
{"level":"info","msg":"| 200 |      26.946µs |             ::1 | GET | /v1/product/add?name=a\u0026price=10 |","time":"2019-07-17 22:23:56"}
```

**msg 信息太多，不方便看，怎么办？**

```
// 日志格式
logger.WithFields(logrus.Fields{
	"status_code"  : statusCode,
	"latency_time" : latencyTime,
	"client_ip"    : clientIP,
	"req_method"   : reqMethod,
	"req_uri"      : reqUri,
}).Info()
```

执行以下，再看日志：

```
{"client_ip":"::1","latency_time":26681,"level":"info","msg":"","req_method":"GET","req_uri":"/v1/product/add?name=a\u0026price=10","status_code":200,"time":"2019-07-17 22:37:54"}
{"client_ip":"::1","latency_time":24315,"level":"info","msg":"","req_method":"GET","req_uri":"/v1/product/add?name=a\u0026price=10","status_code":200,"time":"2019-07-17 22:37:55"}
```

说明一下：`time`、`msg`、`level` 这些参数是 logrus 自动加上的。

**logrus 支持输出文件名和行号吗？**

不支持，作者的回复是太耗性能。

不过网上也有人通过 Hook 的方式实现了，选择在生产环境使用的时候，记得做性能测试。

**logrus 支持日志分割吗？**

不支持，但有办法实现它。

1、可以利用 `Linux logrotate`，统一由运维进行处理。

2、可以利用 `file-rotatelogs` 实现。

需要导入包：

`github.com/lestrrat-go/file-rotatelogs`

`github.com/rifflock/lfshook`

奉上完整代码：

```
package middleware

import (
	"fmt"
	"ginDemo/config"
	"github.com/gin-gonic/gin"
	rotatelogs "github.com/lestrrat-go/file-rotatelogs"
	"github.com/rifflock/lfshook"
	"github.com/sirupsen/logrus"
	"os"
	"path"
	"time"
)

// 日志记录到文件
func LoggerToFile() gin.HandlerFunc {

	logFilePath := config.Log_FILE_PATH
	logFileName := config.LOG_FILE_NAME

	// 日志文件
	fileName := path.Join(logFilePath, logFileName)

	// 写入文件
	src, err := os.OpenFile(fileName, os.O_APPEND|os.O_WRONLY, os.ModeAppend)
	if err != nil {
		fmt.Println("err", err)
	}

	// 实例化
	logger := logrus.New()

	// 设置输出
	logger.Out = src

	// 设置日志级别
	logger.SetLevel(logrus.DebugLevel)

	// 设置 rotatelogs
	logWriter, err := rotatelogs.New(
		// 分割后的文件名称
		fileName + ".%Y%m%d.log",

		// 生成软链，指向最新日志文件
		rotatelogs.WithLinkName(fileName),

		// 设置最大保存时间(7天)
		rotatelogs.WithMaxAge(7*24*time.Hour),

		// 设置日志切割时间间隔(1天)
		rotatelogs.WithRotationTime(24*time.Hour),
	)

	writeMap := lfshook.WriterMap{
		logrus.InfoLevel:  logWriter,
		logrus.FatalLevel: logWriter,
		logrus.DebugLevel: logWriter,
		logrus.WarnLevel:  logWriter,
		logrus.ErrorLevel: logWriter,
		logrus.PanicLevel: logWriter,
	}
	
	lfHook := lfshook.NewHook(writeMap, &logrus.JSONFormatter{
		TimestampFormat:"2006-01-02 15:04:05",
	})

	// 新增 Hook
	logger.AddHook(lfHook)

	return func(c *gin.Context) {
		// 开始时间
		startTime := time.Now()

		// 处理请求
		c.Next()

		// 结束时间
		endTime := time.Now()

		// 执行时间
		latencyTime := endTime.Sub(startTime)

		// 请求方式
		reqMethod := c.Request.Method

		// 请求路由
		reqUri := c.Request.RequestURI

		// 状态码
		statusCode := c.Writer.Status()

		// 请求IP
		clientIP := c.ClientIP()

		// 日志格式
		logger.WithFields(logrus.Fields{
			"status_code"  : statusCode,
			"latency_time" : latencyTime,
			"client_ip"    : clientIP,
			"req_method"   : reqMethod,
			"req_uri"      : reqUri,
		}).Info()
	}
}

// 日志记录到 MongoDB
func LoggerToMongo() gin.HandlerFunc {
	return func(c *gin.Context) {
		
	}
}

// 日志记录到 ES
func LoggerToES() gin.HandlerFunc {
	return func(c *gin.Context) {

	}
}

// 日志记录到 MQ
func LoggerToMQ() gin.HandlerFunc {
	return func(c *gin.Context) {

	}
}
```

这时会新生成一个文件 `system.log.20190717.log`，日志内容与上面的格式一致。

最后，`logrus` 可扩展的 Hook 很多，大家可以去网上查找。

## 源码

**下载源码后，请先执行 `dep ensure` 下载依赖包！**

[查看源码](https://github.com/xinliangnote/Go/blob/master/01-Gin框架/codes/03-日志记录)


03-日志记录

## 概述

这篇文章分享 Gin 的路由配置，主要包含的功能点如下：

- 实现了，路由分组 v1版本、v2版本。
- 实现了，生成签名和验证验证。
- 实现了，在配置文件中读取配置。



![2_go_1.png](https://blog.sudoeasy.com/static/img/143d18ea72b992d9e11397d859f2c1bc.2_go_1.png)

![2_go_2.png](https://blog.sudoeasy.com/static/img/a3fbe223d403903af21f1bc12238309f.2_go_2.png)

![2_go_3.png](https://blog.sudoeasy.com/static/img/e677ddbd57e6a6c88bc16812dd8637ac.2_go_3.png)

![2_go_4.png](https://blog.sudoeasy.com/static/img/da4c98ee410f994a25354c39a28c845f.2_go_4.png)
## 路由配置

比如我们的接口地址是这样的：

- `/v1/product/add`
- `/v1/member/add`
- `/v2/product/add`
- `/v2/member/add`

假设需求是这样的，接口支持多种请求方式，v1 不需签名验证，v2 需要签名验证，路由文件应该这样写：

```
package router

import (
	"ginDemo/common"
	"ginDemo/controller/v1"
	"ginDemo/controller/v2"
	"github.com/gin-gonic/gin"
	"net/url"
	"strconv"
)

func InitRouter(r *gin.Engine)  {

	r.GET("/sn", SignDemo)

	// v1 版本
	GroupV1 := r.Group("/v1")
	{
		GroupV1.Any("/product/add", v1.AddProduct)
		GroupV1.Any("/member/add", v1.AddMember)
	}

	// v2 版本
	GroupV2 := r.Group("/v2", common.VerifySign)
	{
		GroupV2.Any("/product/add", v2.AddProduct)
		GroupV2.Any("/member/add", v2.AddMember)
	}
}

func SignDemo(c *gin.Context) {
	ts := strconv.FormatInt(common.GetTimeUnix(), 10)
	res := map[string]interface{}{}
	params := url.Values{
		"name"  : []string{"a"},
		"price" : []string{"10"},
		"ts"    : []string{ts},
	}
	res["sn"] = common.CreateSign(params)
	res["ts"] = ts
	common.RetJson("200", "", res, c)
}
```

`.Any` 表示支持多种请求方式。

`controller/v1` 表示 v1 版本的文件。

`controller/v2` 表示 v2 版本的文件。

`SignDemo` 表示生成签名的Demo。

接下来，给出一些代码片段：

验证签名方法：

```
// 验证签名
func VerifySign(c *gin.Context) {
	var method = c.Request.Method
	var ts int64
	var sn string
	var req url.Values

	if method == "GET" {
		req = c.Request.URL.Query()
		sn = c.Query("sn")
		ts, _  = strconv.ParseInt(c.Query("ts"), 10, 64)

	} else if method == "POST" {
		req = c.Request.PostForm
		sn = c.PostForm("sn")
		ts, _  = strconv.ParseInt(c.PostForm("ts"), 10, 64)
	} else {
		RetJson("500", "Illegal requests", "", c)
		return
	}

	exp, _ := strconv.ParseInt(config.API_EXPIRY, 10, 64)

	// 验证过期时间
	if ts > GetTimeUnix() || GetTimeUnix() - ts >= exp {
		RetJson("500", "Ts Error", "", c)
		return
	}

	// 验证签名
	if sn == "" || sn != CreateSign(req) {
		RetJson("500", "Sn Error", "", c)
		return
	}
}
```

生成签名的方法：

```
// 生成签名
func CreateSign(params url.Values) string {
	var key []string
	var str = ""
	for k := range params {
		if k != "sn" {
			key = append(key, k)
		}
	}
	sort.Strings(key)
	for i := 0; i < len(key); i++ {
		if i == 0 {
			str = fmt.Sprintf("%v=%v", key[i], params.Get(key[i]))
		} else {
			str = str + fmt.Sprintf("&%v=%v", key[i], params.Get(key[i]))
		}
	}
	// 自定义签名算法
	sign := MD5(MD5(str) + MD5(config.APP_NAME + config.APP_SECRET))
	return sign
}
```

获取参数的方法：

```
// 获取 Get 参数
name := c.Query("name")
price := c.DefaultQuery("price", "100")

// 获取 Post 参数
name := c.PostForm("name")
price := c.DefaultPostForm("price", "100")

// 获取 Get 所有参数
ReqGet = c.Request.URL.Query()

//获取 Post 所有参数
ReqPost = c.Request.PostForm
```

v1 业务代码：

```
package v1

import "github.com/gin-gonic/gin"

func AddProduct(c *gin.Context)  {
	// 获取 Get 参数
	name  := c.Query("name")
	price := c.DefaultQuery("price", "100")

	c.JSON(200, gin.H{
		"v1"    : "AddProduct",
		"name"  : name,
		"price" : price,
	})
}
```

v2 业务代码：

```
package v2

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

func AddProduct(c *gin.Context)  {
	// 获取 Get 参数
	name  := c.Query("name")
	price := c.DefaultQuery("price", "100")

	c.JSON(200, gin.H{
		"v1"    : "AddProduct",
		"name"  : name,
		"price" : price,
	})
}

```

接下来，直接看效果吧。

访问 v1 接口：

![](https://github.com/xinliangnote/Go/blob/master/01-Gin框架/images/02-路由配置/2_go_1.png)

访问后，直接返回数据，不走签名验证。

访问 v2 接口：

![](https://github.com/xinliangnote/Go/blob/master/01-Gin框架/images/02-路由配置/2_go_2.png)

进入了这段验证：

```
// 验证过期时间
if ts > GetTimeUnix() || GetTimeUnix() - ts >= exp {
	RetJson("500", "Ts Error", "", c)
	return
}
```

修改为合法的时间戳后：

![](https://github.com/xinliangnote/Go/blob/master/01-Gin框架/images/02-路由配置/2_go_3.png)

进入了这段验证：

```
// 验证签名
if sn == "" || sn != CreateSign(req) {
	RetJson("500", "Sn Error", "", c)
	return
}
```

修改为合法的签名后：

![](https://github.com/xinliangnote/Go/blob/master/01-Gin框架/images/02-路由配置/2_go_4.png)

至此，简单的路由配置已经实现了。

对了，还有一个点没说，就是如何读取配置文件中的配置，我是这样做的：

```
package config

const (
	PORT       = ":8080"
	APP_NAME   = "ginDemo"
	APP_SECRET = "6YJSuc50uJ18zj45"
	API_EXPIRY = "120"
)
```

引入 config 包，直接 `config.xx` 即可。

## 源码

**下载源码后，请先执行 `dep ensure` 下载依赖包！**

[查看源码](https://github.com/xinliangnote/Go/blob/master/01-Gin框架/codes/02-路由配置)

02-路由配置

## 概述

看下 Gin 框架的官方介绍：

> Gin 是一个用 Go (Golang) 编写的 web 框架。 它是一个类似于 martini 但拥有更好性能的 API 框架, 由于 httprouter，速度提高了近 40 倍。 如果你是性能和高效的追求者, 你会爱上 Gin。

是的，就是用 Gin 来写 API 接口。

![1_api_1.png](https://blog.sudoeasy.com/static/img/3f8d698683cc017f7c85ad56dc6c7e15.1_api_1.png)
## Gin 安装

必须要先安装 Go，Go 的安装可以参考：[Go - 环境安装](https://mp.weixin.qq.com/s/ByhEuCncxcXvq7am7D4IPg)。

框架安装可以参考官网：

https://gin-gonic.com/zh-cn/docs/quickstart/

我在安装时，用的是 dep 安装，给大家分享下。

**dep 是啥 ？**





它是 Golang 官方依赖管理工具，可以认为它与 PHP 中的 composer 类似。

在这就不多做介绍了，可以自己去了解，安装也比较简单。

我本机是 Mac，安装只需一个命令：

```
brew install dep
```

咱们接下来创建一个新项目：ginDemo。

在 ginDemo 目录下执行：

```
dep init
```

执行完毕，会生成如下三个文件：

```
├─ ginDemo
│  ├─ vendor
│  ├─ Gopkg.toml
│  ├─ Gopkg.lock
```

- 依赖包都会下载到 `vendor` 目录。
- 需要的依赖配置写在 `Gopkg.toml` 文件。
- `Gopkg.lock` 暂时可以不用管。

在 `Gopkg.toml` 文件中增加依赖：

```
[[constraint]]
  name = "github.com/gin-gonic/gin"
  version = "1.4.0"
```

新增一个 main.go 文件：

```
// 官方 Demo
package main

import "github.com/gin-gonic/gin"

func main() {
	r := gin.Default()
	r.GET("/ping", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "pong",
		})
	})
	r.Run() // listen and serve on 0.0.0.0:8080
}
```

ginDemo 目录下执行：

```
dep ensure
```

执行完毕，`vendor` 目录会存在安装包，这时整体目录结构如下：

```
├─ ginDemo
│  ├─ vendor
│     ├── github.com
│         ├── ...
│     ├── golang.org
│         ├── ...
│     ├── gopkg.in
│         ├── ...
│  ├─ Gopkg.toml
│  ├─ Gopkg.lock
│  ├─ main.go
```

ginDemo 目录下执行：

```
go run main.go
```

浏览器访问：`http://localhost:8080/ping`

![](https://github.com/xinliangnote/Go/blob/master/01-Gin框架/images/01-框架安装/1_go_1.png)

大功告成！

01-框架安装

## prometheus热重启

prometheus启动命令添加参数 --web.enable-lifecycle

然后热重启：curl -XPOST http://localhost:9090/-/reload 

 



 

## alertmanager热重启

curl -XPOST http://localhost:9093/-/reload