golang微框架Gin
Gin简介
Gin是一个golang的微框架，基于httprouter，封装比较优雅，API友好，源码注释比较明确，具有快速灵活，容错方便等特点
Gin特征
速度快：基于基数树的路由，内存占用小，没有反射，可预测的APi性能
中间件支持
传入的http请求可以有中间件链和最终操作处理，例如：Logger，Authorization，GZip最后在Db中发布以条消息
Crash-free
Gin可以捕获Http请求期间发生的panic并恢复它，这样你的服务器始终都可用
JSON验证
Gin可以解析和验证请求的JSON——例如，检查所需的值是否存在
路由分组
更好的组织您的路线，需要授权与不需要授权，不同的API版本，此外，组可以无限嵌套，而不会降低性能
错误管理
Gin提供了一种方便的方法用来收集HTTP请求期间发生的所有错误，最终 ，中间件可以将它们写入日志，数据并通过网络发送他们
内置渲染
GIn为JSon，XML，HTML渲染提供了简单易用·的API
可扩展
创建一个新的中间件非常简单，只需要查看实例代码就可以
第一个Gin
安装Gin
go get -u github.com/gin-gonic/gin
导入项目
import "github.com/gin-gonic/gin"
实现代码
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
}
Gin实现用户登录
实现步骤
创建一个文件templates
在项目根目录下边创建文件夹templtes，用来保存静态文件
创建一个登录的html文件
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Login</title>
</head>
<body>
<form action="/login" method="post">
Username: <input type="text" name="username"><br>
Password: <input type="password" name="password"><br>
<input type="submit" value="Login">
</form>
</body>
</html>
创建一个欢迎html页面
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Welcome</title>
</head>
<body>
Welcome, {{.username}}
</body>
</html>
使用Gin处理逻辑
package main
import "github.com/gin-gonic/gin"
func MyHandler(c *gin.Context) {
c.JSON(200, gin.H{
"hello": "hello world",
})
}
func Login(c *gin.Context) {
c.HTML(200, "login.html", nil)
}
func DoLogin(c *gin.Context) {
username := c.PostForm("username")
password := c.PostForm("password")
c.HTML(200, "welcome.html", gin.H{
"username": username,
"password": password,
})
}
func main() {
e := gin.Default()
e.LoadHTMLGlob("templates/*")
e.GET("/login", Login)
e.POST("/login", DoLogin)
e.Run()
}
使用Gin请求参数
Get请求参数
使用c.Query(“key”),或者c.DefaultQuery（”key”）方法
package main
import "github.com/gin-gonic/gin"
func TestQueryString(c *gin.Context) {
username := c.Query("username")
site := c.DefaultQuery("site", "www.duoke360.com")
c.String(200, "username:%s, site:%s", username, site)
}
func main() {
e := gin.Default()
// url : http://localhost:8080/testQueryString?username=郭宏志&site=多课网
e.GET("/testQueryString", TestQueryString)
e.Run()
}
Gin数据绑定
绑定Form表单
package main
import (
"github.com/gin-gonic/gin"
)
type User struct {
Username string `form:"username"`
Password string `form:"password"`
Hobby []string `form:"hobby"`
Gender string `form:"gender"`
City string `form:"city"`
}
func Regsiter(c *gin.Context) {
var user User
c.ShouldBind(&user)
c.String(200, "User:%s", user)
}
func GoRegister(c *gin.Context) {
c.HTML(200, "register.html", nil)
}
func main() {
e := gin.Default()
e.LoadHTMLGlob("templates/*")
e.POST("/register", Regsiter)
e.GET("/register", GoRegister)
e.Run()
}
绑定查询参数
package main
import (
"log"
"github.com/gin-gonic/gin"
)
type User struct {
Username string `form:"username"`
Password string `form:"password"`
}
func TestGetBind(c *gin.Context) {
var user User
err := c.ShouldBind(&user)
if err != nil {
log.Fatal(err)
}
c.String(200, "User:%s", user)
}
func main() {
e := gin.Default()
// http://localhost:8080/testGetBind?username=ghz&password=123
e.GET("/testGetBind", TestGetBind)
e.Run()
}
绑定路径请求参数
package main
import (
"log"
"github.com/gin-gonic/gin"
)
type User struct {
Username string `uri:"username"`
Password string `uri:"password"`
}
func TestGetBind(c *gin.Context) {
var user User
err := c.ShouldBindUri(&user)
if err != nil {
log.Fatal(err)
}
c.String(200, "User:%s", user)
}
func main() {
e := gin.Default()
// http://localhost:8080/testGetBind/ghz/123
e.GET("/testGetBind/:username/:password", TestGetBind)
e.Run()
}
GIN 访问静态文件集成BootStrap框架
下载bootstrap
下载地址：
https://getbootstrap.com/
添加bootstrap css 和js 文件
创建一个assets文件夹 将 css和js文件添加到该文件夹中
创建html文件
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="stylesheet" href="/assets/css/bootstrap.min.css">
<title>Login</title>
</head>
<body>
<div class="container">
<form>
<div class="mb-3">
<label for="exampleInputEmail1" class="form-label">Email address</label>
<input type="email" class="form-control" id="exampleInputEmail1" aria-describedby="emailHelp">
<div id="emailHelp" class="form-text">We'll never share your email with anyone else.</div>
</div>
<div class="mb-3">
<label for="exampleInputPassword1" class="form-label">Password</label>
<input type="password" class="form-control" id="exampleInputPassword1">
</div>
<div class="mb-3 form-check">
<input type="checkbox" class="form-check-input" id="exampleCheck1">
<label class="form-check-label" for="exampleCheck1">Check me out</label>
</div>
<button type="submit" class="btn btn-primary">Submit</button>
</form>
</div>
</body>
</html>
go code
package main
import (
"net/http"
"github.com/gin-gonic/gin"
)
func Login(c *gin.Context) {
c.HTML(200, "login.html", nil)
}
func main() {
e := gin.Default()
e.LoadHTMLGlob("templates/*")
e.Static("/assets", "./assets")
e.StaticFS("/croot", http.Dir("c:/"))
e.StaticFile("/favicon.ico", "./assets/favicon.ico")
e.GET("/login", Login)
e.POST("/login", DoLogin)
e.Run()
}
Gin使用中间件
中间件听起来非常高大上的名字，实际上非常简单，就是在请求中间其拦截作用的处理函数
Gin默认中间件
如果你使用Gin.Default实例化gin引擎，默认有俩个中间件，LOgger和Recover，分别用来处理日志和处理错误，如果使用Gin.New需要重新添加
// 新建一个没有任何默认中间件的路由
r := gin.New()
// 全局中间件
// Logger 中间件将日志写入 gin.DefaultWriter，即使你将 GIN_MODE 设置为 release。
// By default gin.DefaultWriter = os.Stdout
r.Use(gin.Logger())
// Recovery 中间件会 recover 任何 panic。如果有 panic 的话，会写入 500。
r.Use(gin.Recovery())
自定义中间件
1.自定义中间件非常简单，定义一个符合下边格式的处理函数
type HandlerFunc func(*Context)
2.使用Use方法调用
package main
import (
"fmt"
"github.com/gin-gonic/gin"
)
func TestMW(c *gin.Context) {
c.String(200, "hello,%s", "ghz")
}
func MyMiddleware1(c *gin.Context) {
fmt.Println("我的第一个中间件")
}
func MyMiddleware2(c *gin.Context) {
fmt.Println("我的第二个中间件")
}
func main() {
/* func Default() *Engine {
debugPrintWARNINGDefault()
engine := New()
engine.Use(Logger(), Recovery())
return engine
} */
// e := gin.Default()
// e := gin.New()
e := gin.Default()
e.Use(MyMiddleware1, MyMiddleware2)
e.GET("testmw", TestMW)
e.Run()
}
使用Gin BasicAuth中间件
Gin提供了BasicAuth的中间件，用来对网络资源的访问保护
实例：
package main
import (
"fmt"
"net/http"
"github.com/gin-gonic/gin"
)
// 模拟一些私人数据
var secrets = gin.H{
"foo": gin.H{"email": "[email protected]", "phone": "123433"},
"austin": gin.H{"email": "[email protected]", "phone": "666"},
"lena": gin.H{"email": "[email protected]", "phone": "523443"},
}
func main() {
r := gin.Default()
// 路由组使用 gin.BasicAuth() 中间件
// gin.Accounts 是 map[string]string 的一种快捷方式
authorized := r.Group("/admin", gin.BasicAuth(gin.Accounts{
"foo": "bar",
"austin": "1234",
"lena": "hello2",
"manu": "4321",
}))
// /admin/secrets 端点
// 触发 "localhost:8080/admin/secrets
authorized.GET("/secrets", func(c *gin.Context) {
// 获取用户，它是由 BasicAuth 中间件设置的
user := c.MustGet(gin.AuthUserKey).(string)
fmt.Println(user)
if secret, ok := secrets[user]; ok {
c.JSON(http.StatusOK, gin.H{"user": user, "secret": secret})
} else {
c.JSON(http.StatusOK, gin.H{"user": user, "secret": "NO SECRET :("})
}
})
// 监听并在 0.0.0.0:8080 上启动服务
r.Run(":8080")
}
测试
在浏览器中输入localhost:8080/admin/secrets时，会弹出一个对话框，要求输入正确的用户名和密码，才能访问资源。
Gin cookie的使用
cookie是服务器向客户端写的一些数据，可以实现像自动登陆等功能
Gin cookie的使用
package main
import "github.com/gin-gonic/gin"
func Handler(c *gin.Context) {
// 获得cookie
s, err := c.Cookie("username")
if err != nil {
s = "ghz"
// 设置cookie
c.SetCookie("username", s, 60*60, "/", "localhost", false, true)
}
c.String(200, "测试cookie")
}
func main() {
e := gin.Default()
e.GET("/test", Handler)
e.Run()
}
Gin使用session
因为http是无状态短连接 ，如何保存客户端和服务器直接的会话状态呢？可以使用session
使用gin session中间件
gin本身没有对session的支持，可以使用第三方中间件
go get github.com/gin-contrib/sessions
import "github.com/gin-contrib/sessions"
该中间件提更了很多后端支持：
cookie-based
redis
memcached
MongoDB
memstore
PostgreSQL
实例：
package main
import (
"github.com/gin-contrib/sessions"
"github.com/gin-contrib/sessions/cookie"
"github.com/gin-gonic/gin"
)
func main() {
r := gin.Default()
store := cookie.NewStore([]byte("secret"))
r.Use(sessions.Sessions("mysession", store))
r.GET("/hello", func(c *gin.Context) {
session := sessions.Default(c)
if session.Get("hello") != "world" {
session.Set("hello", "world")
session.Save()
}
c.JSON(200, gin.H{"hello": session.Get("hello")})
})
r.Run(":8000")
}
Gin实现restful风格的CURD
package main
import (
"fmt"
"strconv"
"github.com/gin-gonic/gin"
)
type User struct {
UId int `json:"uid"`
Name string `json:"name"`
Age int `json:"age"`
}
var users = make([]User, 3)
func init() {
u1 := User{1, "tom", 20}
u2 := User{2, "kite", 30}
u3 := User{3, "rose", 40}
users = append(users, u1)
users = append(users, u2)
users = append(users, u3)
fmt.Println(users)
}
func find(uid int) (*User, int) {
for i, u := range users {
if u.UId == uid {
return &u, i
}
}
return nil, -1
}
func AddUser(c *gin.Context) {
u4 := User{4, "Joe", 50}
users = append(users, u4)
c.JSON(200, users)
}
func DelUser(c *gin.Context) {
uid := c.Param("uid")
id, _ := strconv.Atoi(uid)
_, i := find(id)
users = append(users[:i], users[i+1:]...)
c.JSON(200, users)
}
func UpdateUser(c *gin.Context) {
uid := c.Param("uid")
id, _ := strconv.Atoi(uid)
u, _ := find(id)
u.Name = "修改的Name"
c.JSON(200, u)
}
func FindUser(c *gin.Context) {
uid := c.Param("uid")
id, _ := strconv.Atoi(uid)
u, _ := find(id)
c.JSON(200, u)
}
func main() {
e := gin.Default()
e.GET("/user/:uid", FindUser)
e.PUT("/user/:uid", UpdateUser)
e.DELETE("/user/:uid", DelUser)
e.POST("/user/", AddUser)
e.Run()
}
Gin实现路由分组
假如你的网站上有很多个模块：博客，教程，视频，回答，每个模块又有很多个路由，这样就可以进行路由分组，使用的方法是router.Group（“分组名称”）
package main
import "github.com/gin-gonic/gin"
func F1(c *gin.Context) {}
func F2(c *gin.Context) {}
func F3(c *gin.Context) {}
func F4(c *gin.Context) {}
func F5(c *gin.Context) {}
func F6(c *gin.Context) {}
func main() {
router := gin.Default()
// 博客
// 访问：http://localhost:8080/blog/list
v1 := router.Group("/blog")
{
v1.POST("/list", F1)
v1.POST("/post", F2)
v1.POST("/add", F3)
}
// 视频
// 访问：http://localhost:8080/video/list
v2 := router.Group("/video")
{
v2.POST("/list", F4)
v2.POST("/post", F5)
v2.POST("/add", F6)
}
router.Run(":8080")
}
Gin输出渲染
Gin支持很多种输出渲染，可以是简单的字符串，Json，xml，html，protoBuf。使用的方法如下：
c.JSON(200, nil)
c.XML(200, nil)
c.HTML(200, "", nil)
c.String(200, "")
c.ProtoBuf(200, nil)
这里像字符串，json，html我们都用过，这里我们再总结一下：
package main
import "github.com/gin-gonic/gin"
func TestJson(c *gin.Context) {
c.JSON(200, gin.H{
"name": "多课网",
"site": "www.duoke360.com",
})
}
func TestXML(c *gin.Context) {
c.XML(200, gin.H{
"name": "多课网",
"site": "www.duoke360.com",
})
}
func TestHtml(c *gin.Context) {
c.HTML(200, "login.html", nil)
}
func TestString(c *gin.Context) {
c.String(200, "多课网，老郭讲golang")
}
func main() {
e := gin.Default()
e.GET("/test_json", TestJson)
e.GET("/test_xml", TestXML)
e.LoadHTMLGlob("templates/*")
e.GET("/test_html", TestHtml)
e.GET("/test_string", TestString)
> 这里是引用
e.Run()
}
Gin实现文件上传
创建xml文件
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<form action="/upload" method="post" enctype="multipart/form-data">
请选择上传文件：<input type="file" name="file" id=""><br>
<input type="submit" value="上传">
</form>
</body>
</html>
Go code
package main
import (
"fmt"
"log"
"net/http"
"github.com/gin-gonic/gin"
)
func Upload(c *gin.Context) {
// 单文件
file, _ := c.FormFile("file")
log.Println(file.Filename)
// 上传文件到项目根目录，使用原文件名
c.SaveUploadedFile(file, file.Filename)
c.String(http.StatusOK, fmt.Sprintf("'%s' uploaded!", file.Filename))
}
func GoUpload(c *gin.Context) {
c.HTML(200, "upload.html", nil)
}
func main() {
router := gin.Default()
// 为 multipart forms 设置较低的内存限制 (默认是 32 MiB)
router.MaxMultipartMemory = 8 << 20 // 8 MiB
router.LoadHTMLGlob("templates/*")
router.GET("/upload", GoUpload)
router.POST("/upload", Upload)
router.Run(":8080")
}