响应数据

响应字符串

func UserHandle(ctx *gin.Context) {
	ctx.String(http.StatusOK, "hello world")
}

响应`JSON`

使用结构体

可以通过json tag来设置返回数据的别名，格式如下，这样返回的json数据的key就是设置的别名

type User struct {
  UserName string `json:"user_name"`
}

WARNING

json:"xxx"，json:和"之间不能有空格
字段别名如user_name一定要用双引号包裹

如果不想让结构体中的某个字段返回，有以下方法
- 定义结构体时，字段名称小写
- 定义json tag时，使用-

type User struct {
  UserName string
  password string // password 小写后，返回的数据就不会包含这个字段
  Age int
}
// 或者
type User struct {
  UserName string `json:"user_name"`
  Password string `json:"-"` // json tag中定义"-"，该字段也不会返回
  Age int `json:"age"`
}

// 处理json
func jsonHandler(ctx *gin.Context) {
	type User struct {
		UserName string `json:"user_name"`
		Password string `json:"-"`
		Age int `json:"age"`
	}
	user := User{ "张三", "123456", 22}
	ctx.JSON(http.StatusOK, user)
}

响应如下：

json

{
    "user_name": "张三",
    "age": 22
}

使用`map`

// 处理map
func mapHandler(ctx *gin.Context) {
	user1 := map[string]string{
		"userName": "张三",
		"age": "22",
		"like": "乒乓球",
	}
	ctx.JSON(http.StatusOK, user1)
}

响应如下：

json

{
    "age": "22",
    "like": "乒乓球",
    "userName": "张三"
}

直接响应`JSON`

使用gin.H{}来直接响应json数据

// 处理json
func jsonHandler(ctx *gin.Context) {
	ctx.JSON(http.StatusOK, gin.H{
		"user_name": "流失",
		"age": 22,
		"like": []string{"乒乓球", "羽毛球"},
	})
}

响应如下：

json

{
    "age": 22,
    "like": [
        "乒乓球",
        "羽毛球"
    ],
    "user_name": "流失"
}

响应`XML`

字符串返回

// 响应xml
func xmlHandler(ctx *gin.Context) {
	ctx.XML(http.StatusOK, "hello world")
}

响应如下：

xml

<string>hello world</string>

结构体返回

// 响应xml
func xmlHandler(ctx *gin.Context) {
	type User struct {
		UserName string
		Password string
		Age int
	}
	user := User{ "张三", "123456", 22}
	ctx.XML(http.StatusOK, user)
}

响应如下：

xml

<User>
    <UserName>张三</UserName>
    <Password>123456</Password>
    <Age>22</Age>
</User>

修改响应的xml字段，并隐藏某些字段

func xmlHandler(ctx *gin.Context) {
	type User struct {
		UserName string `xml:"user_name"`
		Password string `xml:"-"`
		Age int `xml:"age"`
	}
	user := User{ "张三", "123456", 22}
	ctx.XML(http.StatusOK, user)
}

响应如下:

xml

<User>
    <user_name>张三</user_name>
    <age>22</age>
</User>

通过`gin.H`返回

// 响应xml
func xmlHandler(ctx *gin.Context) {
	ctx.XML(http.StatusOK, gin.H{
		"user_name": "流失",
		"age": 22,
		"like": []string{"乒乓球", "羽毛球"},
	})
}

响应如下：

xml

<map>
    <age>22</age>
    <like>乒乓球</like>
    <like>羽毛球</like>
    <user_name>流失</user_name>
</map>

响应`yaml`

结构体返回

// 响应xml
func yamlHandler(ctx *gin.Context) {
	type User struct {
		UserName string
		Password string
		Age int
	}
	user := User{ "张三", "123456", 22}
	ctx.YAML(http.StatusOK, user)
}

响应如下：

yaml

username: 张三
password: "123456"
age: 22

修改响应的yaml字段，并隐藏某些字段

// 响应yaml
func yamlHandler(ctx *gin.Context) {
	type User struct {
		UserName string `yaml:"user_name"`
		Password string `yaml:"-"`
		Age int `yaml:"age"`
	}
	user := User{ "张三", "123456", 22}
	ctx.YAML(http.StatusOK, user)
}

响应如下：

yaml

user_name: 张三
age: 22

通过`gin.H`返回

// 响应xml
func yamlHandler(ctx *gin.Context) {
	ctx.YAML(http.StatusOK, gin.H{
		"user_name": "流失",
		"age": 22,
		"like": []string{"乒乓球", "羽毛球"},
	})
}

响应如下：

yaml

age: 22
like:
    - 乒乓球
    - 羽毛球
user_name: 流失=

响应`HTML`

响应html之前，需要先加载html模板文件，然后才能响应html，可以使用如下两种方法

//  使用glob规则匹配并加载所有的html模板
func (*gin.Engine).LoadHTMLGlob(pattern string)

// 加载多个html文件
func (*gin.Engine).LoadHTMLFiles(files ...string)

如果使用结构体定义数据让html接收，结构体中的变量名称首字母依旧需要大写

// 响应html
func htmlHandler(ctx *gin.Context) {
	type User struct {
		UserName string
		Age int
		Like []string
	}
	user := User{
		"张三",
		22,
		[]string {"乒乓球", "羽毛球"},
	}
	ctx.HTML(http.StatusOK, "user.html", user)
}
func main() {
	// 初始化路由
	router := gin.Default()
	// 加载所有的html模板
	router.LoadHTMLGlob("template/*")
	// router.LoadHTMLFiles("template/user.html", "template/xxx.html", ...)
	// 响应HTML
	router.GET("/get_html", htmlHandler)
	// 启动http服务并监听
	router.Run(":9100")
}

template/user.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>Document</title>
</head>
<body>
  <div id="app">
    <div class="name">我的名字是：{{ .UserName }}</div>
    <div class="name">我的年龄是：{{ .Age }}</div>
    <div class="name">
      <h2>我的爱好是：</h2>
      <ul>
        {{ range .Like }}
        <li>{{.}}</li>
        {{ end }}
      </ul>
    </div>
  </div>
</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>Document</title>
</head>

<body>
	<div id="app">
		<div class="name">我的名字是：张三</div>
		<div class="name">我的年龄是：22</div>
		<div class="name">
			<h2>我的爱好是：</h2>
			<ul>

				<li>乒乓球</li>

				<li>羽毛球</li>

			</ul>
		</div>
	</div>
</body>

</html>

响应文件

`Serving static files`提供静态文件服务

// relativePath 是指实际访问的路径，root是指服务器放置静态文件的路径，可以是一个目录路径，也可以是文件路径
func (*gin.RouterGroup).Static(relativePath string, root string) gin.IRoutes

//和 router.Static 一样，不过可以自定义文件系统目录 http.FileSystem, gin 默认使用的是 gin.Dir()
func (*gin.RouterGroup).StaticFS(relativePath string, fs http.FileSystem) gin.IRoutes

// 设置单个静态文件访问路径别名
func (*gin.RouterGroup).StaticFile(relativePath string, filepath string) gin.IRoutes

//和 router.StaticFile 一样，不过可以自定义文件系统目录 http.FileSystem, gin 默认使用的是 gin.Dir()
func (*gin.RouterGroup).StaticFileFS(relativePath string, filepath string, fs http.FileSystem) gin.IRoutes

代码示例：

func main() {
	// 初始化路由
	router := gin.Default()
	// 提供静态文件服务
	// 比如图片路径为 assets/img/ysy.jpeg assets/img/avatar.jpeg
	// 设置静态资源实际访问路径和实际存放文件的路径
	// /s 是指实际访问的路径，assets是指服务器放置静态文件的路径
	// 访问 http://ip:9100/s/img/ysy.jpeg 可以获取图片
	router.Static("/s", "assets")

	//和 router.Static 一样，不过可以自定义文件系统目录 http.FileSystem，gin 默认使用的是 gin.Dir()
	// 访问 http://ip:9100/ss/img/ysy.jpeg 可以获取图片
	router.StaticFS("/ss", http.Dir("assets"))

	// 设置静态文件访问路径别名
	// 访问 http://ip:9100/y.jpeg  http://ip:9100/avatar.jpeg 可以获取图片
	router.StaticFile("avatar.jpeg", "assets/img/avatar.jpeg")
	router.StaticFile("y.jpeg", "assets/img/ysy.jpeg")

	//和 router.StaticFile 一样，不过可以自定义文件系统目录 http.FileSystem，gin 默认使用的是 gin.Dir()
	router.StaticFileFS("sfs.jpeg", "img/ysy.jpeg", http.Dir("assets"))
	
	// 启动http服务并监听
	router.Run(":9100")
}

`Serving data from file`返回文件数据

// ctx.File 从文件中读取数据并返回
func (*gin.Context).File(filepath string)

// ctx.FileAttachment 从文件中读取数据并返回，并且可以对返回的文件重命名
func (*gin.Context).FileAttachment(filepath string, filename string)

// FileFromFS将指定的文件从http.FileSystem高效地写入主体流。
func (*gin.Context).FileFromFS(filepath string, fs http.FileSystem)

代码示例：

func fileHanlder(ctx *gin.Context) {
	// ctx.File 从文件中提供数据
	// ctx.File("assets/img/ysy.jpeg")

	// ctx.FileAttachment  从文件中提供数据，并且可以对返回的文件重命名
	// ctx.FileAttachment("assets/img/ysy.jpeg", "a.jepg")
	
	// 将指定的文件从 http.FileSystem高效地写入主体流。
	var fs http.FileSystem = http.Dir("./")
	ctx.FileFromFS("assets/img/ysy.jpeg", fs)
}

func main() {
	// 初始化路由
	router := gin.Default()
	//响应文件
	router.GET("/get_file", fileHanlder)
	// 启动http服务并监听
	router.Run(":9100")
}

重定向

可以重定向到外部链接，如https://www.baidu.com
可以重定向到内部路由，如/get_html

func (*gin.Context).Redirect(code int, location string)

代码示例

func redirectHandler(ctx *gin.Context) {
  // 重定向到外部连接
	// ctx.Redirect(http.StatusMovedPermanently, "https://www.baidu.com")
	// 重定向到内部路由
	ctx.Redirect(http.StatusMovedPermanently, "/get_html")
}
func main() {
	// 初始化路由
	router := gin.Default()
	// 访问重定向
	router.GET("/get_redirect", redirectHandler)
	
	// 启动http服务并监听
	router.Run(":9100")
}

Babel

Vite

基础知识

文件操作

网络

Gin

Gorm

Logger

Logrus

Zap

Crawler

加密

响应数据

响应字符串

响应`JSON`

使用结构体

使用`map`

直接响应`JSON`

响应`XML`

字符串返回

结构体返回

通过`gin.H`返回

响应`yaml`

结构体返回

通过`gin.H`返回

响应`HTML`

响应文件

`Serving static files`提供静态文件服务

`Serving data from file`返回文件数据

重定向

文件操作

网络

Logrus

Zap

响应数据 #

响应字符串 #

响应JSON #

使用结构体 #

使用map #

直接响应JSON #

响应XML #

字符串返回 #

结构体返回 #

通过gin.H返回 #

响应yaml #

结构体返回 #

通过gin.H返回 #

响应HTML #

响应文件 #

Serving static files提供静态文件服务 #

Serving data from file返回文件数据 #

重定向 #

响应数据

响应字符串

响应`JSON`

使用结构体

使用`map`

直接响应`JSON`

响应`XML`

字符串返回

结构体返回

通过`gin.H`返回

响应`yaml`

结构体返回

通过`gin.H`返回

响应`HTML`

响应文件

`Serving static files`提供静态文件服务

`Serving data from file`返回文件数据

重定向