GoFrame 安装

安装

golang版本 >= 1.20

1
2
3
4
5
#初始化go.mod
go mod init

# 安装gf
go get -u -v github.com/gogf/gf/v2

导入

1
2
3
import (
	"github.com/gogf/gf/v2/frame/g"
)

快速开始

1
2
3
4
5
6
7
8
9
10
11
12
package main

import (
	"fmt"

    "github.com/gogf/gf/v2"
)

func main() {
	
    fmt.Println("Hello GoFrame:", gf.VERSION)
}

运行

1
go run main.go

输出

1
Hello GoFrame: 2.9.0

获取请求参数

1
2
3
4
5
6
7
8
9
10
11
12
package main

import (
	"fmt"

    "github.com/gogf/gf/v2"
)

func main() {
    ctx := gctx.New()
    fmt.Println(ctx.Request().Get("name"))
}

请求数据结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import (
	"fmt"

    "github.com/gogf/gf/v2"
)

type Request struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    ctx := gctx.New()
    var req Request
    ctx.Request().Parse(&req)
    fmt.Println(req)
}

响应数据结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main

import (
	"fmt"

    "github.com/gogf/gf/v2"
)

type Response struct {
    Code int         `json:"code"`
    Msg  string      `json:"msg"`
    Data interface{} `json:"data"`
}

func main() {
    ctx := gctx.New()
    var req Request
    ctx.Request().Parse(&req)
    fmt.Println(req)
}

路由

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import (
	"fmt"

    "github.com/gogf/gf/v2"
)

func main() {
    ctx := gctx.New()
    var req Request
    ctx.Request().Parse(&req)
    fmt.Println(req)
}

路由

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package main

import (
	"fmt"

    "github.com/gogf/gf/v2"
)

type HelloReq struct {
    g.Meta `path:"/" method:"get"`
    Name   string `v:"required" dc:"姓名"`
    Age    int    `v:"required" dc:"年龄"`
}

type HelloRes struct {
    Code int         `json:"code"`
    Msg  string      `json:"msg"`
    Data interface{} `json:"data"`
}

func Hello(ctx context.Context, req *HelloReq) (res *HelloRes, err error) {
    return &HelloRes{
        Code: 0,
        Msg:  "success",
        Data: map[string]interface{}{
            "name": req.Name,
            "age":  req.Age,
        },
    }, nil
}

func main() {
    ctx := gctx.New()
    var req HelloReq
    ctx.Request().Parse(&req)
    fmt.Println(req)
    res, err := Hello(ctx, &req)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(res)
}

中间价

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package main

import (
	"fmt"

    "github.com/gogf/gf/v2"
)

func main() {
    ctx := gctx.New()
    var req HelloReq
    ctx.Request().Parse(&req)
    fmt.Println(req)
    res, err := Hello(ctx, &req)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(res)
}

func Middleware(ctx context.Context) (err error) {
    fmt.Println("Middleware")
    return nil
}

func Hello(ctx context.Context, req *HelloReq) (res *HelloRes, err error) {
    return &HelloRes{
        Code: 0,
        Msg:  "success",
        Data: map[string]interface{}{
            "name": req.Name,
            "age":  req.Age,
        },
    }, nil
}

func init() {
    g.Server().AddMiddleware(Middleware)
    g.Server().AddHandler("/hello", Hello)

}