@colin4k1024/tsp 2.4.0

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221//351/253/230/347/272/247/347/211/271/346/200/247//345/271/263/346/273/221/351/207/215/345/220/257/347/211/271/346/200/247.md

@@ -0,0 +1,203 @@
+`平滑重启`( `热重启`)是指 `WebServer` 在重启的时候不会中断已有请求的执行。该特性在不同的项目版本发布的时候特别有用，例如，当需要先后发布两个版本： `A`、 `B`，那么在 `A` 执行的过程当中，我们可以将 `B` 的程序发布 **直接覆盖** `A` 的程序， 并使用平滑重启特性(使用 `Web` 或者 `命令行`)无缝地将请求过渡到新版本的服务中。
+
+`GoFrame` 框架支持非常方便的 `Web管理功能`，也就是说我们可以通过Web页面/接口直接进行 `Server` 的重启/关闭等管理操作。同时，框架也支持通过 `命令行终端指令`(仅限 `*nix` 系统)的形式进行 `Server` 的重启/关闭等管理操作。
+
+## 特性开启
+
+默认情况下平滑重启特性是关闭的，可以通过 `graceful` 配置选项打开，具体请查看 `WebServer` 的配置管理章节： [服务配置-配置文件模板](../服务配置/服务配置-配置文件模板.md)
+:::tip
+目前平滑重启特性需要在本地随机打开一个端口的 `tcp` 监听服务用于新老进程通信交换状态信息。
+:::
+## 注意事项
+
+- 该特性仅限于 `*nix` 系统( `Linux/Unix/FreeBSD` 等等)，在 `Windows` 下仅支持完整重启功能（请求无法平滑过渡）。
+- 测试平滑重启特性时请不要使用 `IDE run`(例如 `Goland`)或者 `go run` 命令来运行进程，因为这两种方式本身会创建父进程来管理运行的 `Go` 进程，会引起平滑重启时子父进程状态交换的失败。
+- 后续示例中的 `SetGraceful` 配置方法在 `v2.7.4` 版本后新增，低于 `v2.7.4` 版本请使用配置管理方式启用平滑重启特性。
+
+## 管理方法
+
+我们先来看一下`WebServer`中涉及到管理操作方法有哪些：
+
+```go
+func (s *Server) Restart(newExeFilePath ...string) error
+func (s *Server) Shutdown() error
+func (s *Server) EnableAdmin(pattern ...string) 
+```
+
+`Restart` 用于重启服务（ `*nix` 系统下为平滑重启， `windows` 下为完整重启）， `Shutdown` 用于关闭服务， `EnableAdmin` 用于将管理页面注册到指定的路由规则上，默认地址是 `/debug/admin`(我们可以指定一个私密的管理地址，也可以使用中间件来对该页面进行鉴权)。
+
+以下对其中两个方法做详细说明。
+
+### Restart
+
+`Restart` 的参数可指定自定义重启的可执行文件路径( `newExeFilePath`)，不传递时默认为原可执行文件路径。特别是在windows系统下，当可执行文件正在使用时，无法对其进行文件替换更新（新版本文件替换老版本文件）。当指定自定义的可执行文件路径后， `Server` 重启时将会执行新版本的可执行文件，不再使用老版本文件，这种特性简化了在某些系统上的版本更新流程。
+
+### EnableAdmin
+
+- 首先，该方法为用户管理 `Server` 提供了简便的页面和接口，在单 `Server` 下管理非常方便，直接访问管理页面点击对应链接即可。需要注意的是，由于带有管理功能，如果是在生产环境上，建议自定义该管理地址为一个私密地址。
+- 同时， `EnableaAdmim` 提供的 `restart` 接口也支持自定义可执行文件路径，直接通过GET参数往restart接口传递 `newExeFilePath` 变量即可，例如： [http://127.0.0.1/debug/admin/restart?newExeFilePath=xxxxxxx](http://127.0.0.1/debug/admin/restart?newExeFilePath=xxxxxxx)
+- 此外，在大多数时候， `Server` 往往不只有1个节点，因此大多数服务管理运维中，例如：重启操作，当然不是直接访问每个 `Server` 的 `admin` 页面手动执行重启操作。而是充分利用 `admin` 页面提供的功能接口，通过接口控制来实现统一的 `Server` 管理控制。
+
+### 示例1：基本使用
+
+```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()
+}
+```
+
+我们通过以下几个步骤来测试平滑重启：
+
+1. 访问 [http://127.0.0.1:8199/pid](http://127.0.0.1:8199/pid) 查看当前进程的pid
+
+2. 访问 [http://127.0.0.1:8199/sleep](http://127.0.0.1:8199/sleep)，这个页面将会执行10秒，用于测试重启时该页面请求执行是否会断掉
+
+3. 访问 [http://127.0.0.1:8199/debug/admin](http://127.0.0.1:8199/debug/admin)，这是 `s.EnableAdmin` 后默认注册的一个WebServer管理页面
+
+4. 随后我们点击 `restart` 管理链接，WebServer将会立即平滑重启( `*nix` 系统下)
+
+同时在终端也会输出以下信息:
+
+```shell
+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]
+```
+
+5. 我们可以发现在整个操作中， `sleep` 页面的执行并没有被中断，继续等待几秒，当 `sleep` 执行完成后，页面输出内容为：
+
+6. 可以发现， `sleep` 页面输出的进程pid和之前的不一样了，代表请求的执行被新的进程平滑接管，旧的服务进程也随之销毁；
+
+### 示例2：HTTPS支持
+
+```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()
+}
+```
+
+`GoFrame` 框架的平滑重启特性对于HTTPS的支持也是相当友好和简便，操作步骤如下：
+
+1. 访问 [https://127.0.0.1:8200/debug/admin/restart](https://127.0.0.1:8200/debug/admin/restart) 平滑重启HTTPS服务；
+2. 访问 [https://127.0.0.1:8200/debug/admin/shutdown](https://127.0.0.1:8200/debug/admin/shutdown) 平滑关闭WebServer服务；
+
+在命令行终端可以看到以下输出信息：
+
+```shell
+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
+```
+
+### 示例3：多服务及多端口
+
+`GoFrame` 框架的平滑重启特性相当强大及稳定，不仅仅支持单一服务单一端口监听管理，同时也支持多服务多端口等复杂场景的监听管理。
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+)
+
+func main() {
+    s1 := g.Server("s1")
+    s1.SetGraceful(true)
+    s1.EnableAdmin()
+    s1.SetPort(8100, 8200)
+    s1.Start()
+
+    s2 := g.Server("s2")
+    s2.SetGraceful(true)
+    s2.EnableAdmin()
+    s2.SetPort(8300, 8400)
+    s2.Start()
+
+    g.Wait()
+}
+```
+
+以上示例演示的是两个WebServer `s1` 及 `s2`，分别监听 `8100`， `8200` 及 `8300`， `8400`。我们随后访问 [http://127.0.0.1:8100/debug/admin/reload](http://127.0.0.1:8100/debug/admin/reload) 平滑重启服务，然后再通过 [http://127.0.0.1:8100/debug/admin/shutdown](http://127.0.0.1:8100/debug/admin/shutdown) 平滑关闭服务，最终在终端打印出的信息如下：
+
+```html
+2018-05-18 11:26:54.729 18111: http server started listening on [:8400]
+2018-05-18 11:26:54.729 18111: http server started listening on [:8100]
+2018-05-18 11:26:54.729 18111: http server started listening on [:8300]
+2018-05-18 11:26:54.729 18111: http server started listening on [:8200]
+2018-05-18 11:27:08.203 18111: server reloading
+2018-05-18 11:27:08.203 18111: all servers shutdown
+2018-05-18 11:27:08.207 18124: http server reloaded listening on [:8300]
+2018-05-18 11:27:08.207 18124: http server reloaded listening on [:8400]
+2018-05-18 11:27:08.207 18124: http server reloaded listening on [:8200]
+2018-05-18 11:27:08.207 18124: http server reloaded listening on [:8100]
+2018-05-18 11:27:19.379 18124: server shutting down
+2018-05-18 11:27:19.380 18102: all servers shutdown
+```
+
+## 命令行管理
+
+`GoFrame` 框架除了提供 `Web` 方式的管理能力以外，也支持命令行方式来进行管理，由于命令行采用了 `信号` 进行管理。
+
+### 重启服务
+
+使用 `SIGUSR1` 信号量实现，使用方式：
+
+```shell
+kill -SIGUSR1 进程ID
+```
+
+### 关闭服务
+
+使用 `SIGINT/SIGQUIT/SIGKILL/SIGHUP/SIGTERM` 其中任意一个信号量来实现，使用方式：
+
+```shell
+kill -SIGTERM 进程ID
+```
+
+## 其他管理方式
+
+由于 `GoFrame` 框架的 `WebServer` 采用了单例设计，因此任何地方都可以通过 `g.Server(名称)` 来获得对应 `Server` 的单例对象，随后通过 `Restart` 和 `Shutdown` 方法可以实现对该 `Server` 的管理。

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221//351/253/230/347/272/247/347/211/271/346/200/247//346/234/215/345/212/241/346/227/245/345/277/227/347/256/241/347/220/206.md

@@ -0,0 +1,108 @@
+`GoFrame` 框架提供了完善的 `Server` 日志管理功能，包括 `access log` 以及 `error log`，推荐使用配置文件的方式统一配置管理。
+
+## 日志配置
+
+### 配置对象
+
+请查看API文档：
+
+[https://pkg.go.dev/github.com/gogf/gf/v2/net/ghttp#ServerConfig](https://pkg.go.dev/github.com/gogf/gf/v2/net/ghttp#ServerConfig)
+
+### 配置属性
+
+日志相关配置属性如下：
+
+```go
+Logger            *glog.Logger      // Logger for server.
+LogPath           string            // Directory for storing logging files.
+LogStdout         bool              // Printing logging content to stdout.
+ErrorStack        bool              // Logging stack information when error.
+ErrorLogEnabled   bool              // Enable error logging files.
+ErrorLogPattern   string            // Error log file pattern like: error-{Ymd}.log
+AccessLogEnabled  bool              // Enable access logging files.
+AccessLogPattern  string            // Error log file pattern like: access-{Ymd}.log
+```
+
+简要说明：
+
+1. 默认情况下，日志不会输出到文件中，而是直接打印到终端。默认情况下的 `access` 日志终端输出是关闭的，仅有 `error` 日志默认开启。
+2. 所有的选项均可通过 `Server.Set*` 方法设置，大部分选项可以通过 `Server.Get*` 方法获取。
+3. `Logger` 是一个自定义的日志管理对象，开发者也可以传递一个完整的日志管理对象，忽略其他日志选项配置。
+4. `LogPath` 属性用于设置日志目录，只有在设置了日志目录的情况下才会输出日志到日志文件中。
+5. `ErrorLogPattern` 及 `AccessLogPattern` 用于配置日志文件名称格式，默认为 `error-{Ymd}.log` 及 `access-{Ymd}.log`，例如： `error-20191212.log`, `access-20191212.log`。
+6. 其他配置选项说明请参考注释和API文档。
+
+### 配置文件
+
+官方推荐使用配置文件的方式来管理服务配置以及日志日志配置。 一个参考的日志配置内容示例（以 `yaml` 格式为例）：
+
+```yaml
+server:
+  LogPath:          "/var/log/gf-demos/server"
+  LogStdout:        false
+  ErrorStack:       true
+  ErrorLogEnabled:  true
+  ErrorLogPattern:  "error.{Ymd}.log"
+  AccessLogEnabled: true
+  AccessLogPattern: "access.{Ymd}.log"
+```
+
+当 `Server` 启动时将会自动去读取默认配置文件 `config.yaml` 中的 `server` 节点配置。
+
+### 配置方法
+
+日志的配置也可以通过 `Server` 对象的 `Set*` 方法来进行配置，参考 [服务配置](../服务配置/服务配置.md) 章节。
+
+## 日志格式
+
+配置文件的方式比较简单，这里不再示例说明。以下示例通过配置方法的方式进行对 `Server` 进行配置。
+
+### 请求日志
+
+请求日志：
+
+```html
+2018-04-20 18:11:57.344 200 "GET http 127.0.0.1:8199 /log/access HTTP/1.1" 0.120, 127.0.0.1, "", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Ubuntu Chromium/53.0.2785.143 Chrome/53.0.2785.143 Safari/537.36"
+```
+
+日志格式:
+
+```html
+请求时间(精确到毫秒) HTTP状态码 "请求方式 请求前缀 请求地址 请求协议" 执行时间(秒) 客户端IP "来源URL", "UserAgent"
+```
+
+其中， `请求前缀` 为 `http` 或者 `https`， `请求协议` 往往为 `HTTP/1.0` 或者 `HTTP/1.1`。
+:::warning
+注意，日志中记录的 `执行时间` 单位为 `秒`，绝大多数情况下看到的时间几乎都是 `0.xxx` 秒时间，也就是说执行时间都是毫秒级不到1秒。
+:::
+### 错误日志
+
+错误日志：
+
+```html
+2019-12-20 20:10:56.484 [ERRO] 500, "GET http 127.0.0.1:8199 /log/error HTTP/1.1" 0.210, 127.0.0.1, "", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36"
+Stack:
+1. OMG
+   1).  main.main.func1
+        /Users/john/Workspace/Go/GOPATH/src/github.com/gogf/gf/.example/net/ghttp/server/log/log_error.go:10
+
+```
+
+错误信息会打印出对应错误产生的堆栈信息（堆栈信息中不包含框架内部调用信息），以便于错误定位以及开发者分析问题原因。
+:::tip
+`Server` 产生的任何 `panic` 错误都将会被自动捕获到错误日志中，因此对于业务端程序来讲，无论是在控制器中、业务封装层、数据模型中，如果产生了错误想要直接退出业务请求处理，直接 `panic` 即可。
+:::
+## 自定义日志处理
+
+开发者可以自定义处理 `Server` 的请求日志，方法有两种：
+
+1. 可以通过日志配置项传递自定义的 `*glog.Logger` 对象。
+2. 可以通过中间件来统一捕获处理，参考 [路由管理-中间件/拦截器](../%E8%B7%AF%E7%94%B1%E7%AE%A1%E7%90%86/%E8%B7%AF%E7%94%B1%E7%AE%A1%E7%90%86-%E4%B8%AD%E9%97%B4%E4%BB%B6%E6%8B%A6%E6%88%AA%E5%99%A8/%E4%B8%AD%E9%97%B4%E4%BB%B6%E6%8B%A6%E6%88%AA%E5%99%A8-%E5%9F%BA%E6%9C%AC%E4%BB%8B%E7%BB%8D.md) 章节。
+
+## `Server` 日志与业务日志
+
+这是一个 `FAQ`。
+
+我们需要注意的是，这里提到的日志都是 `Server` 的日志，类似于 `nginx`, `apache`, `tomcat` 等等一系列 `Web Server` 服务的日志，只允许 `Server` 输出内容，开发者无法往 `Server` 的日志文件中写入日志内容，并且日志类型和格式是完全固定的。
+
+`GoFrame` 框架也提供了日志模块，由 `glog` 日志组件实现，开发者通过 `glog` 组件打印的日志属于业务日志，程序业务代码可以决定输出什么内容，输出到哪里，输出格式是什么样等。并且常用 `g.Log()` 方法来输出业务日志，该方法支持自动读取配置文件中的 `logger` 配置项。具体请参考 [日志组件](../../核心组件/日志组件/日志组件.md) 章节。

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221//351/253/230/347/272/247/347/211/271/346/200/247//350/207/252/345/256/232/344/271/211/347/212/266/346/200/201/347/240/201/345/244/204/347/220/206.md

@@ -0,0 +1,91 @@
+我们可以对WebServer指定的状态码进行自定义处理，例如针对常见的 `404/403/500` 等错误，我们可以展示自定义的错误信息、页面内容，或者跳转到一个特定的页面。
+
+相关方法如下：
+
+```go
+func (s *Server) BindStatusHandler(status int, handler HandlerFunc)
+func (s *Server) BindStatusHandlerByMap(handlerMap map[int]HandlerFunc)
+
+func (d *Domain) BindStatusHandler(status int, handler HandlerFunc)
+func (d *Domain) BindStatusHandlerByMap(handlerMap map[int]HandlerFunc)
+```
+
+可以看到，我们可以使用 `BindStatusHandler` 或者 `BindStatusHandlerMap` 来实现针对指定的状态码进行自定义的回调函数处理，并且该特性也支持针对特定的域名绑定。我们来看几个简单的示例。
+
+## 基本使用
+
+```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("halo 世界！")
+    })
+    s.BindStatusHandler(404, func(r *ghttp.Request){
+        r.Response.Writeln("This is customized 404 page")
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+执行后，我们访问没有绑定的路由页面，例如 [http://127.0.0.1:8199/test](http://127.0.0.1:8199/test) ，可以看到，页面显示了我们期望的返回结果： `This is customized 404 page`。
+
+此外，常见的Web页面请求错误状态码处理方式，是引导用户跳转到指定的错误页面，因此，在状态码回调处理函数中，我们可以使用 `r.RedirectTo` 方法来进行页面跳转，示例如下：
+
+```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()
+}
+```
+
+执行后，我们手动通过浏览器访问一个不存在的页面，例如 [http://127.0.0.1:8199/test](http://127.0.0.1:8199/test) ，可以看到，页面被引导跳转到了 [http://127.0.0.1:8199/status/404](http://127.0.0.1:8199/status/404) 页面，并且可以看到页面返回内容： `woops, status 404 found`
+
+## 批量设置
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+)
+
+func main() {
+    s := g.Server()
+    s.BindStatusHandlerByMap(map[int]ghttp.HandlerFunc {
+        403 : func(r *ghttp.Request){r.Response.Writeln("403")},
+        404 : func(r *ghttp.Request){r.Response.Writeln("404")},
+        500 : func(r *ghttp.Request){r.Response.Writeln("500")},
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+可以看到，我们可以通过 `BindStatusHandlerByMap` 方法对需要自定义的状态码进行批量设置。该示例程序执行后，当服务接口返回的状态码为 `403/404/500` 时，接口将会返回对应的状态码数字。
+
+## 注意事项
+
+在自定义状态码处理方法中如果涉及到内容的输出，往往需要使用 `r.Response.ClearBuffer()` 方法将原本缓冲区的输出内容清空。

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221//351/253/230/347/272/247/347/211/271/346/200/247//351/235/231/346/200/201/346/226/207/344/273/266/346/234/215/345/212/241.md

@@ -0,0 +1,166 @@
+## 静态文件服务配置
+
+默认情况下， `GoFrame Server` 关闭了静态文件服务的功能，如果开发者配置了 **静态文件目录**，那么静态文件服务将会自动开启。
+
+静态文件服务涉及到的常用配置方法如下：
+
+```go
+// 设置http server参数 - ServerRoot
+func (s *Server) SetServerRoot(root string)
+
+// 添加静态文件搜索目录，必须给定目录的绝对路径
+func (s *Server) AddSearchPath(path string)
+
+// 设置http server参数 - IndexFiles，默认展示文件，如：index.html, index.htm
+func (s *Server) SetIndexFiles(index []string)
+
+// 是否允许展示访问目录的文件列表
+func (s *Server) SetIndexFolder(enabled bool)
+
+// 添加URI与静态目录的映射
+func (s *Server) AddStaticPath(prefix string, path string)
+
+// 静态文件服务总开关：是否开启/关闭静态文件服务
+func (s *Server) SetFileServerEnabled(enabled bool)
+
+// 设置URI重写规则
+func (s *Server) SetRewrite(uri string, rewrite string)
+
+// 设置URI重写规则（批量）
+func (s *Server) SetRewriteMap(rewrites map[string]string)
+```
+
+简要介绍：
+
+1. `IndexFiles` 为当访问目录时默认检索的文件名称列表（按照slice先后顺序进行检索），当检索的文件存在时则返回文件内容，否则展示目录列表( `SetIndexFolder` 为 `true` 时)，默认的 `IndexFiles` 为： `index.html, index.htm`；
+2. `SetIndexFolder` 为设置是否在用户访问文件目录，且没有在目录下检索到 `IndexFiles` 时，则展示目录下的文件列表，默认为关闭；
+3. `SetServerRoot` 为设置默认提供服务的静态文件目录，该目录会被自动添加到 `SearchPath` 中的第一个搜索路径；
+4. `AddSearchPath` 为添加静态文件检索目录，可以有多个，按照文件目录添加的先后顺序执行优先级检索；
+5. `AddStaticPath` 为添加 `URI` 与目录路径的映射关系，可以自定义静态文件目录的访问URI规则；
+6. `SetRewrite`/ `SetRewriteMap` 为重写规则设置（类似于 `nginx` 的 `rewrite`），严格上来讲不仅仅是静态文件服务，当然也支持动态的路由注册的 `rewrite`；
+:::tip
+设置静态文件服务的目录路径时，可以使用绝对路径，也可以使用相对路径，例如设置当前运行目录提供静态文件服务可以使用 `SetServerRoot(".")`。
+
+开发者可以设置多个文件目录来提供静态文件服务，并且可以设置目录及URI的优先级，但是一旦通过 `SetFileServerEnabled` 关闭了静态服务，所有静态文件/目录的访问都将失效。
+:::
+## 示例1， 基本使用
+
+```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()
+}
+```
+
+## 示例2，静态目录映射
+
+```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.AddStaticPath("/my-doc", "/Users/john/Documents")
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+## 示例3，静态目录映射，优先级控制
+
+静态目录映射的优先级按照绑定的 `URI` 精准度进行控制，绑定的URI越精准（深度优先匹配），那么优先级越高。
+
+```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.AddStaticPath("/my-doc", "/Users/john/Documents")
+    s.AddStaticPath("/my-doc/test", "/Users/john/Temp")
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+其中，访问 `/my-doc/test` 的优先级会比 `/my-doc` 高，因此假如 `/Users/john/Documents` 目录下存在 `test` 目录（与自定义的 `/my-doc/test` 冲突），将会无法被访问到。
+
+## 示例4， `URI` 重写
+
+`GoFrame` 框架的静态文件服务支持将任意的 `URI` 重写，替换为制定的 `URI`，使用 `SetRewrite/SetRewriteMap` 方法。
+
+示例，在 `/Users/john/Temp` 目录下只有两个文件 `test1.html` 及 `test2.html`。
+
+```go
+package main
+
+import "github.com/gogf/gf/v2/frame/g"
+
+func main() {
+    s := g.Server()
+    s.SetServerRoot("/Users/john/Temp")
+    s.SetRewrite("/test.html", "/test1.html")
+    s.SetRewriteMap(g.MapStrStr{
+        "/my-test1": "/test1.html",
+        "/my-test2": "/test2.html",
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+```
+
+```
+
+执行后，
+
+1. 当我们访问 `/test.html`，其实最终被重写到了 `test1.html`，返回的是该文件内容；
+2. 当我们访问 `/my-test1`，其实最终被重写到了 `test1.html`，返回的是该文件内容；
+3. 当我们访问 `/my-test2`，其实最终被重写到了 `test2.html`，返回的是该文件内容；
+
+## 示例5，跨域
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+    "github.com/gogf/gf/v2/os/glog"
+)
+
+func beforeServeHook(r *ghttp.Request) {
+    glog.Debugf(r.GetCtx(), "beforeServeHook [is file:%v] URI:%s", r.IsFileRequest(), r.RequestURI)
+    r.Response.CORSDefault()
+}
+
+// 利用hook注入跨域配置
+func main() {
+    s := g.Server()
+    s.BindHookHandler("/*", ghttp.HookBeforeServe, beforeServeHook)
+    s.SetServerRoot(".")
+    s.SetFileServerEnabled(true)
+    s.SetAddr(":8080")
+    s.Run()
+}
+```