Web framework-Gin(二)

已于 2023-09-18 23:48:28 修改
阅读量1.1k 收藏 1
点赞数 1
文章标签： gin
于 2023-09-03 22:44:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42472027/article/details/132651165
版权

目录

一、Gin

1、Ajax

2、文件上传

2.1、form表单中文件上传(单个文件)

2.2、form表单中文件上传(多个文件)

2.3、ajax上传单个文件

2.4、ajax上传多个文件

3、模板语法

4、数据绑定

4.1、表单数据的绑定

4.2、路径中参数的绑定

4.3、JSON数据的绑定

4.4、URI数据的绑定

5、路由组

路由组抽取

6、中间件

6.1、自定义中间件

6.2、中间件链

6.3、终止中间件

6.4、中间件的作用域

一、Gin

1、Ajax

        AJAX 即“Asynchronous Javascript And XML”（异步 JavaScript和 XML），是指一种创建交互式、快速动态网页应用的网页开发技术，无需重新加载整个网页的情况下，能够更新部分网页的技术。通过在后台与服务器进行少量数据交换，AJAX 可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行更新。

        AJAX的最大的特点： 异步访问，局部刷新。

案例：Ajax之验证用户名是否被占用

main.go

func main() {
	r := gin.Default()
	r.LoadHTMLGlob("part02/templates/**/*")
	//指定js文件：
	r.Static("/s", "part02/static")
	r.GET("/test1", myfunc.Test1)
	r.POST("/getUserInfo", myfunc.Test2)
	r.POST("/ajaxpost", myfunc.Test3)
	r.Run()
}

myfunc.go

func Test1(context *gin.Context) {
	context.HTML(200, "demo01/hello01.html", nil)
}

func Test3(context *gin.Context) {
	//获取post-ajax请求的数据，获取对应的参数：
	uname := context.PostForm("uname")
	fmt.Println(uname)
	fmt.Println(uname == "丽丽")
	if uname == "丽丽" {
		context.JSON(200, gin.H{
			"msg": "用户名重复了！",
		})
	} else {
		context.JSON(200, gin.H{
			"msg": "",
		})
	}
}

hello01.html  注意：引入jQuery.min.js

{{define "demo01/hello01.html"}}
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <link rel="stylesheet" href="/s/css/mycss.css">
    <script src="/s/js/jQuery.min.js"></script>
</head>
<body>
    用户form表单<br>
    <form action="/getUserInfo" method="post">
        用户名：<input type="text" name="username" id="uname"><span id="errmsg"></span><br>
        密码：<input type="password" name="pwd">
        <input type="submit" value="提交">
    </form>

    <script>
        //获取用户名的文本框
        var unametext = document.getElementById("uname");
        //给文本框绑定一个事件：失去焦点的时候会触发后面的函数的事件
        unametext.onblur = function () {
            //获取文本框的内容：
            var uname = unametext.value;
            //alert(uname)可以弹出数据，验证代码的正确性
            //局部刷新：通过ajax技术来实现数据的校验 ---》 后台 ：异步访问，局部刷新
            //调用ajax方法需要传入json格式的数据： $.ajax({属性名:属性值,属性名:属性值,方法名:方法})
            $.ajax({
                url : "/ajaxpost",//请求路由
                type : "POST",//请求类型 GET、POST
                data : {//向后端发送的数据，以json格式向后传递
                    "uname" : uname
                },
                success : function (info) {//后台响应成功会调用函数,info-后台响应的数据封装到info中，info名字可以随便起
                    document.getElementById("errmsg").innerText = info["msg"]
                },
                fail : function () {后台响应失败会调用函数
                }
            })
        }
    </script>
</body>
</html>
{{end}}

测试：

2、文件上传

2.1、form表单中文件上传(单个文件)

main.go

func main() {
	r := gin.Default()
	r.LoadHTMLGlob("part03/templates/**/*")
	r.GET("/userindex", myfunc.Test1)
	r.POST("/savefile", myfunc.Test2)
	r.Run()
}

myfunc.go

func Test1(context *gin.Context) {
	context.HTML(200, "demo01/hello01.html", nil)
}

func Test2(context *gin.Context) {
	//获取前端传入的文件：
	file, _ := context.FormFile("myfile")
	fmt.Println(file.Filename)
	//加入一个时间戳：
	time_int := time.Now().Unix()
	time_str := strconv.FormatInt(time_int, 10) //10:十进制
	//保存在我的本地：
	context.SaveUploadedFile(file, "e://"+time_str+file.Filename)
	//响应一个字符串：
	context.String(200, "文件上传成功")
}

hello01.html 

{{define "demo01/hello01.html"}}
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <link rel="stylesheet" href="/s/css/mycss.css">
</head>
<body>
    用户form表单<br>
    <form action="/savefile" method="post" enctype="multipart/form-data">
        <input type="file" name="myfile">
        <input type="submit" value="提交">
    </form>
</body>
</html>
{{end}}

测试：

2.2、form表单中文件上传(多个文件)

main.go

func main() {
	r := gin.Default()
	r.LoadHTMLGlob("part03/templates/**/*")
	r.GET("/userindex", myfunc.Test1)
	r.POST("/savefile", myfunc.Test3)
	r.Run()
}

myfunc.go

func Test3(context *gin.Context) {
	//先获取form表单
	form, _ := context.MultipartForm()
	//在form表单中获取name相同的文件：
	files := form.File["myfile"] //File是个Map，通过key获取value部分
	//files就是name相同的多个文件：挨个处理---遍历处理：
	for _, file := range files {
		//加入一个时间戳：
		time_int := time.Now().Unix()
		time_str := strconv.FormatInt(time_int, 10) //10:十进制
		//保存在我的本地：
		context.SaveUploadedFile(file, "e://"+time_str+file.Filename)
	}
	//响应一个字符串：
	context.String(200, "文件上传成功")
}

hello01.html 

{{define "demo01/hello01.html"}}
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <link rel="stylesheet" href="/s/css/mycss.css">
</head>
<body>
    用户form表单<br>
    <form action="/savefile" method="post" enctype="multipart/form-data">
        <input type="file" name="myfile">
        <input type="file" name="myfile">
        <input type="file" name="myfile">
        <input type="submit" value="提交">
    </form>
</body>
</html>
{{end}}

测试：

2.3、ajax上传单个文件

注意利用ajax上传文件的话，在ajax中需要加两个参数：
（1）contentType:false
默认为true，当设置为true的时候,jquery ajax 提交的时候不会序列化 data，而是直接使用data
（2）processData:false,
目的是防止上传文件中出现分界符导致服务器无法正确识别文件起始位置。

main.go

func main() {
	r := gin.Default()
	r.LoadHTMLGlob("part04/templates/**/*")
	r.Static("/s", "part04/static")
	r.GET("/userindex", myfunc.Test1)
	r.POST("/savefile", myfunc.Test4)
	r.Run()
}
myfunc.go
func Test4(context *gin.Context) {
	//获取前端传入的文件：
	file, _ := context.FormFile("file")
	fmt.Println(file.Filename)
	//加入一个时间戳：
	time_int := time.Now().Unix()
	time_str := strconv.FormatInt(time_int, 10) //10:十进制
	//保存在我的本地：
	context.SaveUploadedFile(file, "e://"+time_str+file.Filename)
	//响应一个字符串：
	context.String(200, "文件上传成功")
}

hello01.html 

{{define "demo01/hello01.html"}}
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="/s/js/jQuery.min.js"></script>
</head>
<body>
    用户form表单<br>
    <form action="/savefile" method="post">
        <input type="file" class="myfile" multiple="multiple">
        <input type="button" value="提交按钮" id="btn">
    </form>
    <script>
        //获取按钮
        var btn = document.getElementById("btn");
        //给按钮加入一个单击事件：
        btn.onclick = function () {
            //创建存放form表单的数据：
            var form_data = new FormData();
            //在form_data添加要传入到后台的元素：
            form_data.append("file",$(".myfile")[0].files[0])
            //利用ajax向后台传递数据：
            $.ajax({
                url : "/savefile",
                type : "POST",
                data : form_data,
                contentType:false,
                processData:false,
                success : function () {

                }
            })
        }
    </script>
</body>
</html>
{{end}}

2.4、ajax上传多个文件

main.go

func main() {
	r := gin.Default()
	r.LoadHTMLGlob("part04/templates/**/*")
	r.Static("/s", "part04/static")
	r.GET("/userindex", myfunc.Test1)
	r.POST("/savefile", myfunc.Test5)
	r.Run()
}

myfunc.go

func Test5(context *gin.Context) {
	//先获取form表单
	form, _ := context.MultipartForm()
	//在form表单中获取name相同的文件：
	files := form.File["myfile"] //File是个Map，通过key获取value部分
	//files就是name相同的多个文件：挨个处理---遍历处理：
	for _, file := range files {
		//加入一个时间戳：
		time_int := time.Now().Unix()
		time_str := strconv.FormatInt(time_int, 10) //10:十进制
		//保存在我的本地：
		context.SaveUploadedFile(file, "e://"+time_str+file.Filename)
	}
	//响应一个字符串：
	context.String(200, "文件上传成功")
}

hello01.html 

{{define "demo01/hello01.html"}}
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="/s/js/jQuery.min.js"></script>
</head>
<body>
    用户form表单<br>
    <form action="/savefile" method="post">
        <input type="file" class="myfile">
        <input type="file" class="myfile">
        <input type="file" class="myfile">
        <input type="button" value="提交按钮" id="btn">
    </form>
    <script>
        //获取按钮
        var btn = document.getElementById("btn");
        //给按钮加入一个单击事件：
        btn.onclick = function () {
            //创建存放form表单的数据：
            var form_data = new FormData();
            //获取多个文件：
            var myfiles = $(".myfile");
            //对多个文件进行遍历，每一个添加到form_data中去：
            for (var i = 0;i < myfiles.length;i++){
                form_data.append("myfile",myfiles[i].files[0]);
            }
            //利用ajax向后台传递数据：
            $.ajax({
                url : "/savefile",
                type : "POST",
                data : form_data,
                contentType:false,
                processData:false,
                success : function () {

                }
            })
        }
    </script>
</body>
</html>
{{end}}

响应重定向:是请求服务器后，服务器通知浏览器，让浏览器去自主请求其他资源的一种方式。

3、模板语法

【1】模板
在写动态页面的网站的时候，我们常常将不变的部分提出成为模板，可变部分通过后端程序的渲染来生成动态网页，golang也支持模板渲染。
【2】模板内内嵌的语法支持，全部需要加  {{}}  来标记。
【3】在模板文件内， . 代表了当前位置的上下文：
        （1）在非循环体内，. 就代表了后端传过来的上下文
        （2）在循环体中，. 就代表了循环的上下文
【4】在模板文件内， $  代表了模板根级的上下文
【5】在模板文件内， $. 代表了模板根级的上下文

【6】字符串：{{ “abc,Hello World ” }}
【7】原始字符串：{{ `abc` }}    {{ `a` }}    不会转义
【8】字节类型：{{ ' a' }} ---> 97  会转义
【9】打印：
打印字符串： {{ print "Hello World" }}
nil类型：{{ print nil }} 

{{define "demo01/hello.html"}}
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    打印字符串： {{ print "Hello World" }}
    nil类型：{{ print nil }} 
    变量的定义：
    {{$name := "XIAOMING"}}
    变量的使用：
    {{$name}}
</body>
</html>
{{end}}

【10】if：

方式1：
{{if .condition}}
{{end}}
方式2：
{{if .condition1}}
{{else}}
{{end}}
方式3：
{{if .condition1}}
{{else if .contition2}}
{{end}}

内置的模板函数
not 非
and 与
or 或
eq 等于
ne 不等于
lt 小于 (less than)
le 小于等于
gt 大于
ge 大于等于

【11】range循环

    {{range .arr}}
        {{.}}
        {{$.age}}
    {{end}}
    <br>
    {{range $i,$v := .arr}}
        {{$i}}
        {{$v}}
    {{end}}

【12】with 关键字

{{ with pipeline }} T1 {{ end }}
{{ with pipeline }} T1 {{ else }} T0 {{ end }}
其中 pipeline 为判断条件，如满足就将 . 设为 pipeline 的值并执行 T1，不修改外面的 . 。
否则执行 T0。
{{define "demo01/hello.html"}}
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <br>
    获取结构体中内容：
    {{.stu.Age}}
    {{.stu.Name}}
    <br>
    启动with关键字：
    {{with .stu}}
        {{.Age}}
        {{.Name}}
    {{else}}
        暂无数据
    {{end}}
</body>
</html>
{{end}}

【13】template：作用：引入另一个模板文件

{{template "模板名" pipeline}}
PS：管道（传递数据的）
PS：引入的模板文件中也要用{ {define "路径"} } { {end} }包含
PS：如果想在引入的模板中也需要获取动态数据，必须使用 . 访问当前位置的上下文

hello.html

{{define "demo01/hello.html"}}
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
        <br>
    内嵌另外模板：
    {{/*    如果想要传递内容到内嵌模板中，可以通过.上下文进行传递，和内嵌页面共享上下文数据*/}}
    {{template "templates/demo01/hello2.html" .}}
</body>
</html>
{{end}}

hello2.html

{{define "templates/demo01/hello2.html"}}
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    这是一个内嵌页面。。。
    {{with .stu}}
        {{.Age}}
        {{.Name}}
    {{else}}
        暂无数据
    {{end}}
</body>
</html>
{{end}}

模板函数

【1】print     打印字符串
【2】printf    按照格式化的字符串输出
格式：参照：Go中：fmt.Sprintf
【3】len  返回对应类型的长度(map, slice, array, string, chan)
【4】管道传递符：   |  
函数中使用管道传递过来的数值 
【5】括号提高优先级别：()
【6】and  只要有一个为空，则整体为空；如果都不为空，则返回最后一个
【7】or  只要有一个不为空，则返回第一个不为空的；如果都是空，则返回空
【8】not 用于判断返回布尔值，如果有值则返回false，没有值则返回true
【9】index  读取指定类型对应下标的值(map, slice, array, string)
【10】eq：等于equal，返回布尔值
【11】ne：不等于 not equal，返回布尔值
【12】lt：小于 less than，返回布尔值
【13】le：小于等于less equal，返回布尔值
【14】gt：大于 greater than，返回布尔值
【15】ge：大于等于 greater equal，返回布尔值
【16】日期格式化  Format
实现了时间的格式化，返回字符串，设置时间格式比较特殊，需要固定方式，不能轻易改变
【17】自定义模板函数：

【17】自定义模板函数：

myfunc.go

// 定义一个函数：
func Add(num1 int, num2 int) int {
	return num1 + num2
}

main.go注册函数

import (
	"github.com/gin-gonic/gin"
	"html/template"
	"test_gin/part05/myfunc"
)

func main() {
	r := gin.Default()
	//注册函数：FuncMap是html/FuncMap
	r.SetFuncMap(template.FuncMap{
		//键值对的作用：key指定前端调用的名字，value指定的是后端对应的函数
		"add": myfunc.Add,
	})
	r.LoadHTMLGlob("part05/templates/**/*")
	r.Static("/s", "part05/static")
	r.GET("/test1", myfunc.Test1)
	r.Run()
}

hello01.html使用函数

{{define "demo01/hello01.html"}}
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<br>
    调用add函数：
    {{add 11 82}}
</body>
</html>
{{end}}

测试：

4、数据绑定

数据绑定:能够基于请求自动提取JSON、form表单和QueryString类型的数据，并把值绑定到后端指定的结构体对象中去

4.1、表单数据的绑定

main.go

import (
	"github.com/gin-gonic/gin"
	"test_gin/part06/myfunc"
)

func main() {
	r := gin.Default()
	r.LoadHTMLGlob("part06/templates/**/*")
	r.GET("/userindex", myfunc.Test1)
	r.GET("/toFormBind", myfunc.Test2)
	r.Run()
}
myfunc.go
import (
	"fmt"
	"github.com/gin-gonic/gin"
)

func Test1(context *gin.Context) {
	//获取路径中的参数值：
	context.HTML(200, "demo01/hello01.html", nil)
}

type User struct {
	//加入标签：绑定的时候需要指定将form表单中的username绑定到Username上
	Uername string `form:"username"`
	//加入标签：绑定的时候需要指定将form表单中的pwd绑定到Pwd上
	Pwd string `form:"pwd"`
}

func Test2(context *gin.Context) {
	//定义结构体对象：
	var user User
	//数据绑定：
	err := context.ShouldBind(&user)
	//打印结构体对象的内容：
	fmt.Println(user)
	if err != nil {
		context.String(404, "绑定失败")
	} else {
		context.String(200, "绑定成功")
	}
}

hello01.html
{{define "demo01/hello01.html"}}
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="/toFormBind" >
        用户名：<input type="text" name="username">
        密码：<input type="password" name="pwd">
        <input type="submit" value="提交">
    </form>
</body>
</html>
{{end}}

测试：

4.2、路径中参数的绑定

路径中参数的绑定 又叫：querystring类型的绑定，页面以get方式请求数据，WEB SERVER将请求数据放入名为 QUERY_STRING的环境变量中，所以可以称作为querystring类型的绑定

方式同表单数据的绑定，标签利用的依然是form标签

main.go

func main() {
	r := gin.Default()
	r.LoadHTMLGlob("part06/templates/**/*")
	r.GET("/userindex2", myfunc.Test3)
	r.Run()
}

myfunc.go

func Test3(context *gin.Context) {
	//定义结构体对象：
	var user User
	//数据绑定：
	err := context.ShouldBind(&user)
	//打印结构体对象的内容：
	fmt.Println(user)
	if err != nil {
		context.String(404, "绑定失败")
	} else {
		context.String(200, "绑定成功")
	}
}

测试：

http://localhost:8080/userindex2?username=lwz&pwd=123123

4.3、JSON数据的绑定

main.go

func main() {
	r := gin.Default()
	r.LoadHTMLGlob("part06/templates/**/*")
	//指定文件：
	r.Static("/s", "part06/static")
	r.GET("/userindex3", myfunc.Test4)
	r.POST("/toajax", myfunc.Test5)
	r.Run()
}
hello02.html
{{define "demo02/hello02.html"}}
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="/s/js/jQuery.min.js"></script>
</head>
<body>
    <form>
        用户名字：<input type="text" name="uname" id="uname">
        年龄：<input type="text" name="age" id="age">
        <input type="button" value="提交" id="btn">
    </form>
    <script>
        //获取按钮
        var btn = document.getElementById("btn")
        //给按钮绑定单击事件：
        btn.onclick = function () {
            //获取表单中元素：
            var uname = document.getElementById("uname").value;
            var age = document.getElementById("age").value;
            //通过ajax方式向后台传递：
            $.ajax({
                url : "/toajax",
                type : "POST",
                //如果向后台提交的是Json字符串需要加入这个属性：
                contentType : "application/json",
                //JSON.stringify() 方法用于将 JavaScript 值转换为 JSON 字符串。
                data : JSON.stringify({
                    "uname" : uname,
                    "age" : Number(age)
                }),
                success : function (info) {
                    alert(info["msg"])
                }
            })
        }
    </script>
</body>
</html>
{{end}}

myfunc.go

type User2 struct {
	Uname string `json:"uname"`
	Age   int    `json:"age"`
}

func Test4(context *gin.Context) {
	//获取路径中的参数值：
	context.HTML(200, "demo02/hello02.html", nil)
}
func Test5(context *gin.Context) {
	//创建结构体示例：
	var user User2
	//数据绑定：
	err := context.ShouldBind(&user)
	//打印结构体对象的内容：
	fmt.Println(user)
	if err != nil {
		context.JSON(404, gin.H{
			"msg": "绑定失败",
		})
	} else {
		context.JSON(200, gin.H{
			"msg": "绑定成功",
		})
	}
}

测试

4.4、URI数据的绑定

URI ： 统一资源标识符  a/login  
URL：统一资源定位符 http://localhost:8080/a/login  

main.go

func main() {
	r := gin.Default()
	r.LoadHTMLGlob("part06/templates/**/*")
	r.GET("/userindex4/:uname/:age", myfunc.Test6)
	r.Run()
}

myfunc.go

type User2 struct {
	Uname string `json:"uname" uri:"uname" form:"uname"`
	Age   int    `json:"age" uri:"age" form:"age"`
}

func Test6(context *gin.Context) {
	//创建结构体示例：
	var user User2
	//数据绑定：
	err := context.ShouldBindUri(&user)
	//打印结构体对象的内容：
	fmt.Println(user)
	if err != nil {
		context.String(404, "绑定失败")
	} else {
		context.String(200, "绑定成功")
	}
}

测试：

5、路由组

路由组：将不同的路由按照版本、模块进行不同的分组，利于维护，方便管理。

main.go

func main() {
	r := gin.Default()
	r.LoadHTMLGlob("part08/templates/**/*")
	//指定文件：
	r.Static("/s", "part08/static")

	//按照版本号对路由进行分组：
	v1 := r.Group("/version01")
	{
		v1.GET("/userindex", myfunc.Test1)
		v1.GET("/toFormBind", myfunc.Test2)
		v1.GET("/userindex2", myfunc.Test3)
	}
	v2 := r.Group("/version02")
	{
		v2.GET("/userindex3", myfunc.Test4)
		v2.POST("/toajax", myfunc.Test5)
		v2.GET("/userindex4/:uname/:age", myfunc.Test6)
	}
	r.Run()
}

测试：

路由组抽取

路由抽取的规则：
1.总路由中设置路由组（总路由）
2.模块中的路由负责映射具体的业务（模块路由）

main.go

package main

import (
	"github.com/gin-gonic/gin"
	"test_gin/part09/router"
)

func main() {
	r := gin.Default()
	r.LoadHTMLGlob("part09/templates/**/*")
	//指定文件：
	r.Static("/s", "part09/static")
	//指定总路由：
	router.Router(r)
	r.Run()
}

总路由

package router

import (
	"github.com/gin-gonic/gin"
	"test_gin/part09/bill"
	"test_gin/part09/external"
)

func Router(r *gin.Engine) {
	b := r.Group("/bill")     
	e := r.Group("/external") 
	//模块分组：
	bill.Router(b)
	external.Router(e)
}

模块路由：（bill）

package bill

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

func Router(r *gin.RouterGroup) {
	r.GET("/userindex", Test1)
	r.GET("/toFormBind", Test2)
	r.GET("/userindex2", Test3)
}

func Test1(context *gin.Context) {
	//获取路径中的参数值：
	context.HTML(200, "demo01/hello01.html", nil)
}

type User struct {
	Uername string `form:"username"`
	Pwd     string `form:"pwd"`
}

func Test2(context *gin.Context) {
	//定义结构体对象：
	var user User
	//数据绑定：
	err := context.ShouldBind(&user)
	//打印结构体对象的内容：
	fmt.Println(user)
	if err != nil {
		context.String(404, "绑定失败")
	} else {
		context.String(200, "绑定成功")
	}
}

func Test3(context *gin.Context) {
	//定义结构体对象：
	var user User
	//数据绑定：
	err := context.ShouldBind(&user)
	//打印结构体对象的内容：
	fmt.Println(user)
	if err != nil {
		context.String(404, "绑定失败")
	} else {
		context.String(200, "绑定成功")
	}
}

模块路由(external)

package external

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

func Router(r *gin.RouterGroup) {
	r.GET("/userindex3", Test4)
	r.POST("/toajax", Test5)
	r.GET("/userindex4/:uname/:age", Test6)
}

func Test4(context *gin.Context) {
	//获取路径中的参数值：
	context.HTML(200, "demo02/hello02.html", nil)
}
func Test5(context *gin.Context) {
	//创建结构体示例：
	var user User2
	//数据绑定：
	err := context.ShouldBind(&user)
	//打印结构体对象的内容：
	fmt.Println(user)
	if err != nil {
		context.JSON(404, gin.H{
			"msg": "绑定失败",
		})
	} else {
		context.JSON(200, gin.H{
			"msg": "绑定成功",
		})
	}
}

type User2 struct {
	Uname string `json:"uname" uri:"uname" form:"uname"`
	Age   int    `json:"age" uri:"age" form:"age"`
}

func Test6(context *gin.Context) {
	//创建结构体示例：
	var user User2
	//数据绑定：
	err := context.ShouldBindUri(&user)
	//打印结构体对象的内容：
	fmt.Println(user)
	if err != nil {
		context.String(404, "绑定失败")
	} else {
		context.String(200, "绑定成功")
	}
}

测试：

6、中间件

        Gin框架允许开发者在处理请求的过程中，加入用户自己的钩子(Hook)函数(中间件函数)，这个钩子函数就叫中间件。
        中间件适合处理一些公共的业务逻辑，比如登录认证、权限校验、数据分页、记录日志、耗时统计等等。

6.1、自定义中间件

middleware/middleware.go

package middleware

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

func MiddleWare01(context *gin.Context) {
	fmt.Println("自定义中间件-方式1，在此处编写统一业务逻辑")
}

func MiddleWare02() gin.HandlerFunc {
	return func(context *gin.Context) {
		fmt.Println("自定义中间件-方式2，在此处编写统一业务逻辑")
	}
}

main.go

package main

import (
	"github.com/gin-gonic/gin"
	"test_gin/part10/middleware"
	"test_gin/part10/router"
)

func main() {
	r := gin.Default()
	r.LoadHTMLGlob("part10/templates/**/*")
	//指定文件：
	r.Static("/s", "part10/static")
	r.Use(middleware.MiddleWare01)
	r.Use(middleware.MiddleWare02())
	//指定总路由：
	router.Router(r)
	r.Run()
}

测试：

6.2、中间件链

如果定义众多中间件，会形成一条中间件链，而通过Next方法来对后面的中间件进行执行。

Next 函数作用：继续走中间件链中的下一个中间件。

middleware/middleware.go

package middleware

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

func MiddleWare01(context *gin.Context) {
	fmt.Println("这是自定义的中间件1-开始")
	context.Next()
	fmt.Println("这是自定义的中间件1-结束")
}

func MiddleWare02() gin.HandlerFunc {
	return func(context *gin.Context) {
		fmt.Println("这是自定义的中间件2-开始")
		fmt.Println("这是自定义的中间件2-结束")
	}
}

func MiddleWare03() gin.HandlerFunc {
	return func(context *gin.Context) {
		fmt.Println("这是自定义的中间件3-开始")
		context.Next()
		fmt.Println("这是自定义的中间件3-结束")
	}
}

main.go

func main() {
	r := gin.Default()
	r.LoadHTMLGlob("part10/templates/**/*")
	//指定文件：
	r.Static("/s", "part10/static")
	r.Use(middleware.MiddleWare01)
	r.Use(middleware.MiddleWare03())
	r.Use(middleware.MiddleWare02())
	//指定总路由：
	router.Router(r)
	r.Run()
}

测试结果：

6.3、终止中间件

Abort()方法的作用终止调用整个链条

middleware/middleware.go

package middleware

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

func MiddleWare01(context *gin.Context) {
	fmt.Println("这是自定义的中间件1-开始")
	context.Next()
	fmt.Println("这是自定义的中间件1-结束")
}

func MiddleWare02() gin.HandlerFunc {
	return func(context *gin.Context) {
		fmt.Println("这是自定义的中间件2-开始")
		fmt.Println("这是自定义的中间件2-结束")
	}
}

func MiddleWare03() gin.HandlerFunc {
	return func(context *gin.Context) {
		fmt.Println("这是自定义的中间件3-开始")
		if 4 > 2 {
			//终止链条：
			context.Abort()
			//return
		}
		context.Next()
		fmt.Println("这是自定义的中间件3-结束")
	}
}

main.go

func main() {
	r := gin.Default()
	r.LoadHTMLGlob("part10/templates/**/*")
	//指定文件：
	r.Static("/s", "part10/static")
	r.Use(middleware.MiddleWare01)
	r.Use(middleware.MiddleWare03())
	r.Use(middleware.MiddleWare02())
	//指定总路由：
	router.Router(r)
	r.Run()
}

Abort()方法的作用：终止中间件链条的调用，但是逻辑代码不会被影响

测试：

如果使用return的话，就是不行的，return结束逻辑代码，但是对next的调用不起作用：

middleware/middleware.go

func MiddleWare03() gin.HandlerFunc {
	return func(context *gin.Context) {
		fmt.Println("这是自定义的中间件3-开始")
		if 4 > 2 {
			//终止链条：
			//context.Abort()
			return
		}
		context.Next()
		fmt.Println("这是自定义的中间件3-结束")
	}
}

测试：

6.4、中间件的作用域

1、全局中间件:针对所有的路由都生效
加入位置：main函数中加，例如上面例子

2、路由组中间件：针对某个路由组生效：
加入位置：在总路由分组中加入即可：

router/router.go

package router

import (
	"github.com/gin-gonic/gin"
	"test_gin/part09/bill"
	"test_gin/part09/external"
	"test_gin/part10/middleware"
)

func Router(r *gin.Engine) {
	b := r.Group("/bill")
	b.Use(middleware.MiddleWare01)
	e := r.Group("/external")
	//模块分组：
	bill.Router(b)
	external.Router(e)
}

3、局部中间件：针对具体的某一个路由生效
位置：在具体路由和函数之间的参数加上中间件

package bill

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"test_gin/part10/middleware"
)

func Router(r *gin.RouterGroup) {
	r.GET("/userindex", middleware.MiddleWare01, Test1)
	r.GET("/toFormBind", Test2)
	r.GET("/userindex2", Test3)
}
...

Web framework-Gin

Go framework-Beego

难留少年时，总有少年来！

无论你是年轻还是年长，所有程序员都需要记住：时刻努力学习新技术，否则就会被时代抛弃！

杀神lwz
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
go-web-framework-stars：Go的Web框架，在GitHub上最受欢迎
02-02
Gin是用Go（Golang）编写的HTTP Web框架。 它具有类似于Martini的API，性能更高-快40倍。 如果您需要出色的性能，请给自己一些杜松子酒。 2021-01-27 01:58:21 25821 5094 37 beego是用于Go编程语言的开源高...
gin-web-framework
07-01
Gin is a HTTP web framework written in Go (Golang). It features a Martini-like API with much better performance -- up to 40 times faster. If you need smashing performance, get yourself some Gin. ...
Gin框架从入门到上手学习指南
qq_52510579的博客
01-10 911
Gin 是一个用 Go (Golang) 编写的 Web 框架。它具有类似 martini 的 API，性能要好得多，多亏了 httprouter，速度提高了 40 倍。如果您需要性能和良好的生产力，您一定会喜欢 Gin。Gin相比于Iris和Beego而言，更倾向于轻量化的框架，只负责Web部分，追求极致的路由性能，功能或许没那么全，胜在轻量易拓展，这也是它的优点。因此，在所有的Web框架中，Gin是最容易上手和学习的。Gin是一个Web框架，并非MVC框架，MVC的功能需要开发者自行实现。
Go语言五大主流web框架
深漂小码哥
11-06 9336
Golang web框架
Web framework-Gin
杀神lwz的博客
08-13 695
软件框架（software framework），通常指的是为了实现某个业界标准或完成特定基本任务的软件组件规范，也指为了实现某个软件组件规范时，提供规范所要求之基础功能的软件产品。框架就是：偷懒的程序员，写代码发现写过了写的就是那些玩意，码农，只是代码的搬运工，干脆将代码进行封装, 之后进行重复使用的过程。使用框架,可以大大的提升开发的效率。其实用GO语言标准库就可以完成web开发，但是为什么使用框架呢？框架就是一个别人搭建好的舞台，有很多现成的工具可以提供给你用，你在此基础上开发效率肯定更高。
Gin web框架初步认识
个人学习笔记库，一篇一篇记录成长的足迹
04-13 531
go语言最块的框架，学习其基本知识快速上手web开发
Gin Web 框架使用和流程分析
CoLiuRs
05-18 859
Gin Web 框架的使用和流程分析 Demo package main import ( "log" "net/http" "github.com/gin-gonic/gin" ) func HelloWorld(c *gin.Context) { c.String(http.StatusOK, "pong") } func main() { r := gin.Default() // 获取一个Gin的实例：Engine，gin的核心数据结构 r.Use(gin.L
开源项目-smallnest-go-web-framework-benchmark.zip
10-21
"smallnest-go-web-framework-benchmark"项目的核心目标是评估和比较Go语言中的各种Web框架，包括Gin、Beego、Echo、Martini等。通过一系列精心设计的基准测试，项目揭示了这些框架在处理HTTP请求、路由、模板渲染等...
example-gin:使用Framework Gin和mongodb的示例Go
04-22
通过研究和理解"example-gin-master"项目，开发者可以学习到如何在Go语言环境中高效地使用Gin和MongoDB，这对于构建现代Web服务是非常有价值的。同时，这也是提升Go语言和数据库集成技能的好途径。
Gin Web Framework:Go最快的全功能Web框架-开源
04-26
Gin是一个用Golang编写的速度非常快的Web框架，由于它具有类似于martini的API和自定义版本的httprouter，因此其执行速度可以提高40倍。 它的内存占用非常小，也没有反射和基于Radix树的路由。 对于那些追求空前速度...
2024年网络安全山东省赛-SMB信息收集解析（中职组）_使用访问工具对服务器服务访问,将服务器中管理员桌面的文本文档里的内容作为 flag
最新发布
2401_84252281的博客
04-26 803
任务环境说明：服务器场景：Server1。
基于gin框架搭建的一个简单的web服务
pythonwork的博客
02-28 922
1.Go Web框架的技术选型 Top 6 web frameworks for Go as of 2017，可以看看这个go语言中Web框架的对比和老大的推荐，我选择gin框架作为学习go语言的框架。 2.Gin介绍 gin框架的中文文档，这个文档相当好，清晰明了解释gin框架的整个用法。下面是gin框架的全部特性： gin框架安装 :go get -u github.com/gin-gonic/gin 3.建立一个web服务实现Hello Word 首先需要安装ginweb框架和go
翻译 | Gin Web Framework
双鬼带单
10-20 447
Go web 框架 Gin 翻译
Golang 微框架 Gin 简介
weixin_30699463的博客
08-22 2664
框架一直是敏捷开发中的利器，能让开发者很快的上手并做出应用，甚至有的时候，脱离了框架，一些开发者都不会写程序了。成长总不会一蹴而就，从写出程序获取成就感，再到精通框架，快速构造应用，当这些方面都得心应手的时候，可以尝试改造一些框架，或是自己创造一个。 曾经我以为Python世界里的框架已经够多了，后来发现相比golang简直小巫见大巫。golang提供的net/http库已经很好了，对于...
Gin Web框架简介
热门推荐
moxiaomomo的专栏
04-14 4万+
翻译自: https://github.com/gin-gonic/gin/blob/develop/README.mdGin Web框架 Gin是用Golang实现的一种Web框架。基于 httprouter，它提供了类似martini但更好性能(路由性能约快40倍)的API服务. 如果你希望构建一个高性能的生产环境，你会喜欢上使用 Gin。$ cat test.gopackage
基于gin框架的web服务器搭建
qq_34484082的博客
03-19 765
环境和安装（请看上一篇） 本来选的lrsi（好像是这个）框架，结果被环境的翻墙劝退 gin框架作为轻量级的web框架也很nice，下面开始搭建自己的一个简易的web服务器。 为了统一协议，方便开发，我这里采用的后端接口均为CGI协议的格式。 为了实现先后端分离，后端只提供数据源已经一些基本逻辑，采用的请求格式都为json字符串。 基本功能的添加 1.日志模块 安装好gin框架之后的目录结构： 在工程目录gin_test下创建自己的控制器层controller，为了层次清晰再建一个system的文件夹，里面
Go gin web框架介绍
学亮编程手记
08-12 585
gin框架介绍 一、gin框架介绍 gin是用go语言开发的一个web框架，简单易用，是一个轻量级框架。 二、为什么选择gin 1.运行响应非常快 2.快速开发 3.文档齐全 4.社区活跃 三、特性 1.快速：基于 Radix 树的路由，小内存占用。没有反射。可预测的 API 性能。 2.支持中间件：传入的 HTTP 请求可以由一系列中间件和最终操作来处理。 例如：Logger，Authorization，GZIP，最终操作 DB。 3.Crash 处理：Gin 可以 catch 一个发生在 HTTP 请求
golang开发框架之gin
zrs19800702的博客
10-21 1万+
原链接 https://github.com/gin-gonic/gin Gin Web Framework Gin is a web framework written in Go (Golang). It features a martini-like API with much better performance, up to 40 times faster th
go随聊-web框架gin
九品神元师
10-31 1009
Gin Web Framework      Gin 是一个 Golang 写的 web 框架，具有高性能的优点，基于 httprouter，它提供了类似martini但更好性能(路由性能约快40倍)的API服务。自身的net/http足够简单，Gin更像是一些常用函数或者工具的集合。借助Gin开发，不仅可以省去很多常用的封装带来的时间，也有助于团队的编码风格和形成规范。 https://g...
gin-gonic gin 安全漏洞
11-24
gin-gonic是一个轻量级的Go语言Web框架，它被广泛用于构建高性能的Web应用程序。虽然它被认为是一个相对安全的框架，但没有一个完全免受安全漏洞的框架。下面我将介绍一些可能的gin-gonic gin安全漏洞，并提供相应的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

杀神lwz

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值