创建项目 z-wiki
新建main.go
package main
import (
"github.com/gin-gonic/gin"
)
func helloHandler(c *gin.Context) {
c.JSON(200, gin.H{
"message": "hello world!",
})
}
func main() {
// 初始化gin对象
g := gin.Default()
// 设置一个get请求,其URL为/hello,并实现简单的响应
g.GET("/hello", helloHandler)
// 启动服务
g.Run()
}
目录下执行
go mod init z-wiki
go mod tidy
运行
go run main.go
访问:http://localhost:8080/hello
设置启动端口
port := "9999"
g.Run(":" + port)
go get github.com/gin-contrib/cors
import "github.com/gin-contrib/cors"
func main() {
g := gin.Default()
corsConfig := cors.DefaultConfig()
corsConfig.AllowOrigins = []string{"http://www.psvmc.cn", "http://psvmc.cn"}
g.Use(cors.New(corsConfig))
g.Run()
}
g.Use(cors.Default())
等效于
corsConfig := cors.DefaultConfig()
corsConfig.AllowOrigins = []string{"*"}
g.Use(cors.New(corsConfig))
corsConfig := cors.DefaultConfig()
corsConfig.AllowOrigins = []string{"*"}
corsConfig.AllowHeaders = []string{"Content-Type", "Z-UserId"}
g.Use(cors.New(corsConfig))
main.go
package main
import (
"z-wiki/routers"
"github.com/gin-contrib/cors"
"github.com/gin-gonic/gin"
)
func main() {
// 初始化gin对象
g := gin.Default()
g.Use(cors.Default())
routers.LoadUser(g)
// 启动服务
g.Run()
}
routers/user_router.go
package routers
import "github.com/gin-gonic/gin"
func LoadUser(e *gin.Engine) {
e.GET("/user/info", helloHandler)
}
func helloHandler(c *gin.Context) {
c.JSON(200, gin.H{
"name": "小明",
})
}
访问:http://localhost:8080/user/info
注意:
对其他包暴露的方法首字母要大写。
我们想项目的根路由重定向到项目的static/index.html
中
手相添加静态目录
// 设置静态文件目录
g.Static("/static", "./static")
添加路由重定向
routers/index_router.go
package routers
import (
"github.com/gin-gonic/gin"
)
func LoadIndex(e *gin.Engine) {
e.GET("/", func(c *gin.Context) {
// 重定向到新的路由
c.Redirect(301, "/static")
})
}
加载路由
routers.LoadIndex(g)
c.Query("userid")
c.Param("userid")
在 Gin 框架中,你可以使用 ShouldBindJSON()
方法来获取 POST 请求中的 JSON 参数。
以下是一个示例代码,演示如何在 Go 中使用 Gin 框架获取请求的 JSON 参数:
假设有一个 POST 请求发送了一个 JSON 参数,如 {"name": "Alice", "age": 30}
。
package main
import (
"github.com/gin-gonic/gin"
"net/http"
)
type Person struct {
Name string `json:"name"`
Age int `json:"age"`
}
func main() {
r := gin.Default()
r.POST("/person", func(c *gin.Context) {
var person Person
if err := c.ShouldBindJSON(&person); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
c.JSON(http.StatusOK, gin.H{
"name": person.Name,
"age": person.Age,
})
})
r.Run(":9999")
}
在上面的示例中,我们定义了一个 Person
结构体来表示 JSON 中的参数。在路由 /person
中,我们使用 ShouldBindJSON()
方法将请求的 JSON 参数绑定到 person
变量中。如果绑定成功,则返回 JSON 格式的姓名和年龄信息;如果绑定失败,则返回错误信息。
当发送 POST 请求到 http://localhost:9999/person
并携带 JSON 参数时,Gin 框架将解析请求中的 JSON 参数,并将其存储在 person
变量中。然后我们可以通过 person.Name
和 person.Age
访问参数的值。
file, err := c.FormFile("file")
userid := c.PostForm("userid")
userId := c.Request.Header.Get("Z-UserId")
file_router.go
package routers
import (
"fmt"
"github.com/gin-gonic/gin"
"github.com/google/uuid"
"os"
"path"
"path/filepath"
"strings"
"time"
"z-wiki/model"
)
func LoadFile(e *gin.Engine) {
e.POST("/file/upload", uploadHandler)
}
func uploadHandler(c *gin.Context) {
file, err := c.FormFile("file")
userid := c.PostForm("userid")
fmt.Println("userid:", userid)
if err != nil {
c.JSON(200, model.ResultVo[string]{Code: 1, Msg: "未找到文件", Obj: ""})
return
}
dateStr := time.Now().Format("200601")
pathStr := path.Join("static", "upload", dateStr)
err = os.MkdirAll(pathStr, os.ModePerm)
if err != nil {
c.JSON(200, model.ResultVo[string]{Code: 1, Msg: "上传失败", Obj: ""})
return
}
uuidStr := uuid.New().String()
fileExt := filepath.Ext(file.Filename)
filePathAll := path.Join(pathStr, uuidStr+strings.ToLower(fileExt))
fmt.Println("filePathAll", filePathAll)
err = c.SaveUploadedFile(file, filePathAll)
if err != nil {
c.JSON(200, model.ResultVo[string]{Code: 1, Msg: "上传失败", Obj: ""})
return
}
c.JSON(200, model.ResultVo[string]{Code: 0, Msg: "上传成功", Obj: filePathAll})
}
resultvo.go
package model
type ResultVo[T any] struct {
Code int `json:"code"`
Msg string `json:"msg"`
Obj T `json:"obj"`
}
config/config.json
{
"port":"8888",
"db_host": "dbtest.psvmc.cn",
"db_user": "zhangjian",
"db_pwd": "Test_123456"
}
utils/config_reader.go
package utils
import (
"encoding/json"
"fmt"
"os"
)
type Config struct {
PORT string `json:"port"`
DBHost string `json:"db_host"`
DBUser string `json:"db_user"`
DBPwd string `json:"db_pwd"`
}
func ReadConfig() *Config {
file, err := os.Open("config/config.json")
if err != nil {
fmt.Println("Failed to open config file:", err)
return nil
}
defer file.Close()
decoder := json.NewDecoder(file)
config := Config{}
err = decoder.Decode(&config)
if err != nil {
fmt.Println("Failed to decode config file:", err)
return nil
}
return &config
}
config := utils.ReadConfig()
if config == nil {
return
}
fmt.Println("-----------------------------")
fmt.Println("PORT:", config.PORT)
fmt.Println("DBHost:", config.DBHost)
fmt.Println("DBUser:", config.DBUser)
fmt.Println("DBPwd:", config.DBPwd)
fmt.Println("-----------------------------")
package main
import (
"encoding/json"
"fmt"
)
type Person struct {
Name string
Age int
}
func Json2Str() {
person := Person{Name: "Alice", Age: 30}
jsonData, err := json.Marshal(person)
if err != nil {
fmt.Println("转换失败:", err)
return
}
jsonString := string(jsonData)
fmt.Println("Json2Str:", jsonString)
}
func Str2Json() {
str := `{"Name": "Alice", "Age": 30}`
var person Person
err := json.Unmarshal([]byte(str), &person)
if err != nil {
fmt.Println("转换失败:", err)
return
}
fmt.Printf("Str2Json:%+v\n", person)
}