01-Gin框架路由

一：相关链接：

• 官方文档： https://github.com/gin-gonic/gin
• 中文翻译教程：https://www.topgoer.com/gin%E6%A1%86%E6%9E%B6/%E7%AE%80%E4%BB%8B.html

二：Gin安装

• 下载包， 切换国内源。
  • export GO111MODULE=on
  • export GOPROXY=https://goproxy.cn,direct
• 下载Gin：
  • go get -u github.com/gin-gonic/gin
• 注意： 安装完后， GOLand还是出现导入包报错， 则重新启动GoLand即可。
• 重启后， 查看go.mod的中是否有了该依赖, 没有则加上。

require github.com/gin-gonic/gin v1.8.1
1

三：Gin简单案例

• 1: 创建路由
• 2: 编写路由
• 3: 启动WEB
• 注意： 启动的时候，必须处理异常。

package main

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"net/http"
)

func helloWord(c *gin.Context) {
	// 返回一个字符串
	c.String(http.StatusOK, "hello World!")
}

func main() {
	// 1: 创建路由
	router := gin.Default()

	// 2: 编写路由
	router.GET("/", helloWord)

	// 3: 启动WEB
	err := router.Run(":8080")
	if err != nil {
		fmt.Printf("server start fail, err msg is %s\n", err)
	}
}

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

四：路由

路由拆分到某个文件中

• 当前的目录结构：

.
├── go.mod
├── go.sum
├── main.go // 主运行
└── routers.go  // 路由（路由函数 + 路由设置器）
1
2
3
4
5

• 主运行文件

package main

import (
	"fmt"
)

func main() {
	// 实例化路由设置器
	router := setupRouter()
	// 启动
	err := router.Run(":8080")
	if err != nil {
		fmt.Printf("server start fail, err msg is %s\n", err)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 路由文件

package main

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

func hello(c *gin.Context) {
	// 返回一个字符串
	c.String(http.StatusOK, "hello")
}

func word(c *gin.Context) {
	// 返回一个字符串
	c.String(http.StatusOK, "World")
}

func setupRouter() *gin.Engine {
	// 路由设置器
	router := gin.Default()
	router.GET("/hello", hello)
	router.GET("/word", word)
	return router
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

路由拆分到某个包中

• 结构

.
├── go.mod
├── go.sum
├── main.go
└── routers
    └── routers.go
1
2
3
4
5
6

• 修改的地方：
  • SetupRouter名称中的S要大写了。（固定写法）

路由拆分到多个文件中

• 结构

.
├── go.mod
├── go.sum
├── main.go
└── routers
    ├── animal.go
    └── people.go

1
2
3
4
5
6
7
8

• people.go

package routers

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

func helloPeople(c *gin.Context) {
	// 返回一个字符串
	c.String(http.StatusOK, "hello People!")
}

func LoadPeople(engine *gin.Engine) {
	engine.GET("/people/hello", helloPeople)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• main.go

package main

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"learn_gin/routers"
)

func main() {
	// 实例化路由设置器
	router := gin.Default()
	// 将路由加载器注册到路由中
	routers.LoadPeople(router)
	routers.LoadAnimal(router)
	// 启动
	err := router.Run(":8080")
	if err != nil {
		fmt.Printf("server start fail, err msg is %s\n", err)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

• 缺点：
  • 将路由加载器注册到路由中， 一行写一个， 玩意有20个模块就需要写20行。
  • 调整： 初始化一个加载器切片， 循环将加载器注册到路由中。

package main

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"learn_gin/routers"
)

func loderRegisteRouter(loadList []func(engine *gin.Engine), router *gin.Engine) {
	for _, routerLoadFunc := range loadList {
		routerLoadFunc(router)
	}
}

func main() {
	// 实例化路由设置器
	router := gin.Default()
	// 定义一个路由加载器切片
	routerLoadFunc := []func(engine *gin.Engine){
		routers.LoadPeople,
		routers.LoadAnimal,
	}
	// 将加载器全部注册到路由中
	loderRegisteRouter(routerLoadFunc, router)
	// 启动
	err := router.Run(":8080")
	if err != nil {
		fmt.Printf("server start fail, err msg is %s\n", err)
	}
}
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

根据APP拆分路由

• 结构

.
├── app
│   ├── animal
│   │   ├── handler.go
│   │   └── router.go
│   └── people
│       ├── handler.go
│       └── router.go
├── go.mod
├── go.sum
├── main.go
└── routers
    └── routers.go
1
2
3
4
5
6
7
8
9
10
11
12
13

• handler，用来编写核心处理逻辑

package animal

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

func helloAnimal(c *gin.Context) {
	// 返回一个字符串
	c.String(http.StatusOK, "hello Animal!")
}

func loveAnimalc(c *gin.Context) {
	// 返回一个字符串
	c.String(http.StatusOK, "love Animal!")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• router编写子路由

package animal

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

func Routers(e *gin.Engine) {
	e.GET("/animal/hello", helloAnimal)
	e.GET("/animal/love", loveAnimalc)
}

1
2
3
4
5
6
7
8
9

• router/routers 初始化引擎， 并将路由注册到引擎中。

package routers

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

type Option func(*gin.Engine)

var options []Option

// Include 将APP中的路由放入options切片中
func Include(opts ...Option) {
	options = append(options, opts...)
}

// Init 初始化引擎， 并将路由注册到引擎中
func Init() *gin.Engine {
	engine := gin.Default()
	for _, opt := range options {
		opt(engine)
	}
	return engine
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

• main 调度

package main

import (
	"fmt"
	"learn_gin/app/animal"
	"learn_gin/app/people"
	"learn_gin/routers"
)

func main() {
	// 加载多个APP的路由配置
	routers.Include(people.Routers, animal.Routers)
	// 初始化路由
	r := routers.Init()
	if err := r.Run(); err != nil {
		fmt.Println("startup service failed, err:%v\n", err)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19