gin框架学习

🕗 发布于 2024-12-12 14:12 gin 学习 golang go web安全

gin框架是什么

gin框架是一个用Go语言编写的web框架，其主要可以用于微服务开发等项目使用

goland快速安装gin

直接使用goland进行创建一个新项目即可

![[Pasted image 20241116194154.png]]

然后编写如下代码并运行（爆红忽略即可)，

package main  
  
import (  
    "github.com/gin-gonic/gin"  
)  
  
func main() {  
    // 创建一个默认的路由引擎  
    r := gin.Default()  
    // GET：请求方式；/hello：请求的路径  
    // 当客户端以GET方法请求/hello路径时，会执行后面的匿名函数  
    r.GET("/hello", func(c *gin.Context) {  
       // c.JSON：返回JSON格式的数据 gin.H 是map[string]interface{}的缩写   
c.JSON(200, gin.H{  
          "message": "Hello",  
       })  
    })  
    // 启动HTTP服务，默认在0.0.0.0:8080启动服务  
    r.Run()  
}

运行后可以发现报错

![[Pasted image 20241116194559.png]]

点击下面的go get即可进行下载

下载完成会显示编译成功即可运行代码

gin简单学习

创建服务

使用gin.Default()方法进行创建一个服务。

其不仅创建了一个Gin引擎，还自动注册了一些默认的中间件。

并且这个函数返回的是一个 *gin.Engine类型对象，这个对象是Gin的核心，用来处理HTTP请求和路由。

而除了gin.Default方法之外，还有一个gin.New()方法也可以进行创建服务，这个函数创建出的引擎是没有添加任何默认中间件的引擎实例，所有操作都可以自己进行，更加灵活。

package main  
  
import "github.com/gin-gonic/gin"  
  
func main() {  
    //创建一个服务  
    ginServer := gin.Default()  
}

创建请求内容

使用ginServer.GET，或者ginServer.POST进行创建GET请求或者POST请求的路由。

这俩个方法都接收俩个参数，第一个为路由路径，第二个为路由处理函数，当访问这个路由时就会触发后面的路由处理函数。

import (  
    "github.com/gin-gonic/gin"  
)  
  
func main() {  
    //创建一个服务  
    ginServer := gin.Default()  
  
    //创建一个get请求  
    ginServer.GET("/hello", func(context *gin.Context) {  
       context.JSON(200, gin.H{"msg": "hello"})  
    })

运行服务

使用的是.Run方法，Run方法启动一个HTTP服务器，开始监听并传入的请求，其接收参数为指定监听的端口

package main  
  
import (  
    "github.com/gin-gonic/gin"  
)  
  
func main() {  
    //创建一个服务  
    ginServer := gin.Default()  
  
    //创建一个get请求  
    ginServer.GET("/hello", func(context *gin.Context) {  
       context.JSON(200, gin.H{"msg": "hello"})  
    })  
  
    //服务器端口,以及运行服务  
    ginServer.Run(":8081")  
}

运行后访问127.0.0.1：8081/hello即可看到hello数据被输出

RESTful API实现

使用不同的请求访问页面时，可以通过定义不同的请求方法来实现不同的功能。

并且，在gin框架中，还有一个可以匹配所有请求方法的Any方法。

package main  
  
import (  
    "github.com/gin-gonic/gin"  
)  
  
func main() {  
    //创建一个服务  
    ginServer := gin.Default()  
  
    //创建一个get请求  
    ginServer.GET("/hello", func(context *gin.Context) {  
       context.JSON(200, gin.H{"msg": "hello"})  
    })  
  
    ginServer.POST("/user", func(context *gin.Context) {  
       context.JSON(200,gin.H{"msg":"POST"})  
    })  
    ginServer.PUT("/user", func(context *gin.Context) {  
       context.JSON(200,gin.H{"msg":"PUT"})  
    })  
    
  
    //服务器端口,以及运行服务  
    ginServer.Run(":8082")  
}

可以使用burpsuit进行测试实现。

响应加载前端页面

使用静态文件

静态文件一般使用Static()方法进行设置，Static方法将某一个目录下的静态资源(HTML,CSS,JS等)映射到指定目录中。

index.html

<!DOCTYPE html>  
<html lang="en">  
<head>  
    <meta charset="UTF-8">  
    <title>Hello Go WEB</title>  
</head>  
<body>  
<h1>WEB</h1>  
</body>  
</html>

package main

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

func main() {
// 创建Gin路由
r := gin.Default()

// 设置静态文件路径
r.Static("/assets", "./public")

// 启动服务器
r.Run(":8080")
}

这样即可加载index.html到/index中

gin模版引擎渲染动态页面

其主要使用了LoadHTMLGlob方法来指定加载哪个目录下的HTML文件。

并且使用c.HTML来渲染并返回指定的界面。

index.html

<!DOCTYPE html>  
<html lang="en">  
<head>  
    <meta charset="UTF-8">  
    <title>Hello Go WEB</title>  
</head>  
<body>  
<h1>WEB</h1>  
{{.msg}}  
</body>  
</html>

package main  
  
import (  
    "github.com/gin-gonic/gin"  
)  
  
func main() {  
    // 创建Gin路由  
    r := gin.Default()  
  
    r.LoadHTMLGlob("public/*")  
  
    r.GET("/index", func(context *gin.Context) {  
       context.HTML(200, "index.html", gin.H{  
          "msg": "Go Web",  
       })  
    })  
  
    // 启动服务器  
    r.Run(":8080")  
}

gin框架加载资源文件

使用Static方法进行加载资源文件

index.js

alert("Hacker")

static.css

body{  
    background: red;  
}

main.go

package main  
  
import (  
    "github.com/gin-gonic/gin"  
)  
  
func main() {  
    // 创建Gin路由  
    r := gin.Default()  
  
    r.LoadHTMLGlob("public/*")  
    r.Static("/static", "./static")  
  
    r.GET("/index", func(context *gin.Context) {  
       context.HTML(200, "index.html", gin.H{  
          "msg": "Go Web",  
       })  
    })  
  
    // 启动服务器  
    r.Run(":8080")  
}

获取请求参数

获取url请求参数

使用c.Param()获取指定参数

package main  
  
import (  
    "github.com/gin-gonic/gin"  
    "net/http")  
  
func main() {  
    // 创建Gin路由  
    r := gin.Default()  
  
    r.LoadHTMLGlob("public/*")  
    r.Static("/static", "./static")  
  
    r.GET("/index", func(context *gin.Context) {  
       context.HTML(200, "index.html", gin.H{  
          "msg": "Go Web",  
       })  
    })  
  
    r.GET("/get/:id", func(context *gin.Context) {  
       id := context.Param("id")  
       context.JSON(http.StatusOK, gin.H{  
          "id": id,  
       })  
    })  
  
    // 启动服务器  
    r.Run(":8080")  
}

获取get请求参数

使用DefaultQuery()或Query()方法获取，这俩个方法的区别是，DefaultQuery()方法可以设置无参数传入时的默认值，而Query方法直接返回空字符串

package main  
  
import (  
    "github.com/gin-gonic/gin"  
    "net/http")  
  
func main() {  
    // 创建Gin路由  
    r := gin.Default()  
  
    r.LoadHTMLGlob("public/*")  
    r.Static("/static", "./static")  
  
    r.GET("/index", func(context *gin.Context) {  
       context.HTML(200, "index.html", gin.H{  
          "msg": "Go Web",  
       })  
    })  
  
    r.GET("/get", func(context *gin.Context) {  
       id := context.Query("id")  
       pass := context.DefaultQuery("pass", "123456")  
       context.JSON(http.StatusOK, gin.H{  
          "id":   id,  
          "pass": pass,  
       })  
    })  
  
    // 启动服务器  
    r.Run(":8080")  
}

获取post请求参数

主要使用DefaultPostForm和PostForm方法来获取参数，区别和上面一样

package main  
  
import (  
    "github.com/gin-gonic/gin"  
    "net/http")  
  
func main() {  
    // 创建Gin路由  
    r := gin.Default()  
  
    r.LoadHTMLGlob("public/*")  
    r.Static("/static", "./static")  
  
    r.GET("/index", func(context *gin.Context) {  
       context.HTML(200, "index.html", gin.H{  
          "msg": "Go Web",  
       })  
    })  
  
    r.POST("/get", func(context *gin.Context) {  
       id := context.PostForm("id")  
       pass := context.DefaultPostForm("pass", "123456")  
       context.JSON(http.StatusOK, gin.H{  
          "id":   id,  
          "pass": pass,  
       })  
    })  
  
    // 启动服务器  
    r.Run(":8080")  
}

获取json请求体参数

使用BindJson方法来获取数据

package main  
  
import (  
    "github.com/gin-gonic/gin"  
    "net/http")  
  
type User struct {  
    Name string `json:"name"`  
    Age  int    `json:"age"`  
}  
  
func main() {  
    // 创建Gin路由  
    r := gin.Default()  
  
    r.LoadHTMLGlob("public/*")  
    r.Static("/static", "./static")  
  
    r.GET("/index", func(context *gin.Context) {  
       context.HTML(200, "index.html", gin.H{  
          "msg": "Go Web",  
       })  
    })  
  
    r.POST("/get", func(context *gin.Context) {  
       var user User  
       context.BindJSON(&user)  
       context.JSON(http.StatusOK, gin.H{  
          "name": user.Name,  
          "age":  user.Age,  
       })  
    })  
  
    // 启动服务器  
    r.Run(":8080")  
}

获取请求头

可以使用GetHeader函数来获取请求头的特定字段

package main  
  
import (  
    "github.com/gin-gonic/gin"  
    "net/http")  
  
func main() {  
    // 创建Gin路由  
    r := gin.Default()  
  
    r.LoadHTMLGlob("public/*")  
    r.Static("/static", "./static")  
  
    r.GET("/index", func(context *gin.Context) {  
       context.HTML(200, "index.html", gin.H{  
          "msg": "Go Web",  
       })  
    })  
  
    r.GET("/get", func(context *gin.Context) {  
       header := context.GetHeader("Connection")  
       context.JSON(http.StatusOK, gin.H{  
          "header": header,  
       })  
  
    })  
  
    // 启动服务器  
    r.Run(":8080")  
}

获取表单参数

package main  
  
import (  
    "github.com/gin-gonic/gin"  
    "net/http")  
  
func main() {  
    // 创建Gin路由  
    r := gin.Default()  
  
    r.LoadHTMLGlob("public/*")  
    r.Static("/static", "./static")  
  
    r.GET("/index", func(context *gin.Context) {  
       context.HTML(200, "index.html", gin.H{  
          "msg": "Go Web",  
       })  
    })  
  
    r.POST("user/login", func(context *gin.Context) {  
       username := context.PostForm("username")  
       password := context.PostForm("password")  
  
       context.JSON(http.StatusOK, gin.H{  
          "username": username,  
          "passwoed": password,  
       })  
    })  
  
    // 启动服务器  
    r.Run(":8080")  
}

index.html

<!DOCTYPE html>  
<html lang="en">  
<head>  
    <meta charset="UTF-8">  
    <title>Hello Go WEB</title>  
    <link rel="stylesheet" href="../static/static.css">  
    <script src="../static/index.js"></script>  
</head>  
<body>  
<form action="/user/login" method="post">  
    <p>username:<input type="text" name="username"></p>  
    <p>password:<input type="text" name="password"></p>  
  
    <button type="submit">提交</button>  
</form>  
</body>  
</html>

路由

重定向

路由重定向使用的方法为 Redirect方法，Redirect方法接收俩个参数；一个是状态码，通常使用 http.StatusFound（302）或者 http.StatusMovedPermanently（301）来表示重定向，另一个是重定向到的url，表示重定向到哪里去

package main  
  
import (  
    "github.com/gin-gonic/gin"  
    "net/http")  
  
func main() {  
    // 创建Gin路由  
    r := gin.Default()  
  
    r.LoadHTMLGlob("public/*")  
    r.Static("/static", "./static")  
  
    r.GET("/index", func(context *gin.Context) {  
       context.HTML(200, "index.html", gin.H{  
          "msg": "Go Web",  
       })  
    })  
  
    r.GET("/search", func(context *gin.Context) {  
       context.Redirect(http.StatusMovedPermanently, "https://www.baidu.com")  
    })  
  
    // 启动服务器  
    r.Run(":8080")  
}

路由组

gin中使用Group方法进行创建路由组

package main  
  
import (  
    "github.com/gin-gonic/gin"  
)  
  
func main() {  
    // 创建Gin路由  
    r := gin.Default()  
  
    r.LoadHTMLGlob("public/*")  
    r.Static("/static", "./static")  
  
    r.GET("/index", func(context *gin.Context) {  
       context.HTML(200, "index.html", gin.H{  
          "msg": "Go Web",  
       })  
    })  
      
    a :=r.Group("cat")  
    {  
       a.GET("/1", func(context *gin.Context) {  
            
       })  
       a.POST("2", func(context *gin.Context) {  
            
       })  
    }  
  
    // 启动服务器  
    r.Run(":8080")  
}

中间件

使用了Use方法来使用中间件。


package main  
  
import (  
    "fmt"  
    "github.com/gin-gonic/gin"    "net/http")  
  
func Logger() gin.HandlerFunc {  
    return func(c *gin.Context) {  
       fmt.Println("Logger middleware executed")  
       c.Next()  // 执行后续的处理函数  
    }  
}  
  
  
func main() {  
    r := gin.Default()  
  
    // 使用中间件  
    r.Use(Logger())  
  
    r.GET("/test", func(c *gin.Context) {  
       c.String(http.StatusOK, "Test route")  
    })  
  
    r.Run(":8080")  
  
  
}

使用gin编写一个简单的钓鱼网站

index.html

<!DOCTYPE html>  
<html lang="en">  
<head>  
    <meta charset="UTF-8">  
    <title>Hello Go WEB</title>  
    <link rel="stylesheet" href="../static/static.css">  
    <script src="../static/index.js"></script>  
</head>  
<body>  
<form action="/login" method="post">  
    <p>username:<input type="text" name="username"></p>  
    <p>password:<input type="text" name="password"></p>  
  
    <button type="submit">提交</button>  
</form>  
  
{{.msg}}  
</body>  
</html>

main.go

package main  
  
import (  
    "fmt"  
    "github.com/gin-gonic/gin"    "net/http"    "os")  
  
const goo = 0  
  
func main() {  
  
    file, err := os.OpenFile("example.txt", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)  
    if err != nil {  
       fmt.Println("Error opening file:", err)  
       return  
    }  
    defer file.Close()  
    r := gin.Default()  
  
    r.LoadHTMLGlob("public/*")  
  
    r.GET("/index", func(context *gin.Context) {  
       context.HTML(http.StatusOK, "index.html", gin.H{})  
    })  
  
    r.POST("/login", func(context *gin.Context) {  
       username := context.PostForm("username")  
       password := context.PostForm("password")  
  
       log := username + ":" + password + "\n"  
  
       file.WriteString(log)  
       context.Redirect(http.StatusMovedPermanently, "http://127.0.0.1:8080/index")  
  
    })  
  
    r.Run(":8080")  
}

原文地址：https://blog.csdn.net/2301_80148821/article/details/144409242

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：MATLAB工具：模糊逻辑设计器fuzzyLogicDesigner的使用方法
下一篇：激活函数在神经网络中的作用，以及Tramformer中的激活函数

【跨库查询、多库查询】.NET开源 ORM 框架 SqlSugar 系列
💎摘要：本章主要介绍跨库查询和多库查询场景，罗列出各种可能会遇到的问题来一一展示案例。
阅读更多2024-12-13
【AI知识】逻辑回归介绍+ 做二分类任务的实例（代码&可视化）
【AI知识】有监督学习分类任务之逻辑回归 + 逻辑回归做二分类任务的实例（代码&可视化）
阅读更多2024-12-13
Java 抽象类
java abstract 抽象类
阅读更多2024-12-13
file转MultiFile的方法
file转MultiFile的方法
阅读更多2024-12-13
Element Plus Table 组件树形渲染实现方法
Element Plus的Table组件通过指定列表数据的children属性，实现树形数据的渲染；同时使用row-key标识唯一的行，依赖排序和子节点数据结构，以实现连动操作。
阅读更多2024-12-13
Android安卓进程保活(二)：双进程拉活
当一个进程结束后，立刻调用启动另一个进程，这样实现互相调用，互相启动( 只有在一个进程结束时候才会启动另一个进程)
阅读更多2024-12-13
PyTorch基本使用-张量的形状操作
transpose 函数可以实现交换张量形状的指定维度, 例如: 一个张量的形状为 (2, 3, 4) 可以通过 transpose 函数把 3 和 4。块组成的，它们并没有存储在整块的内存中，vie
阅读更多2024-12-13
智能人体安全防护：3D 视觉技术原理、系统架构与代码实现剖析
智能3D人体安全检测方案基于3D相机和智能人体识别软件，能够对禁区进行实时监控，并通过AI算法精准识别是否有人跨越边界。一旦检测到异常情况，系统将立即发出警报，帮助企业及时应对潜在的安全威胁。
阅读更多2024-12-13
API 接口选择那个？RESTful、GraphQL、gRPC、WebSocket、Webhook
本文我们了解了基于 HTTP 应用层协议之上的，常用六种 API 接口：RESTful、GraphQL、gRPC、WebSocket、Webhook。每一个都具有自己鲜明的特色及应用场景，我们应该根据
阅读更多2024-12-13
Cacti 未经身份验证的命令注入 CVE-2022-46169复现
再利用此漏洞之前，添加新的“graphs”,因为此漏洞需要POLLER_ACTION_SCRIPT_PHP的采集器。选择的Graph Type是“Device - Uptime”，点击创建。默认账户密
阅读更多2024-12-13

gin框架学习

gin框架是什么

goland快速安装gin

gin简单学习

创建服务

创建请求内容

运行服务

RESTful API实现

响应加载前端页面

使用静态文件

gin模版引擎渲染动态页面

gin框架加载资源文件

获取请求参数

获取url请求参数

获取get请求参数

获取post请求参数

获取json请求体参数

获取请求头

获取表单参数

路由

重定向

路由组

中间件

使用gin编写一个简单的钓鱼网站

相关文章