路由设置
最后更新于：2022-04-02 04:55:07
**设置路由**
分别使用GET、POST、PUT、PATCH、DELETE和OPTIONS访问方式
~~~
package main
import (
"net/http"
"github.com/gin-gonic/gin"
)
func main() {
// 注册一个默认的路由器
router := gin.Default()
// 最基本的用法
router.GET("/appGet", func(c *gin.Context) {
// 回复一个200OK,在client的http-get的resp的body中获取数据
c.String(http.StatusOK, "appGet OK")
})
router.POST("/appPost", func(c *gin.Context) {
// 回复一个200 OK, 在client的http-post的resp的body中获取数据
c.String(http.StatusOK, "appPost OK")
})
router.PUT("/appPut", func(c *gin.Context) {})
router.DELETE("/appDelete", func(c *gin.Context) {})
router.PATCH("/appPatch", func(c *gin.Context) {})
router.HEAD("/appHead", func(c *gin.Context) {})
router.OPTIONS("/appOptions", func(c *gin.Context) {})
// router.Run() // 不传参数，默认是8080端口
// 绑定端口是 8000 ,注意是要加:"
router.Run(":8000")
}
~~~
编译运行
Get方式请求：http://0.0.0.0:8000/appGet
返回：appGet OK
Post方式请求：http://0.0.0.0:8000/appPost
返回：appPost OK
**带参数的路由**
1）使用gin.Context中的Param方法解析
~~~
package main
import (
"net/http"
"github.com/gin-gonic/gin"
)
// 处理带参数的path-GET
func getParameter(c *gin.Context) {
// 回复一个200 OK，获取传入的参数
nickname := c.Param("nickname")
passwd := c.Param("passwd")
c.String(http.StatusOK, "参数:%s %s get parameter OK", nickname, passwd)
}
// 处理带参数的path-POST
func postParameter(c *gin.Context) {
// 回复一个200 OK，获取传入的参数
nickname := c.Param("nickname")
passwd := c.Param("passwd")
c.String(http.StatusOK, "参数:%s %s post parameter OK", nickname, passwd)
}
// 注意':'和'*'的区别
func optionalParameter(c *gin.Context) {
// 回复一个200 OK，获取传入的参数
nickname := c.Param("nickname")
passwd := c.Param("passwd")
c.String(http.StatusOK, "参数:%s %s optional parameter OK", nickname, passwd)
}
func main() {
router := gin.Default()
// 注意':'必须要匹配,'*'选择匹配,即存在就匹配,否则可以不考虑
router.GET("/appGet/:nickname/:passwd", getParameter)
router.POST("/appPost/:nickname/:passwd", postParameter)
router.GET("/optional/:nickname/*passwd", optionalParameter)
router.Run(":8000")
}
~~~
注意：定义参数的方法有两个辅助符号':'和'*'。
如果使用':'参数方法，那么这个参数是必须要匹配的。
如果使用'*'参数， 那么这个参数是可选的。
编译运行
Get方式请求：http://0.0.0.0:8000/appGet/nickname=oldboy/passwd=123456
返回：参数:nickname=oldboy passwd=123456 get parameter OK
Post方式请求：http://0.0.0.0:8000/appPost/nickname=oldboy/passwd=123456
返回：参数:nickname=oldboy passwd=123456 post parameter OK
可选参数：
Get方式请求：http://0.0.0.0:8000/optional/nickname=oldboy/passwd=123456
返回：参数:nickname=oldboy /passwd=123456 optional parameter OK
http://0.0.0.0:8000/optional/nickname=oldboy/
返回：参数:nickname=oldboy / optional parameter OK
2）使用gin.Context中的Query方法解析，类似于正常的URL中的参数传递
~~~
package main
import (
"net/http"
"github.com/gin-gonic/gin"
)
// 使用Query获取参数
func getParameter(c *gin.Context) {
// 回复一个200 OK，获取传入的参数
nickname := c.Query("nickname")
passwd := c.Query("passwd")
c.String(http.StatusOK, "参数:%s %s get parameter OK", nickname, passwd)
}
// 使用Query获取参数
func postParameter(c *gin.Context) {
// 回复一个200 OK，获取传入的参数
nickname := c.Query("nickname")
passwd := c.Query("passwd")
c.String(http.StatusOK, "参数:%s %s post parameter OK", nickname, passwd)
}
func main() {
router := gin.Default()
// 使用gin的Query参数形式
router.GET("/appGet", getParameter)
router.POST("/appPost", postParameter)
router.Run(":8000")
}
~~~
编译运行
Get方式请求：http://0.0.0.0:8000/appGet?nickname=oldboy&passwd=123456
返回：参数:oldboy 123456 get parameter OK
Post方式请求：http://0.0.0.0:8000/appPost?nickname=oldboy&passwd=123456
返回：参数:oldboy 123456 post parameter OK
3）使用gin.Context中的PostForm方法解析
我们需要将参数放在请求的Body中传递, 而不是URL中
~~~
package main
import "github.com/gin-gonic/gin"
// 参数是form中获得,即从Body中获得,忽略URL中的参数
func postParameter(c *gin.Context) {
message := c.PostForm("message")
extra := c.PostForm("extra")
nick := c.DefaultPostForm("nick", "anonymous")
c.JSON(200, gin.H{
"status": "postParameter:posted",
"message": message,
"nick": nick,
"extra": extra,
})
}
func main() {
router := gin.Default()
// 使用post_form形式,注意必须要设置Post的type,
// 同时此方法中忽略URL中带的参数,所有的参数需要从Body中获得
router.POST("/appPost", postParameter)
router.Run(":8000")
}
~~~
由于我们使用了request Body，那么就需要指定Body中数据的形式，此处是form格式，即application/x-www-form-urlencoded。常见的几种http提交数据方式有: application/x-www-form-urlencoded; multipart/form-data; application/json; text/xml。具体使用请google.
在服务端, 使用message := c.PostForm("message")方法解析参数，然后进行处理。
客户端请求代码：
~~~
package main
import (
"fmt"
"io/ioutil"
"net/http"
"strings"
)
var resp *http.Response
func main() {
// 使用post_form形式,注意必须要设置Post的type,同时此方法中忽略URL中带的参数,所有的参数需要从Body中获得
resp, _ = http.Post("http://0.0.0.0:8000/appPost", "application/x-www-form-urlencoded", strings.NewReader("message=hello&extra=world"))
helpRead(resp)
}
// 用于读取resp的body
func helpRead(resp *http.Response) {
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println("ERROR2!: ", err)
}
fmt.Println(string(body))
}
~~~
获取请求头信息
~~~
ua := c.GetHeader("User-Agent")
ct := c.GetHeader("Content-Type")
~~~
设置请求头信息
~~~
ua := c.Header("User-Agent","Mozilla/5.0")
ct := c.Header("Content-Type","text/html; charset=utf-8")
~~~
**路由分组**
~~~
package main
import (
"net/http"
"github.com/gin-gonic/gin"
)
func main() {
router := gin.Default()
// g1
g1 := router.Group("/g1")
{
g1.GET("/login", func(c *gin.Context) {
c.String(http.StatusOK, "/g1/login OK")
})
g1.GET("/submit", func(c *gin.Context) {})
g1.GET("/read", func(c *gin.Context) {})
}
// g2
g2 := router.Group("/g2")
{
g2.POST("/login", func(c *gin.Context) {
c.String(http.StatusOK, "/g2/login OK")
})
g2.POST("/submit", func(c *gin.Context) {})
g2.POST("/read", func(c *gin.Context) {})
}
router.Run(":8000")
}
~~~
编译运行
Get方式请求：http://0.0.0.0:8000/g1/login
返回：/g1/login OK
Post方式请求：http://0.0.0.0:8000/g2/login
返回：/g2/login OK
**middleware中间件**
注意，gin.Default() 默认是加载了一些框架内置的中间件的，而 gin.New() 则没有，根据需要自己手动加载中间件。
~~~
package main
import (
"fmt"
"net/http"
"github.com/gin-gonic/gin"
)
func main() {
r := gin.New()
r.Use(gin.Logger())
r.Use(gin.Recovery())
// 在单个路由中使用 MyBenchLogger 中间件
r.GET("/benchmark", MyBenchLogger(), func(c *gin.Context) {})
authorized := r.Group("/")
// 在路由组中使用中间件
authorized.Use(func(c *gin.Context) {})
{
authorized.POST("/login", func(c *gin.Context) {
c.String(http.StatusOK, "/login OK")
})
authorized.POST("/submit", func(c *gin.Context) {})
authorized.POST("/read", func(c *gin.Context) {})
// testing group
testing := authorized.Group("testing")
testing.GET("/analytics", func(c *gin.Context) {
c.String(http.StatusOK, "/testing/analytics OK")
})
}
// Listen and serve on 0.0.0.0:8080
r.Run(":8000")
}
// 中间件示例
func MyBenchLogger() gin.HandlerFunc {
return func(c *gin.Context) {
fmt.Println("before middleware")
c.Set("request", "clinet_request")
c.Next()
fmt.Println("before middleware")
}
}
~~~
编译运行
Get方式请求：http://0.0.0.0:8000/testing/analytics
返回：/testing/analytics OK
Post方式请求：http://0.0.0.0:8000/login
返回：/login OK
**静态文件服务**
可以向客户端展示本地的一些文件信息, 例如显示某路径下地文件。服务端代码示例：
~~~
package main
import (
"net/http"
"github.com/gin-gonic/gin"
)
func main() {
router := gin.Default()
// 下面测试静态文件服务
// 显示当前文件夹下的所有文件/或者指定文件
router.StaticFS("/showDir", http.Dir("."))
// router.StaticFS("/files", http.Dir("/bin"))
router.Static("/files", "/bin")
router.StaticFile("/image", "./oldboy/1.jpg")
router.Run(":8000")
}
~~~
首先你需要在服务器的路径下创建一个oldboy文件夹，并且放入1.jpg文件。如果已经存在请忽略。
在浏览器中输入：
0.0.0.0:8000/showDir
页面返回：服务器当前路径下地文件信息
在浏览器中输入：
0.0.0.0:8000/files
页面返回：服务器/bin目录下地文件信息
在浏览器中输入：
0.0.0.0:8000/image
页面返回：服务器./oldboy/1.jpg图片
';