GoFrame

https://goframe.org/docs/
Admin
GoFrame is a modular, high-performance web application framework for Go that provides development...
Tokens:513,340
Snippets:4,314
Trust Score:8.6
Update:1 month ago
Show doc for...
Tokens:
Raw
### CLI installation interaction example

Source: https://goframe.org/docs/cli/install

Shows the interactive prompt when running the install command to select a destination directory.

```text
$ ./gf_darwin_amd64 install  
I found some installable paths for you(from $PATH):  
  Id | Writable | Installed | Path  
   0 |     true |      true | /usr/local/bin  
   1 |     true |     false | /Users/john/Workspace/Go/GOPATH/bin  
   2 |     true |     false | /Users/john/.gvm/bin  
   4 |     true |     false | /Users/john/.ft  
please choose one installation destination [default 0]:  
gf binary is successfully installed to: /usr/local/bin  
```

--------------------------------

### gf init Command Usage Examples

Source: https://goframe.org/docs/cli/init

Various ways to initialize a project, including standard creation, mono-repo setups, and remote template usage.

```bash
gf init my-project
gf init my-mono-repo -m
gf init my-mono-repo -a
gf init my-project -u
gf init my-project -g "github.com/myorg/myproject"
gf init -r github.com/gogf/template-single my-project
gf init -r github.com/gogf/examples/httpserver/jwt my-jwt
gf init -r github.com/gogf/gf/cmd/gf/v2@v2.9.7 mygf
gf init -r github.com/gogf/gf/cmd/gf/v2 mygf -s
gf init -i
```

--------------------------------

### Logger Configuration Examples

Source: https://goframe.org/docs/core/glog-config

Examples showing basic default configuration and multi-logger configuration setups.

```yaml
logger:  
  path:    "/var/log"  
  level:   "all"  
  stdout:  false  
```

```yaml
logger:  
  path:    "/var/log"  
  level:   "all"  
  stdout:  false  
  logger1:  
    path:    "/var/log/logger1"  
    level:   "dev"  
    stdout:  false  
  logger2:  
    path:    "/var/log/logger2"  
    level:   "prod"  
    stdout:  true  
```

--------------------------------

### Redis Configuration Examples

Source: https://goframe.org/docs/components/contrib-nosql-redis-config

YAML configuration examples for single-instance and cluster-mode Redis setups.

```yaml
# Redis 配置示例  
redis:  
  # 单实例配置示例1  
  default:  
    address: 127.0.0.1:6379  
    db:      1  
  
  # 单实例配置示例2  
  cache:  
    address:     127.0.0.1:6379  
    db:          1  
    pass:        123456  
    idleTimeout: 600  
```

```yaml
# Redis 配置示例  
redis:  
   # 集群模式配置方法  
  default:  
    address: 127.0.0.1:6379,127.0.0.1:6370  
    db:      1  
```

```yaml
# Redis 配置示例  
redis:  
  # 单实例配置示例1  
  default:  
    address: 127.0.0.1:6379  
    db:      1  
    pass:    "password" # 在此配置密码, 没有可去掉  
```

--------------------------------

### Configuration File Example

Source: https://goframe.org/docs/web/response-template

Example content for the config.toml file used in the template example.

```toml
# Redis数据库配置  
[redis]  
    disk  = "127.0.0.1:6379,0"  
    cache = "127.0.0.1:6379,1"  
```

--------------------------------

### Hierarchical Router Group Registration Example

Source: https://goframe.org/docs/web/router-registering-group

Demonstrates a complete setup using middleware, hooks, and various HTTP methods within nested router groups.

```go
package main  
  
import (  
    "fmt"  
    "net/http"  
  
    "github.com/gogf/gf/v2/frame/g"  
    "github.com/gogf/gf/v2/net/ghttp"  
)  
  
func MiddlewareAuth(r *ghttp.Request) {  
    if r.Get("token").String() != "123456" {  
        r.Response.WriteStatus(http.StatusForbidden)  
        return  
    }  
    r.Middleware.Next()  
}  
  
func MiddlewareCORS(r *ghttp.Request) {  
    r.Response.CORSDefault()  
    r.Middleware.Next()  
}  
  
func MiddlewareLog(r *ghttp.Request) {  
    r.Middleware.Next()  
    fmt.Println(r.Response.Status, r.URL.Path)  
}  
  
func main() {  
    s := g.Server()  
    s.Use(MiddlewareLog)  
    s.Group("/api.v2", func(group *ghttp.RouterGroup) {  
        group.Middleware(MiddlewareAuth, MiddlewareCORS)  
        group.GET("/test", func(r *ghttp.Request) {  
            r.Response.Write("test")  
        })  
        group.Group("/order", func(group *ghttp.RouterGroup) {  
            group.GET("/list", func(r *ghttp.Request) {  
                r.Response.Write("list")  
            })  
            group.PUT("/update", func(r *ghttp.Request) {  
                r.Response.Write("update")  
            })  
        })  
        group.Group("/user", func(group *ghttp.RouterGroup) {  
            group.GET("/info", func(r *ghttp.Request) {  
                r.Response.Write("info")  
            })  
            group.POST("/edit", func(r *ghttp.Request) {  
                r.Response.Write("edit")  
            })  
            group.DELETE("/drop", func(r *ghttp.Request) {  
                r.Response.Write("drop")  
            })  
        })  
        group.Group("/hook", func(group *ghttp.RouterGroup) {  
            group.Hook("/*", ghttp.HookBeforeServe, func(r *ghttp.Request) {  
                r.Response.Write("hook any")  
            })  
            group.Hook("/:name", ghttp.HookBeforeServe, func(r *ghttp.Request) {  
                r.Response.Write("hook name")  
            })  
        })  
    })  
    s.SetPort(8199)  
    s.Run()  
}  
```

--------------------------------

### Configuration File Example

Source: https://goframe.org/docs/cli/gen-pbentity

Example configuration for gf.gen.pbentity in config.yaml, supporting multiple database definitions.

```yaml
gfcli:
  gen:
  - pbentity:
        link:    "mysql:root:12345678@tcp(127.0.0.1:3306)/test"
        path:    "protocol/demos/entity"
        tables:  "order,products"
        package: "demos"
  - pbentity:
        link:    "mysql:root:12345678@tcp(127.0.0.1:3306)/primary"
        path:    "protocol/demos/entity"
        prefix:  "primary_"
        tables:  "user, userDetail"
        package: "demos"
        option:  |
          option go_package    = "protobuf/demos";
          option java_package  = "protobuf/demos";
          option php_namespace = "protobuf/demos";
        typeMapping:
          json:
            type: google.protobuf.Value
            import: google/protobuf/struct.proto
          jsonb:
            type: google.protobuf.Value
            import: google/protobuf/struct.proto
```

--------------------------------

### Controller lifecycle example

Source: https://goframe.org/docs/web/router-registering-struct

A complete example demonstrating how Init and Shut are executed during a request lifecycle.

```go
package main  
  
import (  
    "github.com/gogf/gf/v2/frame/g"  
    "github.com/gogf/gf/v2/net/ghttp"  
)  
  
type Controller struct{}  
  
func (c *Controller) Init(r *ghttp.Request) {  
    r.Response.Writeln("Init")  
}  
  
func (c *Controller) Shut(r *ghttp.Request) {  
    r.Response.Writeln("Shut")  
}  
  
func (c *Controller) Hello(r *ghttp.Request) {  
    r.Response.Writeln("Hello")  
}  
  
func main() {  
    s := g.Server()  
    c := new(Controller)  
    s.BindObject("/object", c)  
    s.SetPort(8199)  
    s.Run()  
}
```

--------------------------------

### Run Example and Observe Output

Source: https://goframe.org/docs/micro-service/config-service

Execution output showing the result of running the example application.

```bash
$ go run main.go  
true  
{}  
"failed to update local value: config file is empty"  
panic: failed to update local value: config file is empty  
  
goroutine 1 [running]:  
github.com/gogf/gf/v2/os/gcfg.(*Config).MustGet(0x0?, {0x1c1c4f8?, 0xc0000c2000?}, {0x1ac11ad?, 0x0?}, {0x0?, 0xc000002340?, 0xc000064738?})  
        /Users/john/Workspace/gogf/gf/os/gcfg/gcfg.go:167 +0x5e  
main.main()  
        /Users/john/Workspace/gogf/gf/example/config/polaris/main.go:20 +0x1b8  
```

```bash
$ go run main.go  
true  
{  
    "server": {  
        "openapiPath": "/api.json",  
        "swaggerPath": "/swagger",  
        "address":     ":8199",  
    },  
}  
<nil>  
":8199"  
```

--------------------------------

### Default Configuration Example

Source: https://goframe.org/docs/core/gview-config

Example of a basic viewer configuration block.

```toml
[viewer]  
    paths       = ["template", "/var/www/template"]  
    defaultFile = "index.html"  
    delimiters  =  ["${", "}"]  
    [viewer.data]  
        name    = "gf"  
        version = "1.10.0"
```

--------------------------------

### MatchAll and MatchAllString usage examples

Source: https://goframe.org/docs/components/text-gregex-funcs

Examples demonstrating how to extract URL parameters using MatchAll and MatchAllString.

```go
func ExampleMatchAll() {  
      patternStr := `(\w+)=(\w+)`  
      matchStr := "https://goframe.org/pages/viewpage.action?pageId=1114219&searchId=8QC5D1D2E!"  
      result, err := gregex.MatchAll(patternStr, []byte(matchStr))  
      g.Dump(result)  
      g.Dump(err)  
  
      // Output:  
      //  [  
      //     [  
      //         "pageId=1114219",  
      //         "pageId",  
      //         "1114219",  
      //     ],  
      //     [  
      //         "searchId=8QC5D1D2E",  
      //         "searchId",  
      //         "8QC5D1D2E",  
      //     ],  
      // ]  
      // <nil>  
}  
  
func ExampleMatchAllString() {  
      patternStr := `(\w+)=(\w+)`  
      matchStr := "https://goframe.org/pages/viewpage.action?pageId=1114219&searchId=8QC5D1D2E!"  
      result, err := gregex.MatchAllString(patternStr, matchStr)  
      g.Dump(result)  
      g.Dump(err)  
  
      // Output:  
      // [  
      //     [  
      //         "pageId=1114219",  
      //         "pageId",  
      //         "1114219",  
      //     ],  
      //     [  
      //         "searchId=8QC5D1D2E",  
      //         "searchId",  
      //         "8QC5D1D2E",  
      //     ],  
      // ]  
      // <nil>  
}  
```

--------------------------------

### Start a scheduled task

Source: https://goframe.org/docs/components/os-gcron-example

Demonstrates how to start a previously stopped task by its name using the Start method.

```go
func main() {  
    var (  
        ctx = gctx.New()  
    )  
    cron := gcron.New()  
    array := garray.New(true)  
    cron.AddOnce(ctx, "@every 2s",func(ctx context.Context) {  
        array.Append(1)  
    },"cron2")  
    cron.Stop("cron2")  
    time.Sleep(3000 * time.Millisecond)  
    fmt.Println(array.Len(),cron.Size())  
    cron.Start("cron2")  
    time.Sleep(3000 * time.Millisecond)  
    fmt.Println(array.Len(),cron.Size())  
  
    // Output:  
    // 0 1  
    // 1 0  
}  
```

```text
0 1  
1 0  
```

--------------------------------

### Start Service

Source: https://goframe.org/docs/practices/quick-demo

Runs the application server.

```bash
go run main.go  

```

--------------------------------

### Install golint manually

Source: https://goframe.org/docs/install-go/config-env

Clone the repository and install the golint tool if goproxy is not configured.

```bash
mkdir -p $GOPATH/src/golang.org/x/  
cd $GOPATH/src/golang.org/x/  
git clone https://github.com/golang/lint.git  
git clone https://github.com/golang/tools.git  
cd $GOPATH/src/golang.org/x/lint/golint  
go install  

```

--------------------------------

### ScanDir Example

Source: https://goframe.org/docs/components/os-gfile

Demonstrates recursive directory scanning.

```go
func ExampleScanDir() {  
      // init  
      var (  
          fileName = "gfile_example.txt"  
          tempDir  = gfile.TempDir("gfile_example_scan_dir")  
          tempFile = gfile.Join(tempDir, fileName)  
  
          tempSubDir  = gfile.Join(tempDir, "sub_dir")  
          tempSubFile = gfile.Join(tempSubDir, fileName)  
      )  
  
      // write contents  
      gfile.PutContents(tempFile, "goframe example content")  
      gfile.PutContents(tempSubFile, "goframe example content")  
  
      // scans directory recursively  
      list, _ := gfile.ScanDir(tempDir, "*", true)  
      for _, v := range list {  
          fmt.Println(gfile.Basename(v))  
      }  
  
      // Output:  
      // gfile_example.txt  
      // sub_dir  
      // gfile_example.txt  
}
```

--------------------------------

### Download and install on Mac/Linux

Source: https://goframe.org/docs/cli/install

Downloads the latest precompiled binary, sets execution permissions, installs it, and removes the temporary file.

```bash
wget -O gf https://github.com/gogf/gf/releases/latest/download/gf_$(go env GOOS)_$(go env GOARCH) && chmod +x gf && ./gf install -y && rm ./gf  
```

--------------------------------

### Version Output Example (>= v2.5.7)

Source: https://goframe.org/docs/cli/version

Example output format for GoFrame CLI versions 2.5.7 and later, including detailed environment and build information.

```text
$ gf version  
v2.7.2  
Welcome to GoFrame!  
Env Detail:  
  Go Version: go1.22.2 linux/amd64  
  GF Version(go.mod):  
    github.com/gogf/gf/contrib/drivers/mysql/v2@v2.7.2  
    github.com/gogf/gf/v2@v2.7.2  
CLI Detail:  
  Installed At: /data/home/v_hlaghuang/go/bin/gf  
  Built Go Version: go1.20.8  
  Built GF Version: v2.7.2  
  Git Commit: 2024-06-26 10:08:04 b11caba5b03ed54fbb1415151f7d62b6d913179d  
  Built Time: 2024-06-26 10:09:50  
Others Detail:  
  Docs: https://goframe.org  
  Now : 2024-07-17T15:48:57+08:00  
```

--------------------------------

### Version Output Example (< v2.5.6)

Source: https://goframe.org/docs/cli/version

Example output format for GoFrame CLI versions prior to 2.5.6.

```text
$ gf version  
GoFrame CLI Tool v2.0.0, https://goframe.org  
GoFrame Version: v2.0.0-beta.0.20211214160159-19c9f0a48845 in current go.mod  
CLI Installed At: /Users/john/Workspace/Go/GOPATH/src/github.com/gogf/gf-cli/main  
CLI Built Detail:  
  Go Version:  go1.16.3  
  GF Version:  v2.0.0-beta  
  Git Commit:  2021-12-15 22:43:12 7884058b5df346d34ebab035224e415afb556c19  
  Build Time:  2021-12-15 23:00:43  
```

--------------------------------

### Build Configuration Example

Source: https://goframe.org/docs/cli/build

Example configuration structure for the gf build command, which can be defined in the project's configuration file.

```yaml
gfcli:  
  build:  
    name:     "gf"  
    arch:     "all"  
    system:   "all"  
    mod:      "none"  
    packSrc:  "resource,manifest"  
    version:  "v1.0.0"  
    output:   "./bin"  
    extra:    ""  
```

--------------------------------

### IteratorAscFrom Usage Examples

Source: https://goframe.org/docs/components/container-gtree-funcs

Examples demonstrating normal iteration, handling non-existent keys with exact matching, and handling non-existent keys with index-based searching.

```go
func ExampleBTree_IteratorAscFrom_Normal() {  
      m := make(map[interface{}]interface{})  
      for i := 1; i <= 5; i++ {  
          m[i] = i * 10  
      }  
      tree := gtree.NewBTreeFrom(3, gutil.ComparatorInt, m)  
  
      tree.IteratorAscFrom(1, true, func(key, value interface{}) bool {  
          fmt.Println("key:", key, ", value:", value)  
          return true  
      })  
  
      // Output:  
      // key: 1 , value: 10  
      // key: 2 , value: 20  
      // key: 3 , value: 30  
      // key: 4 , value: 40  
      // key: 5 , value: 50  
}
```

```go
func ExampleBTree_IteratorAscFrom_NoExistKey() {  
      m := make(map[interface{}]interface{})  
      for i := 1; i <= 5; i++ {  
          m[i] = i * 10  
      }  
      tree := gtree.NewBTreeFrom(3, gutil.ComparatorInt, m)  
  
      tree.IteratorAscFrom(0, true, func(key, value interface{}) bool {  
          fmt.Println("key:", key, ", value:", value)  
          return true  
      })  
  
      // Output:  
}
```

```go
func ExampleBTree_IteratorAscFrom_NoExistKeyAndMatchFalse() {  
      m := make(map[interface{}]interface{})  
      for i := 1; i <= 5; i++ {  
          m[i] = i * 10  
      }  
      tree := gtree.NewBTreeFrom(3, gutil.ComparatorInt, m)  
  
      tree.IteratorAscFrom(0, false, func(key, value interface{}) bool {  
          fmt.Println("key:", key, ", value:", value)  
          return true  
      })  
  
      // Output:  
      // key: 1 , value: 10  
      // key: 2 , value: 20  
      // key: 3 , value: 30  
      // key: 4 , value: 40  
      // key: 5 , value: 50  
}
```

--------------------------------

### MustKeys Usage Example

Source: https://goframe.org/docs/core/gcache-funcs

Demonstrates retrieving all keys from the cache.

```go
func ExampleCache_MustKeys() {  
      c := gcache.New()  
  
      c.SetMap(ctx, g.MapAnyAny{"k1": "v1", "k2": "v2"}, 0)  
  
      // MustKeys acts like Keys, but it panics if any error occurs.  
      keys1 := c.MustKeys(ctx)  
      fmt.Println(keys1)  
  
      // May Output:  
      // [k1 k2]  
  
}  
```

--------------------------------

### Middleware Execution Order Example

Source: https://goframe.org/docs/web/router-middleware-intro

A complete example demonstrating the execution order of pre and post middleware across nested route groups.

```go
package main  
  
import (  
    "context"  
    "github.com/gogf/gf/v2/frame/g"  
    "github.com/gogf/gf/v2/net/ghttp"  
    "github.com/gogf/gf/v2/os/glog"  
)  
  
type HelloReq struct {  
    g.Meta `path:"/hello" method:"get"`  
}  
type HelloRes struct {  
}  
  
type Hello struct{}  
  
func (Hello) Say(ctx context.Context, req *HelloReq) (res *HelloRes, err error) {  
    glog.Debug(ctx, "中")  
    return  
}  
  
func RequestHandle1(r *ghttp.Request) {  
    glog.Debug(r.GetCtx(), "前1")  
    r.Middleware.Next()  
}  
  
func RequestHandle2(r *ghttp.Request) {  
    glog.Debug(r.GetCtx(), "前2")  
    r.Middleware.Next()  
}  
  
func RequestHandle3(r *ghttp.Request) {  
    glog.Debug(r.GetCtx(), "前3")  
    r.Middleware.Next()  
}  
  
func RequestHandle4(r *ghttp.Request) {  
    glog.Debug(r.GetCtx(), "前4")  
    r.Middleware.Next()  
}  
  
func ResponseHandle1(r *ghttp.Request) {  
    r.Middleware.Next()  
    glog.Debug(r.GetCtx(), "后1")  
}  
  
func ResponseHandle2(r *ghttp.Request) {  
    r.Middleware.Next()  
    glog.Debug(r.GetCtx(), "后2")  
}  
  
func ResponseHandle3(r *ghttp.Request) {  
    r.Middleware.Next()  
    glog.Debug(r.GetCtx(), "后3")  
}  
  
func ResponseHandle4(r *ghttp.Request) {  
    r.Middleware.Next()  
    glog.Debug(r.GetCtx(), "后4")  
}  
  
func main() {  
    s := g.Server()  
    s.Use(ghttp.MiddlewareHandlerResponse)  
    s.Group("/", func(group *ghttp.RouterGroup) {  
        // 前置中间件  
        group.Middleware(RequestHandle1)  
        group.Middleware(RequestHandle2)  
  
        // 后置中间件  
        group.Middleware(ResponseHandle1)  
        group.Middleware(ResponseHandle2)  
  
        group.Group("/sub", func(group *ghttp.RouterGroup) {  
            // 前置中间件  
            group.Middleware(RequestHandle3)  
            group.Middleware(RequestHandle4)  
  
            // 后置中间件  
            group.Middleware(ResponseHandle3)  
            group.Middleware(ResponseHandle4)  
  
            group.Bind(new(Hello))  
        })  
    })  
    s.Run()  
}  

```

--------------------------------

### Basic Static File Server Usage

Source: https://goframe.org/docs/web/senior-static-server

A minimal example demonstrating how to enable directory indexing and set a server root.

```go
package main  
  
import "github.com/gogf/gf/v2/frame/g"  
  
// 静态文件服务器基本使用  
func main() {  
    s := g.Server()  
    s.SetIndexFolder(true)  
    s.SetServerRoot("/Users/john/Temp")  
    s.AddSearchPath("/Users/john/Documents")  
    s.SetPort(8199)  
    s.Run()  
}  
```

--------------------------------

### View gf init Help

Source: https://goframe.org/docs/cli/init

Displays the usage, arguments, and options for the initialization command.

```bash
$ gf init -h
```

--------------------------------

### Basic GUID usage

Source: https://goframe.org/docs/components/util-guid

Example of generating a unique identifier without parameters.

```go
package main  
  
import (  
    "fmt"  
    "github.com/gogf/gf/v2/util/guid"  
)  
  
func main() {  
    fmt.Printf("TraceId: %s", guid.S())  
}
```

```text
TraceId: oa9sdw03dk0c35q9bdwcnz42p00trwfr
```

--------------------------------

### Enable interactive initialization mode

Source: https://goframe.org/docs/cli/init

Launch the interactive guide to configure project settings step-by-step.

```bash
$ gf init -i
```

--------------------------------

### IteratorDescFrom usage example

Source: https://goframe.org/docs/components/container-gtree-funcs

Iterates over the BTree in descending order starting from a specific key.

```go
func ExampleBTree_IteratorDescFrom() {  
      m := make(map[interface{}]interface{})  
      for i := 1; i <= 5; i++ {  
          m[i] = i * 10  
      }  
      tree := gtree.NewBTreeFrom(3, gutil.ComparatorInt, m)  
  
      tree.IteratorDescFrom(5, true, func(key, value interface{}) bool {  
          fmt.Println("key:", key, ", value:", value)  
          return true  
      })  
  
      // Output:  
      // key: 5 , value: 50  
      // key: 4 , value: 40  
      // key: 3 , value: 30  
      // key: 2 , value: 20  
      // key: 1 , value: 10  
}
```

--------------------------------

### Get start of day with StartOfDay

Source: https://goframe.org/docs/components/os-gtime-funcs

Returns the time object representing the beginning of the day.

```go
func (t *Time) StartOfDay() *Time
```

```go
func ExampleTime_StartOfDay() {  
      gt1 := gtime.New("2018-08-08 08:08:08")  
  
      fmt.Println(gt1.StartOfDay())  
  
      // Output:  
      // 2018-08-08 00:00:00  
}
```

--------------------------------

### Main Application Entry Point

Source: https://goframe.org/docs/micro-service/config-service

Import the boot package in main.go to ensure configuration initialization occurs before other components.

```go
package main  
  
import (  
    _ "github.com/gogf/gf/example/config/polaris/boot"  
  
    "github.com/gogf/gf/v2/frame/g"  
    "github.com/gogf/gf/v2/os/gctx"  
)  
  
func main() {  
    var ctx = gctx.GetInitCtx()  
  
    // Available checks.  
    g.Dump(g.Cfg().Available(ctx))  
  
    // All key-value configurations.  
    g.Dump(g.Cfg().Data(ctx))  
  
    // Retrieve certain value by key.  
    g.Dump(g.Cfg().MustGet(ctx, "server.address"))  
}  
```

--------------------------------

### Install gredis component

Source: https://goframe.org/docs/components/contrib-nosql-redis

Use the go get command to add the gredis contrib package to your project.

```bash
go get -u github.com/gogf/gf/contrib/nosql/redis/v2
```

--------------------------------

### 在 main 包中引入 boot 包

Source: https://goframe.org/docs/core/gres-pack-using-cli

在入口 main 包中优先引入 boot 包，以确保程序启动设置正确加载。

```go
import (
    _ "my-app/boot"

    // 其他包
)
```

--------------------------------

### Redis Singleton Usage

Source: https://goframe.org/docs/components/contrib-nosql-redis-config

Example of using the g.Redis singleton to perform basic set and get operations.

```go
package main  
  
import (  
    "fmt"  
  
    _ "github.com/gogf/gf/contrib/nosql/redis/v2"  
  
    "github.com/gogf/gf/v2/frame/g"  
    "github.com/gogf/gf/v2/os/gctx"  
)  
  
func main() {  
    var ctx = gctx.New()  
    _, err := g.Redis().Set(ctx, "key", "value")  
    if err != nil {  
        g.Log().Fatal(ctx, err)  
    }  
    value, err := g.Redis().Get(ctx, "key")  
    if err != nil {  
        g.Log().Fatal(ctx, err)  
    }  
    fmt.Println(value.String())  
}  
```

--------------------------------

### Server Startup Logs

Source: https://goframe.org/docs/web/api-document-swagger-ui

Example output showing the server routes and the OpenAPI specification endpoint.

```text
2022-05-18 20:41:09.160 [INFO] openapi specification is serving at address: http://127.0.0.1:8199/api.json  
2022-05-18 20:41:09.161 [INFO] pid[57888]: http server started listening on [:8199]  
  
  ADDRESS | METHOD |   ROUTE   |                             HANDLER                             |    MIDDLEWARE  
----------|--------|-----------|-----------------------------------------------------------------|--------------------  
  :8199   | ALL    | /*        | github.com/gogf/gf/v2/net/ghttp.internalMiddlewareServerTracing | GLOBAL MIDDLEWARE  
----------|--------|-----------|-----------------------------------------------------------------|--------------------  
  :8199   | ALL    | /api.json | github.com/gogf/gf/v2/net/ghttp.(*Server).openapiSpec           |  
----------|--------|-----------|-----------------------------------------------------------------|--------------------  
  :8199   | GET    | /hello    | main.(*Hello).Say                                               |  
----------|--------|-----------|-----------------------------------------------------------------|--------------------  
  :8199   | GET    | /swagger  | main.main.func1.1                                               |  
----------|--------|-----------|-----------------------------------------------------------------|--------------------  
```

--------------------------------

### Start the Service

Source: https://goframe.org/docs/practices/mvc-demo-chat

Execute the application using the Go toolchain.

```bash
go run main.go  
```

--------------------------------

### Testing Request Conversion with Curl

Source: https://goframe.org/docs/web/request-struct-converting

Example commands to verify that both GET and POST requests are correctly parsed into the struct.

```bash
$ curl "http://127.0.0.1:8199/register?name=john&password1=123&password2=456"  
{"code":0,"error":"","data":{"Name":"john","Pass":"123","Pass2":"456"}}  
  
$ curl -d "name=john&password1=123&password2=456" -X POST "http://127.0.0.1:8199/register"  
{"code":0,"error":"","data":{"Name":"john","Pass":"123","Pass2":"456"}}  
```

--------------------------------

### Install Dependencies

Source: https://goframe.org/docs/practices/quick-demo

Prepares the project environment by tidying Go modules.

```bash
cd /path/to/examples/practices/quick-demo  
go mod tidy  

```

--------------------------------

### Redirecting on Status Error

Source: https://goframe.org/docs/web/senior-status-handler

Example of using r.RedirectTo to guide users to a specific error page when a 404 occurs.

```go
package main  
  
import (  
    "github.com/gogf/gf/v2/frame/g"  
    "github.com/gogf/gf/v2/net/ghttp"  
)  
  
func main() {  
    s := g.Server()  
    s.BindHandler("/status/:status", func(r *ghttp.Request) {
        r.Response.Write("woops, status ", r.Get("status"), " found")  
    })  
    s.BindStatusHandler(404, func(r *ghttp.Request){
        r.Response.RedirectTo("/status/404")  
    })  
    s.SetPort(8199)  
    s.Run()  
}  
```

--------------------------------

### Generating GUID with custom parameters

Source: https://goframe.org/docs/components/util-guid

Example of using custom byte slices to influence the generated unique identifier.

```go
func CreateSessionId(r *ghttp.Request) string {  
    var (  
        address = request.RemoteAddr  
        header  = fmt.Sprintf("%v", request.Header)  
    )  
    return guid.S([]byte(address), []byte(header))  
}
```

--------------------------------

### 创建 Hello World 服务

Source: https://goframe.org/docs/web/start

使用 g.Server() 创建默认服务并绑定根路由。默认监听 80 端口。

```go
package main  
  
import (  
    "github.com/gogf/gf/v2/frame/g"  
    "github.com/gogf/gf/v2/net/ghttp"  
)  
  
func main() {  
    s := g.Server()  
    s.BindHandler("/", func(r *ghttp.Request) {  
        r.Response.Write("哈喽世界！")  
    })  
    s.Run()  
}  
```

--------------------------------

### Install Dependencies

Source: https://goframe.org/docs/practices/mvc-demo-chat

Run these commands in the project directory to prepare the environment.

```bash
cd /path/to/examples/practices/mvc-demo-chat  
go mod tidy  
```

--------------------------------

### ServeFile Usage Example

Source: https://goframe.org/docs/web/response-file-downloading

Demonstrates serving a file directly to the browser using ServeFile.

```go
package main  
  
import (  
    "github.com/gogf/gf/v2/frame/g"  
    "github.com/gogf/gf/v2/net/ghttp"  
)  
  
func main() {  
    s := g.Server()  
    s.BindHandler("/", func(r *ghttp.Request) {  
        r.Response.ServeFile("test.txt")  
    })  
    s.SetPort(8999)  
    s.Run()  
}  
```

--------------------------------

### HTTPS Graceful Restart Example

Source: https://goframe.org/docs/web/senior-hot-reload

Shows how to configure a server with HTTPS and enable administrative management.

```go
package main  
  
import (  
    "github.com/gogf/gf/v2/frame/g"  
    "github.com/gogf/gf/v2/net/ghttp"  
)  
  
func main() {  
    s := g.Server()  
    s.BindHandler("/", func(r *ghttp.Request){  
        r.Response.Writeln("哈罗！")  
    })  
    s.SetGraceful(true)  
    s.EnableHTTPS("/home/john/temp/server.crt", "/home/john/temp/server.key")  
    s.EnableAdmin()  
    s.SetPort(8200)  
    s.Run()  
}
```

```text
2018-05-18 11:13:05.554 17278: https server started listening on [:8200]  
2018-05-18 11:13:21.270 17278: server reloading  
2018-05-18 11:13:21.270 17278: all servers shutdown  
2018-05-18 11:13:21.278 17319: https server reloaded listening on [:8200]  
2018-05-18 11:13:34.895 17319: server shutting down  
2018-05-18 11:13:34.895 17269: all servers shutdown
```

--------------------------------

### Hello World example

Source: https://goframe.org/docs/web/router-registering-callback

A basic implementation using an anonymous function as a handler.

```go
package main  
  
import (  
    "github.com/gogf/gf/v2/frame/g"  
    "github.com/gogf/gf/v2/net/ghttp"  
)  
  
func main() {  
    s := g.Server()  
    s.BindHandler("/", func(r *ghttp.Request) {  
        r.Response.Write("哈喽世界！")  
    })  
    s.SetPort(8199)  
    s.Run()  
}
```

--------------------------------

### Validate Passport Format

Source: https://goframe.org/docs/core/gvalid-rules

Validates strings starting with a letter, containing only letters, numbers, or underscores, with a length between 6 and 18.

```go
func Example_Rule_Passport() {  
    type BizReq struct {  
        Passport1 string `v:"passport"`  
        Passport2 string `v:"passport"`  
        Passport3 string `v:"passport"`  
        Passport4 string `v:"passport"`  
    }  
  
    var (  
        ctx = context.Background()  
        req = BizReq{  
            Passport1: "goframe",  
            Passport2: "1356666",  // error starting with letter  
            Passport3: "goframe#", // error containing only numbers or underscores  
            Passport4: "gf",       // error length between 6 and 18  
        }  
    )  
    if err := g.Validator().Data(req).Run(ctx); err != nil {  
        fmt.Print(gstr.Join(err.Strings(), "\n"))  
    }  
  
    // Output:  
    // The Passport2 value `1356666` is not a valid passport format  
    // The Passport3 value `goframe#` is not a valid passport format  
    // The Passport4 value `gf` is not a valid passport format  
}  
```

--------------------------------

### Install via go install

Source: https://goframe.org/docs/cli/install

Installs the GoFrame CLI tool using the Go toolchain. Ensure $GOPATH/bin is in your system PATH.

```bash
go install github.com/gogf/gf/cmd/gf/v2@latest  
```

```bash
go install github.com/gogf/gf/cmd/gf/v2@v2.5.5  
```

--------------------------------

### 使用 Get 方法获取指定元数据

Source: https://goframe.org/docs/components/util-gmeta

通过 Get 方法根据键名获取结构体中特定的元数据标签值。

```go
package main  
  
import (  
    "fmt"  
    "github.com/gogf/gf/v2/util/gmeta"  
)  
  
func main() {  
    type User struct {  
        g.Meta `orm:"user" db:"mysql"`  
        Id         int  
        Name       string  
    }  
    user := User{}  
    fmt.Println(gmeta.Get(user, "orm").String())  
    fmt.Println(gmeta.Get(user, "db").String())  
}
```

```text
user  
mysql
```

--------------------------------

### Initialize and update dependencies via command line

Source: https://goframe.org/docs/install-go/go-module

Using go env and go get commands to configure the environment and fetch project dependencies.

```bash
go env -w GO111MODULE=on  
go env -w GOPROXY=https://goproxy.cn,direct  
go get -u github.com/gogf/gf/v2  
```

--------------------------------

### Code Method Example

Source: https://goframe.org/docs/core/gerror-code-example

Usage example for retrieving error codes recursively.

```go
func ExampleCode() {  
    err1 := gerror.NewCode(gcode.CodeInternalError, "permission denied")  
    err2 := gerror.Wrap(err1, "operation failed")  
    fmt.Println(gerror.Code(err1))  
    fmt.Println(gerror.Code(err2))  
  
    // Output:  
    // 50:Internal Error  
    // 50:Internal Error  
}
```

--------------------------------

### Basic Group Routing Example

Source: https://goframe.org/docs/web/router-registering-group

Demonstrates creating a server and registering routes under the /api prefix with different HTTP methods.

```go
package main  
  
import (  
    "github.com/gogf/gf/v2/frame/g"  
    "github.com/gogf/gf/v2/net/ghttp"  
)  
  
func main() {  
    s := g.Server()  
    s.Group("/api", func(group *ghttp.RouterGroup) {  
        group.ALL("/all", func(r *ghttp.Request) {  
            r.Response.Write("all")  
        })  
        group.GET("/get", func(r *ghttp.Request) {  
            r.Response.Write("get")  
        })  
        group.POST("/post", func(r *ghttp.Request) {  
            r.Response.Write("post")  
        })  
    })  
    s.SetPort(8199)  
    s.Run()  
}
```

--------------------------------

### WrapCode and WrapCodef Examples

Source: https://goframe.org/docs/core/gerror-code-example

Usage examples for wrapping errors with error codes.

```go
func ExampleWrapCode() {  
    err1 := errors.New("permission denied")  
    err2 := gerror.WrapCode(gcode.New(10000, "", nil), err1, "Custom Error")  
    fmt.Println(err2.Error())  
    fmt.Println(gerror.Code(err2).Code())  
  
    // Output:  
    // Custom Error: permission denied  
    // 10000  
}  
  
func ExampleWrapCodef() {  
    err1 := errors.New("permission denied")  
    err2 := gerror.WrapCodef(gcode.New(10000, "", nil), err1, "It's %s", "Custom Error")  
    fmt.Println(err2.Error())  
    fmt.Println(gerror.Code(err2).Code())  
  
    // Output:  
    // It's Custom Error: permission denied  
    // 10000  
}
```

--------------------------------

### Basic Graceful Restart Example

Source: https://goframe.org/docs/web/senior-hot-reload

Demonstrates enabling the admin interface and graceful restart capabilities in a standard HTTP server.

```go
package main  
  
import (  
    "time"  
  
    "github.com/gogf/gf/v2/frame/g"  
    "github.com/gogf/gf/v2/net/ghttp"  
    "github.com/gogf/gf/v2/os/gproc"  
)  
  
func main() {  
    s := g.Server()  
    s.BindHandler("/", func(r *ghttp.Request) {  
        r.Response.Writeln("哈喽！")  
    })  
    s.BindHandler("/pid", func(r *ghttp.Request) {  
        r.Response.Writeln(gproc.Pid())  
    })  
    s.BindHandler("/sleep", func(r *ghttp.Request) {  
        r.Response.Writeln(gproc.Pid())  
        time.Sleep(10 * time.Second)  
        r.Response.Writeln(gproc.Pid())  
    })  
    s.SetGraceful(true)  
    s.EnableAdmin()  
    s.SetPort(8199)  
    s.Run()  
}
```

```text
2018-05-18 11:02:04.812 11511: http server started listening on [:8199]  
2018-05-18 11:02:09.172 11511: server reloading  
2018-05-18 11:02:09.172 11511: all servers shutdown  
2018-05-18 11:02:09.176 16358: http server restarted listening on [:8199]
```

--------------------------------

### Implement HTTP Server with Service Registration

Source: https://goframe.org/docs/micro-service/load-balance

This example demonstrates setting up an HTTP server that registers itself with an etcd registry.

```go
package main  
  
import (  
    "github.com/gogf/gf/contrib/registry/etcd/v2"  
    "github.com/gogf/gf/v2/frame/g"  
    "github.com/gogf/gf/v2/net/ghttp"  
    "github.com/gogf/gf/v2/net/gsvc"  
)  
  
func main() {  
    gsvc.SetRegistry(etcd.New(`127.0.0.1:2379`))  
  
    s := g.Server(`hello.svc`)  
    s.BindHandler("/", func(r *ghttp.Request) {  
        g.Log().Info(r.Context(), `request received`)  
        r.Response.Write(`Hello world`)  
    })  
    s.Run()  
}  
```

--------------------------------

### NewCode and NewCodef Examples

Source: https://goframe.org/docs/core/gerror-code-example

Usage examples for creating errors with error codes.

```go
func ExampleNewCode() {  
    err := gerror.NewCode(gcode.New(10000, "", nil), "My Error")  
    fmt.Println(err.Error())  
    fmt.Println(gerror.Code(err))  
  
    // Output:  
    // My Error  
    // 10000  
}  
  
func ExampleNewCodef() {  
    err := gerror.NewCodef(gcode.New(10000, "", nil), "It's %s", "My Error")  
    fmt.Println(err.Error())  
    fmt.Println(gerror.Code(err).Code())  
  
    // Output:  
    // It's My Error  
    // 10000  
}
```

--------------------------------

### Importing the GUID package

Source: https://goframe.org/docs/components/util-guid

Required import statement to access the guid utility.

```go
import "github.com/gogf/gf/v2/util/guid"
```

--------------------------------

### Fuzzy Matching Rule Examples

Source: https://goframe.org/docs/web/router-pattern

Examples of the *any rule, which matches all remaining URI segments.

```text
rule: /src/*path  
  
/src/                     match  
/src/somefile.go          match  
/src/subdir/somefile.go   match  
/user/                    no match  
/user/john                no match
```

```text
rule: /src/*path/:action  
  
/src/                     no match  
/src/somefile.go          match  
/src/somefile.go/del      match  
/src/subdir/file.go/del   match
```

```text
rule: /src/*path/show  
  
/src/                     no match  
/src/somefile.go          no match  
/src/somefile.go/del      no match  
/src/somefile.go/show     match  
/src/subdir/file.go/show  match  
/src/show                 match
```

--------------------------------

### Ajax client-side function example

Source: https://goframe.org/docs/web/paging

Example of a JavaScript function required for Ajax pagination.

```javascript
function DoAjax(url) {  
    // 这里读取URL的内容并根据业务逻辑进行内容展示  
}  
```

--------------------------------

### Start gRPC Server

Source: https://goframe.org/docs/micro-service

Main entry point to initialize and run the gRPC server.

```go
package main  
  
import (  
    "github.com/gogf/gf/contrib/rpc/grpcx/v2"  
    "github.com/gogf/gf/example/rpc/grpcx/basic/controller"  
)  
  
func main() {  
    s := grpcx.Server.New()  
    controller.Register(s)  
    s.Run()  
}  
```

--------------------------------

### Exit Method Output Example

Source: https://goframe.org/docs/web/response-exit-exitall-exithook

Expected output when accessing the initial handler example.

```text
john  
smith  
```

--------------------------------

### PopRight Example

Source: https://goframe.org/docs/components/container-garray-funcs

Example usage of PopRight to remove the rightmost element from a string array.

```go
func ExampleStrArray_PopRight() {  
      s := garray.NewStrArray()  
      s.SetArray(g.SliceStr{"a", "b", "c", "d"})  
      s.PopRight()  
      fmt.Println(s.Slice())  
  
      // Output:  
      // [a b c]  
}
```

--------------------------------

### PopRand Example

Source: https://goframe.org/docs/components/container-garray-funcs

Example usage of PopRand to remove a random element from a string array.

```go
func ExampleStrArray_PopRand() {  
      s := garray.NewStrArray()  
      s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})  
      r, _ := s.PopRand()  
      fmt.Println(r)  
  
      // May Output:  
      // e  
}
```

--------------------------------

### Chdir Usage Example

Source: https://goframe.org/docs/components/os-gfile

Demonstrates changing the current working directory and verifying the change with gfile.Pwd.

```go
func ExampleChdir() {  
      // init  
      var (  
          path = gfile.Join(gfile.TempDir("gfile_example_basic_dir"), "file1")  
      )  
      // Get current working directory  
      fmt.Println(gfile.Pwd())  
  
      // Changes the current working directory to the named directory.  
      gfile.Chdir(path)  
  
      // Get current working directory  
      fmt.Println(gfile.Pwd())  
  
      // May Output:  
      // xxx/gf/os/gfile  
      // /tmp/gfile_example_basic_dir/file1  
}  
```
Tokens:
Raw