web开发
Gin框架
官网：https://gin-gonic.com/
文档：https://gin-gonic.com/zh-cn/docs/
安装
go get -u github.com/gin-gonic/gin
RESTful API
REST与技术无关，代表的是一种软件架构风格，REST是Representational State Transfer的简称，中文翻译为“表征状态转移”或“表现层状态转化”。
推荐阅读阮一峰 理解RESTful架构
简单来说，REST的含义就是客户端与Web服务器之间进行交互的时候，使用HTTP协议中的4个请求方法代表不同的动作。
GET用来获取资源
POST用来新建资源
PUT用来更新资源
DELETE用来删除资源。开发RESTful API的时候我们通常使用Postman来作为客户端的测试工具。
具体实例
package main
import "github.com/gin-gonic/gin"
func main() {
r := gin.Default()
r.GET("/book", func(c *gin.Context) {
c.JSON(200, gin.H{
"mgs": "GET",
})
})
r.POST("/book", func(c *gin.Context) {
c.JSON(200, gin.H{
"mgs": "POST",
})
})
r.PUT("/book", func(c *gin.Context) {
c.JSON(200, gin.H{
"mgs": "PUT",
})
})
r.DELETE("/book", func(c *gin.Context) {
c.JSON(200, gin.H{
"mgs": "DELETE",
})
})
r.Run(":8888")
}
模板渲染
一系列操作具体看代码注释
r := gin.Default()
//定义静态文件
r.Static("/static", "./statics")
//模板定义
//在解析之前自定一个函数
r.SetFuncMap(template.FuncMap{
"safe": func(str string) template.HTML {
return template.HTML(str)
},
})
// 模板解析
r.LoadHTMLGlob("template/**/*")
//模板渲染r.GET("/users/index", func(c *gin.Context) {
c.HTML(http.StatusOK, "users/index.tmpl", gin.H{
"title": "<a href='https://www.baidu.com'>百度</a>",
})
})
r.GET("/posts/index", func(c *gin.Context) {
c.HTML(http.StatusOK, "posts/index.tmpl", gin.H{
"title": "<a href='https://www.baidu.com'>百度</a>",
})
})
r.Run(":8000")
JSON渲染
第一种方式
使用map
func main() {
r := gin.Default()
//自己定义个map
//data := map[string]interface{}{
// "name": "haojuetrace",
// "age": 18,
// "sex": "男",
//}
//使用gin框架定义的map
data := gin.H{
"name": "haojuetrace",
"age": 18,
"sex": "男",
}
r.GET("/map_json", func(c *gin.Context) {
c.JSON(http.StatusOK, data)//json渲染
})
r.Run(":9090")
}
第二种方式
使用结构体
func main() {
r := gin.Default()
//使用结构体
type mgs struct { //切记字段必须大写开头，因为是json包解析的
Name string `json:"name"` //根据需求指定
Age int
Sex string
}
data := mgs{
"浩哥哥",
18,
"男",
}
r.GET("/map_json", func(c *gin.Context) {
c.JSON(http.StatusOK, data) //json渲染
})
r.Run(":9090")
}
获取参数
获取querystring参数
//querystring
//GET请求 URl ?后面的是querystring参数
//key=value格式，多个key=value用 & 连接
//by； /web?query=haojuetrace&age=18
func main() {
r := gin.Default()
r.GET("/web", func(c *gin.Context) {
//name := c.Query("query") //获取的第一种方式
//name := c.DefaultQuery("query", "somebody") //获取的第二种方式
name, ok := c.GetQuery("query")
if !ok {
name = "somebody"
}
c.JSON(http.StatusOK, gin.H{
"name": name,
})
})
r.Run(":9090")
}
From表单
总共三种方式具体见代码
main.go
package main
import (
"github.com/gin-gonic/gin"
"net/http"
)
func main() {
r := gin.Default()
r.LoadHTMLFiles("./login.html") //解析模板
r.GET("/login", func(c *gin.Context) {
c.HTML(http.StatusOK, "login.html", nil) //渲染模板
})
//username和password对应的是表单name
r.POST("/login", func(c *gin.Context) {
//username := c.PostForm("username") //第一种方式
//password := c.PostForm("password")
//username := c.DefaultPostForm("username", "xiaomi") //第二种方式
//password := c.DefaultPostForm("password", "")
username, ok := c.GetPostForm("username") //第三种方式
if !ok {
username = "zhangsan"
}
password, ok := c.GetPostForm("password")
if !ok {
password = "123456"
}
c.JSON(http.StatusOK, gin.H{
"username": username,
"password": password,
})
})
r.Run(":9090")
}
login.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
<style>
* {
margin: 0;
padding: 0;
}
html {
height: 100%;
}
body {
height: 100%;
}
.container {
height: 100%;
background-image: linear-gradient(to right, #fbc2eb, #a6c1ee);
}
.login-wrapper {
background-color: #fff;
width: 358px;
height: 588px;
border-radius: 15px;
padding: 0 50px;
position: relative;
left: 50%;
top: 50%;
transform: translate(-50%, -50%);
}
.header {
font-size: 38px;
font-weight: bold;
text-align: center;
line-height: 200px;
}
.input-item {
display: block;
width: 100%;
margin-bottom: 20px;
border: 0;
padding: 10px;
border-bottom: 1px solid rgb(128, 125, 125);
font-size: 15px;
outline: none;
}
.input-item:placeholder {
text-transform: uppercase;
}
.btn {
text-align: center;
padding: 10px;
width: 100%;
margin-top: 40px;
background-image: linear-gradient(to right, #a6c1ee, #fbc2eb);
color: #fff;
}
.msg {
text-align: center;
line-height: 88px;
}
a {
text-decoration-line: none;
color: #abc1ee;
}
.input-submit{
text-decoration: none;
/*background-color: #fbc2eb;*/
width: 50px;
cursor: pointer;
border: none;
display: block;
color: #007bff;
outline: none;
}
</style>
</head>
<body>
<div class="container">
<div class="login-wrapper">
<div class="header">Login</div>
<form action="/login" method="post">
<div class="form-wrapper">
<input type="text" name="username" placeholder="username" class="input-item">
<input type="password" name="password" placeholder="password" class="input-item">
<div class="btn">
<input type="submit" value="Login" class="input-submit">
</div>
</div>
</form>
<div class="msg">
Don't have account?
<<a href="#">Sign up</a>>
</div>
</div>
</div>
</body>
</html>
path参数获取
//注意获取到的都是字符串
func main() {
r := gin.Default()
r.GET("/:name/:age", func(c *gin.Context) {
name := c.Param("name") //获取路径上的参数
age := c.Param("age") //获取路径上的参数
c.JSON(http.StatusOK, gin.H{
"name": name,
"age": age,
})
})
r.Run(":9090")
}
参数绑定
package main
import (
"fmt"
"github.com/gin-gonic/gin"
"net/http"
)
type User struct {
Name string `form:"name" json:"name"` //必须要有tag 字段名必须是大写
Age string `form:"age" json:"age"`
}
func main() {
r := gin.Default()
r.GET("/query", func(c *gin.Context) {
var u User
fmt.Println(c.Query("name"))
err := c.ShouldBind(&u) //解析
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{
"request": "404",
})
} else {
c.JSON(http.StatusOK, gin.H{
"request": "200",
"data": u,
})
}
})
//除了请求不一样 ， 其他都一样的
r.POST("/json", func(c *gin.Context) {
var u User
err := c.ShouldBind(&u)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{
"request": "404",
})
} else {
c.JSON(http.StatusOK, gin.H{
"request": "200",
"data": u,
})
}
})
//除了请求不一样 ， 其他都一样的
r.POST("/from", func(c *gin.Context) {
var u User
err := c.ShouldBind(&u)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{
"request": "404",
})
} else {
c.JSON(http.StatusOK, gin.H{
"request": "200",
"data": u,
})
}
})
r.Run(":9090")
}
文件上传
前段代码
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>fileUpLoad</title>
</head>
<body>
<form action="/upload" method="post" enctype="multipart/form-data">
<div>
<input type="file" name="f1">
</div>
<div>
<input type="file" name="f1">
</div>
<input type="submit" value="上传">
</form>
</body>
</html>
上传一个文件
r.POST("/upload", func(c *gin.Context) {
//上传单个文件
file, err := c.FormFile("f1")
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{
"status": err.Error(),
})
} else {
dst := path.Join("./", file.Filename)
c.SaveUploadedFile(file, dst)
c.JSON(http.StatusOK, gin.H{
"status": 200,
})
}
})
上传多个文件
r.POST("/upload", func(c *gin.Context) {
//上传多个文件
form, err := c.MultipartForm()
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{
"status": err.Error(),
})
} else {
files := form.File["f1"]
for _, file := range files {
dst := path.Join("./", file.Filename)
c.SaveUploadedFile(file, dst)
}
c.JSON(http.StatusOK, gin.H{
"massage:": fmt.Sprintf("%d upload", len(files)),
})
}
})
重定向
HTTP重定向
func main() {
r := gin.Default()
r.GET("/index1", func(c *gin.Context) {
c.Redirect(http.StatusMovedPermanently, "https://www.baidu.com/")
})
r.Run(":9090")
}
路由重定向
r.GET("/a", func(c *gin.Context) {
c.Request.URL.Path = "/b"
r.HandleContext(c)
})
r.GET("/b", func(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{
"mgs:": "bbbbbbb",
})
})
路由
普通路由
package main
import (
"github.com/gin-gonic/gin"
"net/http"
)
func main() {
r := gin.Default()
r.GET("/index", func(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{
"msg": "GET",
})
})
r.POST("/index", func(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{
"msg": "POST",
})
})
r.PUT("/index", func(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{
"msg": "PUT",
})
})
r.DELETE("/index", func(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{
"msg": "DELETE",
})
})
//Any能够接受大部分路由类型的请求
r.Any("/user", func(c *gin.Context) {
switch c.Request.Method {
case http.MethodGet:
c.JSON(http.StatusOK, gin.H{
"msg": "GET",
})
case http.MethodPost:
c.JSON(http.StatusOK, gin.H{
"msg": "POST",
})
case http.MethodDelete:
c.JSON(http.StatusOK, gin.H{
"msg": "DELETE",
})
case http.MethodPut:
c.JSON(http.StatusOK, gin.H{
"msg": "PUT",
})
}
})
//NoRoute
//当访问的url路径没有路由则执行
r.NoRoute(func(c *gin.Context) {
c.Redirect(http.StatusMovedPermanently, "http://www.baidu.com")
})
r.Run(":9090")
}
路由组
//路由组
//当有不同的业务线的时候使用
videoGroup := r.Group("/video")
{
videoGroup.GET("/index", func(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{
"msg": "/video/index",
})
})
videoGroup.GET("/xx", func(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{
"msg": "/video/xx",
})
})
}
//路由组也可以嵌套
videoGroup := r.Group("/video")
{
videoGroup.GET("/index", func(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{
"msg": "/video/index",
})
})
videoGroup.GET("/xx", func(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{
"msg": "/video/xx",
})
})
xxGroup := videoGroup.Group("/xx")
{
xxGroup.GET("/index", func(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{
"msg": "/video/xx/index",
})
})
}
}
中间件
定义中间件
Gin中的中间件必须是一个
gin.HandlerFunc类型。
//定义一个计算请求耗时的中间件
func m1(c *gin.Context) {
fmt.Println("m1 in......")
//定义时间
startTime := time.Now()
//调用请求函数
c.Next() //调用下一个请求函数
//c.Abort() // 不调用该请求的剩余处理程序
//计算时间
stopTime := time.Since(startTime)
fmt.Println("time consuming ", stopTime)
fmt.Println("m1 out......")
}
跨域中间件cors
推荐使用社区的https://github.com/gin-contrib/cors 库，一行代码解决前后端分离架构下的跨域问题。
注意： 该中间件需要注册在业务处理函数前面。
注册中间件
为全局路由注册
r := gin.Default()
r.Use(m1) //全局注册中间件m1
r.GET("/index", indexFunc)
r.Run(":9090")
为某个路由单独注册
func main() {
r := gin.Default()
r.GET("/index", m1, indexFunc) //为此路由单独注册m1中间件
r.Run(":9090")
}
为路由组注册中间件
方法一：
shopGroup := r.Group("/shop", m1) //直接指定整个路由组的中间件
{
shopGroup.GET("/index", func(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{
"msg": "/shop/index",
})
})
}
方法二：
shopGroup := r.Group("/shop")
{
shopGroup.GET("/index", m1, func(c *gin.Context) { //指定路由组中单独的路由的中间件
c.JSON(http.StatusOK, gin.H{
"msg": "/shop/index",
})
})
}
中间件注意事项
gin默认中间件
gin.Default()默认使用了Logger和Recovery中间件，其中：
Logger中间件将日志写入gin.DefaultWriter，即使配置了GIN_MODE=release。Recovery中间件会recover任何panic。如果有panic的话，会写入500响应码。如果不想使用上面两个默认的中间件，可以使用
gin.New()新建一个没有任何默认中间件的路由。
gin中间件中使用goroutine
当在中间件或
handler中启动新的goroutine时，不能使用原始的上下文（c *gin.Context），必须使用其只读副本（c.Copy()）。
GORM
github：https://github.com/go-gorm/gorm
官网：https://gorm.io/
by：支持中文文档
官网文档：https://gorm.io/docs/
连接数据库
import (
"fmt"
"gorm.io/driver/mysql"
"gorm.io/gorm"
)
func main() {
dsn := "root:123456@tcp(127.0.0.1:3306)/school?charset=utf8mb4&parseTime=True&loc=Local"
db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
if err != nil {
fmt.Println(err)
return
}
}
创建数据表
import (
"fmt"
"gorm.io/driver/mysql"
"gorm.io/gorm"
)
func main() {
//创建一个数据数据表 自动迁移 （把结构体和数据表进行对应）
db.AutoMigrate(&student{})
}
插入数据
import (
"fmt"
"gorm.io/driver/mysql"
"gorm.io/gorm"
)
type student struct {
Id int
Name string
Age int
Sex string
}
func main() {
u1 := student{
Id: 1,
Name: "haojuetrace",
Age: 18,
Sex: "男",
}
db.Create(&u1) //插入一条数据
}
查询数据
import (
"fmt"
"gorm.io/driver/mysql"
"gorm.io/gorm"
)
type student struct {
Id int
Name string
Age int
Sex string
}
func main() {
var u2 student
db.First(&u2)
fmt.Printf("%#v\n", u2)
}
设计模型
文章评论