Gin框架的使用

最新推荐文章于 2025-02-12 21:21:44 发布

原创最新推荐文章于 2025-02-12 21:21:44 发布 · 333 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#gin

Gin渲染：

HTML渲染

Gin框架中使用LoadHTMLGlob()或者LoadHTMLFiles()方法进行HTML模板渲染。

func main() {
    // 创建一个默认的路由引擎
	r := gin.Default()
    // 渲染模板文件
	r.LoadHTMLGlob("templates/**/*")
    // GET：请求方法 /posts/index：请求路径
	r.GET("/posts/index", func(c *gin.Context) {
        // 选择posts/index.html文件
		c.HTML(http.StatusOK, "posts/index.html", gin.H{
			"title": "posts/index",
		})
	})

	r.GET("users/index", func(c *gin.Context) {
        // 选择posts/index.html文件
		c.HTML(http.StatusOK, "users/index.html", gin.H{
			"title": "users/index",
		})
	})

	r.Run(":8080")
}

静态文件处理

func main() {
    // 创建一个默认的路由引擎
	r := gin.Default()
    // 引用静态文件
	r.Static("/static", "./static")
    渲染模板文件
	r.LoadHTMLGlob("templates/**/*")
    // 在8080端口启动HTTP服务
	r.Run(":8080")
}

JSON渲染

func main() {
    // 创建一个默认的路由引擎
	r := gin.Default()
    // 方法一：自己拼接
	r.GET("/someJSON", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"message": "wecunge"})
	})
    // 方法二：使用结构体
	r.GET("/moreJSON", func(c *gin.Context) {
		var msg struct {
			Name    string
			Message string
			Age     int
		}
		msg.Name = "wecunge"
		msg.Message = "wecunge is wecunge"
		msg.Age = 18
		c.JSON(http.StatusOK, msg)
	})
    // 在8080端口启动服务
	r.Run(":8080")
}

XML渲染

要使用带有具体名称的结构体

func main() {
    // 创建一个默认的路由引擎
	r := gin.Default()
    // 方式一：自己拼接
	r.GET("/someXML", func(c *gin.Context) {
		c.XML(http.StatusOK, gin.H{"message": "wecunge"})
	})
    // 方法二：使用结构体
	r.GET("/moreXML", func(c *gin.Context) {
		type MessageRecord struct {
			Name    string
			Message string
			Age     int
		}
		var msg MessageRecord
		msg.Name = "wecunge"
		msg.Message = "wecunge is wecunge"
		msg.Age = 18
		c.XML(http.StatusOK, msg)
	})
    // 在8080端口启动服务
	r.Run(":8080")
}

YMAL渲染

func main() {
    // 创建一个默认的路由引擎
	r := gin.Default()
    // 自己拼接
	r.GET("/someYAML", func(c *gin.Context) {
	    c.YAML(http.StatusOK, gin.H{"message": "wecunge", "status": http.StatusOK})
    })
    // 在8080端口启动服务
	r.Run(":8080")
}

获取参数

获取querystring参数

func main() {
	// Default返回一个默认的路由引擎
	r := gin.Default()
	r.GET("/user/search", func(c *gin.Context) {
        // 设置默认值为wecunge
		username := c.DefaultQuery("username", "wecunge")
		address := c.Query("wecunge's home")
        // 返回获取的值
		c.JSON(http.StatusOK, gin.H{
			"message":  "wecunge",
			"username": username,
			"address":  address,
		})
	})
    // 在8080端口启动服务
	r.Run("8080")
}

获取form参数

func main() {
	//Default返回一个默认的路由引擎
	r := gin.Default()
	r.POST("/user/search", func(c *gin.Context) {
		// 设置默认值为wecunge
		username := c.DefaultPostForm("username", "wecunge")
		address := c.PostForm("wecunge's home")
		//返回获取到的值
		c.JSON(http.StatusOK, gin.H{
			"message":  "wecunge",
			"username": username,
			"address":  address,
		})
	})
    // 在8080端口启动服务
	r.Run(":8080")
}

获取JSON参数

func main() {
	//Default返回一个默认的路由引擎
	r := gin.Default()
	r.POST("/json", func(c *gin.Context) {
        // 从c.Request.Body读取请求数据
	    b, _ := c.GetRawData()
	    // 定义map或结构体
	    var m map[string]interface{}
	    // 反序列化
	    _ = json.Unmarshal(b, &m)
	    c.JSON(http.StatusOK, m)
    })
    // 在8080端口启动服务
	r.Run(":8080")
}

获取path参数

func main() {
	//Default返回一个默认的路由引擎
	r := gin.Default()
	r.GET("/user/search/:username/:address", func(c *gin.Context) {
		username := c.Param("username")
		address := c.Param("address")
		//返回获取到的值
		c.JSON(http.StatusOK, gin.H{
			"message":  "ok",
			"username": username,
			"address":  address,
		})
	})
    // 在8080端口启动服务
	r.Run(":8080")
}

参数绑定

type Login struct {
	User     string `form:"user" json:"user" binding:"required"`
	Password string `form:"password" json:"password" binding:"required"`
}

func main() {
    // 创建默认的路由引擎
	router := gin.Default()
    // 绑定json
	router.POST("/loginJSON", func(c *gin.Context) {
		var login Login
		if err := c.ShouldBind(&login); err == nil {
			c.JSON(http.StatusOK, gin.H{
				"user":     login.User,
				"password": login.Password,
			})
		} else {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		}
	})
    // 绑定form
	router.POST("/loginForm", func(c *gin.Context) {
		var login Login
		if err := c.ShouldBind(&login); err == nil {
			c.JSON(http.StatusOK, gin.H{
				"user":     login.User,
				"password": login.Password,
			})
		} else {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		}
	})
    // 绑定QueryString
	router.GET("/loginForm", func(c *gin.Context) {
		var login Login
		if err := c.ShouldBind(&login); err == nil {
			c.JSON(http.StatusOK, gin.H{
				"user":     login.User,
				"password": login.Password,
			})
		} else {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		}
	})

	// 在8080端口启动服务
	router.Run(":8080")
}

文件上传

单个文件上传

func main() {
    // 创建默认的路由引擎
	router := gin.Default()

	router.POST("/upload", func(c *gin.Context) {
		// 单个文件
		file, err := c.FormFile("wecunge") // wecunge:文件名
		if err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{
				"message": err.Error(),
			})
			return
		}

		dst := fmt.Sprintf("E:%s", file.Filename)
        // 上传到指定目录
		c.SaveUploadedFile(file, dst)
		c.JSON(http.StatusOK, gin.H{
			"message": fmt.Sprintf("'%s' uploaded", file.Filename),
		})
	})
	// 在8080端口启动服务
	router.Run(":8080")
}

多个文件上传

func main() {
    // 创建默认的路由引擎
	router := gin.Default()
	router.POST("/upload", func(c *gin.Context) {
		form, _ := c.MultipartForm()
		files := form.File["file"]

		for index, file := range files {
            // 上传到指定目录
			dst := fmt.Sprintf("E:%s_%d", file.Filename, index)
			c.SaveUploadedFile(file, dst)
		}
		c.JSON(http.StatusOK, gin.H{
			"message": fmt.Sprintf("%d files uploaded!", len(files)),
		})
	})
	// 在8080端口启动服务
	router.Run(":8080")
}

重定向

HTTP重定向

func main() {
    // 创建默认的路由引擎
	router := gin.Default()
	r.GET("/test", func(c *gin.Context) {
        // 重定向到jiaking.top
	    c.Redirect(http.StatusMovedPermanently, "http://jiaking.top")
    })
	// 在8080端口启动服务
	router.Run(":8080")
}

路由重定向

路由重定向，使用HandleContext：

func main() {
    // 创建默认的路由引擎
	router := gin.Default()
	r.GET("/one", func(c *gin.Context) {
        // 指定重定向的URL
        c.Request.URL.Path = "/two"
        r.HandleContext(c)
    })
    r.GET("/two", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"wecun": "wecunge"})
    })
    // 在8080端口启动服务
	router.Run("8080")
}

Gin路由

普通路由

r.GET("/", func(c *gin.Context) {...})
r.GET("/", func(c *gin.Context) {...})
r.POST("/", func(c *gin.Context) {...})
// 匹配所有的请求方法
r.Any("/", func(c *gin.Context) {...})

为所有的未匹配的路由返回wecunge.html界面

r.NoRoute(func(c *gin.Context) {
    c.HTML(http.StatusNotFound, wecunge.html", nil)
})

路由组

func main() {
    // 创建默认的路由引擎
	r := gin.Default()
	userGroup := r.Group("/user")
	{
        // 所有以/user开头的路由
		userGroup.GET("/index", func(c *gin.Context) {...})
		userGroup.GET("/login", func(c *gin.Context) {...})
		userGroup.POST("/login", func(c *gin.Context) {...})

	}
	shopGroup := r.Group("/shop")
	{
        // 所有以/shop开头的路由
		shopGroup.GET("/index", func(c *gin.Context) {...})
		shopGroup.GET("/cart", func(c *gin.Context) {...})
		shopGroup.POST("/checkout", func(c *gin.Context) {...})
	}
    在8080端口启动服务
	r.Run("8080")
}

Gin中间件

Gin中的中间件必须是一个gin.HandlerFunc类型。

func Auth() gin.HandlerFunc {
	return func(c *gin.Context) {
        ...
	}
}

注册中间件

为全局路由注册

func main() {
	// 创建一个默认的路由
	r := gin.Default()
	// 注册一个全局中间件
	r.Use(Auth())
	
	r.GET("/test", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{
			"message": "wecunge",
		})
	})

    // 在8080端口启动服务
	r.Run("8080")
}

为某个路由单独注册

r.GET("/test", Auth(), func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{
		"message": "wecunge",
	})
})

为路由组注册中间件

func main() {
    // 创建默认的路由引擎
	r := gin.Default()
    // 方法一
	userGroup := r.Group("/user", Auth())
	{
        // 所有以/user开头的路由
		userGroup.GET("/index", func(c *gin.Context) {...})
		userGroup.GET("/login", func(c *gin.Context) {...})
		userGroup.POST("/login", func(c *gin.Context) {...})

	}
    // 方法二
	shopGroup := r.Group("/shop")
    shopGroup.Use(Auth())
	{
        // 所有以/shop开头的路由
		shopGroup.GET("/index", func(c *gin.Context) {...})
		shopGroup.GET("/cart", func(c *gin.Context) {...})
		shopGroup.POST("/checkout", func(c *gin.Context) {...})
	}
    在8080端口启动服务
	r.Run("8080")
}