@colin4k1024/tsp 2.4.0

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221/Session/Session-Redis-KeyValue.md

@@ -0,0 +1,49 @@
+## Redis KeyValue Storage
+
+文件存储的方式在单节点的场景下非常不错，但是涉及到对应用进行多节点部署的场景下，各个节点的 `Session` 无法共享，因此需要将 `Session` 存储单独剥离出来管理， `Redis` 服务器是比较常见的一个选择。
+
+`gsession` 的 `Redis` 存储使用 `StorageRedis` 对象实现，与文件存储比较类似，为了提高执行效率，也是采用了 `内存+Redis` 的方式。与文件存储唯一不同的是，在每一次请求中如果需要对 `Session` 进行操作时，将会从 `Redis` 中拉取一次最新的 `Session` 数据（而文件存储只会在 `Session` 不存在时读取一次文件）。在每一次请求结束之后，将全量的 `Session` 数据通过 `JSON` 序列化之后通过 `KeyValue` 方式更新到 `Redis` 服务中。
+:::tip
+如果单个用户下(以用户维度举例) `Session` 数据量不大的业务场景中，都推荐使用这种 `Storage` 方式。如果单个用户 `Session` 数据量较大（例如 `>10MB`），可以参考 `HashTable` 的 `Storage` 方式： [Session-Redis-HashTable](Session-Redis-HashTable.md)
+:::
+## 使用示例
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+    "github.com/gogf/gf/v2/os/gsession"
+    "github.com/gogf/gf/v2/os/gtime"
+    "time"
+)
+
+func main() {
+    s := g.Server()
+    s.SetSessionMaxAge(time.Minute)
+    s.SetSessionStorage(gsession.NewStorageRedis(g.Redis()))
+    s.Group("/", func(group *ghttp.RouterGroup) {
+        group.ALL("/set", func(r *ghttp.Request) {
+            r.Session.Set("time", gtime.Timestamp())
+            r.Response.Write("ok")
+        })
+        group.ALL("/get", func(r *ghttp.Request) {
+            r.Response.Write(r.Session.Data())
+        })
+        group.ALL("/del", func(r *ghttp.Request) {
+            _ = r.Session.RemoveAll()
+            r.Response.Write("ok")
+        })
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+在该实例中，为了方便观察过期失效，我们将 `Session` 的过期时间设置为 `1分钟`。执行后，
+
+1. 首先，访问 [http://127.0.0.1:8199/set](http://127.0.0.1:8199/set) 设置一个 `Session` 变量；
+2. 随后，访问 [http://127.0.0.1:8199/get](http://127.0.0.1:8199/get) 可以看到该 `Session` 变量已经设置并成功获取；
+3. 接着，我们停止程序，并重新启动，再次访问 [http://127.0.0.1:8199/get](http://127.0.0.1:8199/get)，可以看到 `Session` 变量已经从 `Redis` 存储中恢复；如果我们手动修改 `Redis` 中的对应键值数据，页面刷新时也会读取到最新的值；
+4. 等待1分钟后，再次访问 [http://127.0.0.1:8199/get](http://127.0.0.1:8199/get) 可以看到已经无法获取该 `Session`，因为该 `Session` 已经过期；

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221/Session/Session-RegenerateId.md

@@ -0,0 +1,156 @@
+## 会话固定攻击简介
+
+会话固定攻击（`Session Fixation Attacks`）是一种常见的Web应用安全漏洞，攻击者通过设置用户的会话标识符（`Session ID`）来控制用户的会话。这种攻击的基本流程如下：
+
+1. 攻击者获取一个有效的 `Session ID`（通过访问目标网站或其他方式）
+2. 攻击者诱使受害者使用这个`Session ID`访问目标网站（例如通过特制的URL、XSS攻击等）
+3. 受害者使用这个预设的`Session ID`登录网站
+4. 登录成功后，该`Session ID`与受害者的账户关联
+5. 攻击者使用同一个`Session ID`访问网站，从而获得受害者的身份和权限
+
+这种攻击的危害在于，攻击者无需破解用户的密码就能获取用户的身份，从而访问用户的敏感信息或执行未授权的操作。
+
+## 防范会话固定攻击
+
+防范会话固定攻击的最佳实践是在用户成功认证（登录）后重新生成`Session ID`。这样，即使攻击者设法让用户使用特定的`Session ID`，在登录成功后该 ID 也会被替换，从而使攻击失效。
+
+`GoFrame` 框架提供了 `RegenerateId` 和 `MustRegenerateId` 方法来实现这一安全机制。
+
+## `RegenerateId` 方法
+
+在一些安全性要求较高的应用场景中，为了防止**会话固定攻击**（`Session Fixation Attacks`），通常需要在用户登录成功后重新生成 `Session ID`。`GoFrame` 框架提供了 `RegenerateId` 和 `MustRegenerateId` 方法来实现这一功能。
+
+### 实现原理
+
+`RegenerateId` 方法的实现原理如下：
+
+1. 生成新的`Session ID`
+2. 将当前会话数据复制到新的`Session ID`下
+3. 根据`deleteOld`参数决定是否删除旧的会话数据
+4. 更新当前会话的ID为新生成的 ID
+
+这样就实现了会话数据的无缝迁移，同时保证了安全性。
+
+### `RegenerateId` 方法
+
+- 说明：`RegenerateId` 方法用于为当前会话重新生成一个新的 `Session ID`，同时保留会话中的所有数据。这在用户登录成功后特别有用，可以防止会话固定攻击。
+- 格式：
+
+    ```go
+    RegenerateId(deleteOld bool) (newId string, err error)
+    ```
+
+- 参数说明：
+  - `deleteOld`：指定是否立即删除旧的会话数据
+    - 如果为 `true`：旧的会话数据将被立即删除
+    - 如果为 `false`：旧的会话数据将被保留，并根据其 TTL 自动过期
+
+- 返回值：
+  - `newId`：新生成的`Session ID`
+  - `err`：操作过程中可能出现的错误
+
+### `MustRegenerateId` 方法
+
+- 说明：`MustRegenerateId` 方法与 `RegenerateId` 功能相同，但如果操作过程中出现错误，它会直接`panic`。这在确保`Session ID`必须被重新生成的场景中非常有用。
+- 格式：
+
+    ```go
+    MustRegenerateId(deleteOld bool) string
+    ```
+
+- 参数说明：
+  - `deleteOld`：与 `RegenerateId` 方法中的参数含义相同
+
+- 返回值：
+  - 新生成的`Session ID`
+
+### 使用示例
+
+```go
+package main
+
+import (
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/net/ghttp"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+func main() {
+	s := g.Server()
+
+	// 模拟登录接口
+	s.BindHandler("/login", func(r *ghttp.Request) {
+		username := r.Get("username").String()
+		// password := r.Get("password").String()
+
+		// 假设这里进行了用户名密码验证
+		// password ...
+
+		// 验证通过后，存储用户信息到 Session
+		r.Session.MustSet("user", g.Map{
+			"username":   username,
+			"login_time": gtime.Now(),
+		})
+
+		// 重要：登录成功后重新生成 Session ID，防止会话固定攻击
+		// 参数为 true 表示立即删除旧的会话数据
+		// 返回的session id可以不使用，server将自动通过header返回最新的session id
+		_, err := r.Session.RegenerateId(true)
+		if err != nil {
+			r.Response.WriteJson(g.Map{
+				"code":    500,
+				"message": "Session ID 重新生成失败",
+			})
+			return
+		}
+
+		r.Response.WriteJson(g.Map{
+			"code":    0,
+			"message": "登录成功",
+		})
+	})
+
+	// 获取用户信息接口
+	// 注意需要通过header提交session id
+	s.BindHandler("/user/info", func(r *ghttp.Request) {
+		user := r.Session.MustGet("user")
+		if user == nil {
+			r.Response.WriteJson(g.Map{
+				"code":    403,
+				"message": "未登录或会话已过期",
+			})
+			return
+		}
+		r.Response.WriteJson(g.Map{
+			"code":    0,
+			"message": "获取成功",
+			"data":    user,
+		})
+	})
+
+	// 注销登录接口
+	s.BindHandler("/logout", func(r *ghttp.Request) {
+		// 清除所有会话数据
+		_ = r.Session.RemoveAll()
+		r.Response.WriteJson(g.Map{
+			"code":    0,
+			"message": "注销成功",
+		})
+	})
+
+	s.SetPort(8000)
+	s.Run()
+}
+```
+
+### 安全建议
+
+1. **登录后重新生成 Session ID**：在用户成功登录后，始终调用 `RegenerateId` 方法重新生成`Session ID`，这是防止会话固定攻击的基本做法。
+
+2. **敏感操作后重新生成 Session ID**：在用户执行密码修改、权限变更等敏感操作后，也应考虑重新生成`Session ID`。
+
+3. **删除旧会话数据**：在重新生成`Session ID`时，通常建议将 `deleteOld` 参数设置为 `true`，立即删除旧的会话数据，防止会话数据被恶意利用。
+
+4. **使用 HTTPS**：始终使用`HTTPS`协议传输`Session ID`，防止会话信息被网络安全工具或中间人攻击捕获。
+
+5. **设置正确的 Cookie 属性**：对于存储`Session ID`的`Cookie`，应设置 `HttpOnly`、`Secure` 和 `SameSite` 属性，防止`XSS`攻击和`CSRF`攻击。

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221/Session/Session-Storage/346/216/245/345/217/243/345/274/200/345/217/221.md

@@ -0,0 +1,63 @@
+大部分场景下，通过 `gsession` 组件内置提供的常见 `Storage` 实现已经能够满足需求。如果有特殊的场景需要制定不易开发 `Storage` 当然也是支持的，因为 `gsession` 的功能都采用了接口化设计。
+
+## Storage定义
+
+[https://github.com/gogf/gf/blob/master/os/gsession/gsession\_storage.go](https://github.com/gogf/gf/blob/master/os/gsession/gsession_storage.go)
+
+```go
+// Storage is the interface definition for session storage.
+type Storage interface {
+    // New creates a custom session id.
+    // This function can be used for custom session creation.
+    New(ctx context.Context, ttl time.Duration) (id string, err error)
+
+    // Get retrieves and returns session value with given key.
+    // It returns nil if the key does not exist in the session.
+    Get(ctx context.Context, id string, key string) (value interface{}, err error)
+
+    // GetMap retrieves all key-value pairs as map from storage.
+    GetMap(ctx context.Context, id string) (data map[string]interface{}, err error)
+
+    // GetSize retrieves and returns the size of key-value pairs from storage.
+    GetSize(ctx context.Context, id string) (size int, err error)
+
+    // Set sets one key-value session pair to the storage.
+    // The parameter `ttl` specifies the TTL for the session id.
+    Set(ctx context.Context, id string, key string, value interface{}, ttl time.Duration) error
+
+    // SetMap batch sets key-value session pairs as map to the storage.
+    // The parameter `ttl` specifies the TTL for the session id.
+    SetMap(ctx context.Context, id string, data map[string]interface{}, ttl time.Duration) error
+
+    // Remove deletes key with its value from storage.
+    Remove(ctx context.Context, id string, key string) error
+
+    // RemoveAll deletes all key-value pairs from storage.
+    RemoveAll(ctx context.Context, id string) error
+
+    // GetSession returns the session data as `*gmap.StrAnyMap` for given session id from storage.
+    //
+    // The parameter `ttl` specifies the TTL for this session.
+    // The parameter `data` is the current old session data stored in memory,
+    // and for some storage it might be nil if memory storage is disabled.
+    //
+    // This function is called ever when session starts. It returns nil if the TTL is exceeded.
+    GetSession(ctx context.Context, id string, ttl time.Duration, data *gmap.StrAnyMap) (*gmap.StrAnyMap, error)
+
+    // SetSession updates the data for specified session id.
+    // This function is called ever after session, which is changed dirty, is closed.
+    // This copy all session data map from memory to storage.
+    SetSession(ctx context.Context, id string, data *gmap.StrAnyMap, ttl time.Duration) error
+
+    // UpdateTTL updates the TTL for specified session id.
+    // This function is called ever after session, which is not dirty, is closed.
+    UpdateTTL(ctx context.Context, id string, ttl time.Duration) error
+}
+```
+
+每一个方法的调用时机都在注释中详细介绍了，开发者在实现自定义的 `Storage` 时，可以充分参考内置的几种 `Storage` 实现。
+
+## 注意事项
+
+- `Storage` 接口中，并不是所有的接口方法都需要实现，开发者仅需要根据业务需要，实现特定调用时机的一些接口即可。
+- 为了提高 `Session` 的执行性能，接口有 `gmap.StrAnyMap` 容器类型的使用，开发时可以参考一下章节： [字典类型-gmap](../../组件列表/数据结构/字典类型-gmap/字典类型-gmap.md)

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221/Session/Session.md

@@ -0,0 +1,42 @@
+`GoFrame` 框架提供了完善的 `Session` 管理能力，由 `gsession` 组件实现。由于 `Session` 机制在 `HTTP` 服务中最常用，因此后续章节中将着重以 `HTTP` 服务为示例介绍 `Session` 的使用。
+
+## 基本介绍
+
+接口文档： [https://pkg.go.dev/github.com/gogf/gf/v2/os/gsession](https://pkg.go.dev/github.com/gogf/gf/v2/os/gsession)
+
+任何时候都可以通过 `ghttp.Request` 获取 `Session` 对象，因为 `Cookie` 和 `Session` 都是和请求会话相关，因此都属于 `Request` 的成员对象，并对外公开。 `GoFrame` 框架的 `Session` 默认过期时间是 `24小时`。
+
+`SessionId` 默认通过 `Cookie` 来传递，并且也支持客户端通过 `Header` 传递 `SessionId`， `SessionId` 的识别名称可以通过 `ghttp.Server` 的 `SetSessionIdName` 进行修改。 `Session` 的操作是支持 `并发安全` 的，这也是框架在对 `Session` 的设计上不采用直接以 `map` 的形式操作数据的原因。在 `HTTP` 请求流程中，我们可以通过 `ghttp.Request` 对象来获取 `Session` 对象，并执行相应的数据操作。
+
+此外， `ghttp.Server` 中的 `SessionId` 使用的是客户端的 `RemoteAddr + Header` 请求信息通过 `guid` 模块来生成的，保证随机及唯一性： [https://github.com/gogf/gf/blob/master/net/ghttp/ghttp\_request.go](https://github.com/gogf/gf/blob/master/net/ghttp/ghttp_request.go)
+
+## `gsession` 模块
+
+`Session` 的管理功能由独立的 `gsession` 模块实现，并已完美整合到了 `ghttp.Server` 中。由于该模块是解耦独立的，因此可以应用到更多不同的场景中，例如： `TCP` 通信、 `gRPC` 接口服务等等。在 `gsession` 模块中有比较重要的三个对象/接口：
+
+1. `gsession.Manager`：管理 `Session` 对象、 `Storage` 持久化存储对象、以及过期时间控制。
+2. `gsession.Session`：单个 `Session` 会话管理对象，用于 `Session` 参数的增删查改等数据管理操作。
+3. `gsession.Storage`：这是一个接口定义，用于 `Session` 对象的持久化存储、数据写入/读取、存活更新等操作，开发者可基于该接口实现自定义的持久化存储特性。 该接口定义详见： [https://github.com/gogf/gf/blob/master/os/gsession/gsession\_storage.go](https://github.com/gogf/gf/blob/master/os/gsession/gsession_storage.go)
+
+## 存储实现方式
+
+`gsession` 实现并为开发者提供了常见的四种 `Session` 存储实现方式：
+
+| Storage | 支持分布式 | 支持持久化 | 内存占用 | 执行效率 | 简要介绍 |
+| --- | --- | --- | --- | --- | --- |
+| `StorageFile` | 否 | 是 | 中 | 中 | 基于文件存储（默认）。单节点部署方式下比较高效的持久化存储方式： [Session-File](Session-File.md) |
+| `StorageMemory` | 否 | 否 | 高 | 高 | 基于纯内存存储。单节点部署，性能最高效，但是无法持久化保存，重启即丢失： [Session-Memory](Session-Memory.md) |
+| `StorageRedis` | 是 | 是 | 中 | 中 | 基于 `Redis` 存储（ `Key-Value`）。远程 `Redis` 节点存储 `Session` 数据，支持应用多节点部署： [Session-Redis-KeyValue](Session-Redis-KeyValue.md) |
+| `StorageRedisHashTable` | 是 | 是 | 低 | 低 | 基于 `Redis` 存储（ `HashTable`）。远程 `Redis` 节点存储 `Session` 数据，支持应用多节点部署： [Session-Redis-HashTable](Session-Redis-HashTable.md) |
+
+四种方式各有优劣，详细介绍请查看对应章节。
+
+## `Session` 的初始化
+
+以常见的HTTP请求为例。 `ghttp.Request` 中的 `Session` 对象采用了" **懒初始化( `LazyInitialization`)**"设计方式，默认在 `Request` 中有一个 `Session` 属性对象，但是并未初始化（一个空对象），只有在使用 `Session` 属性对象的方法时才会真正执行初始化。这样的设计既保障了未使用 `Session` 特性的请求执行性能，也保证了组件使用的易用性。
+
+## `Session` 的销毁/注销
+
+用户 `Session` 不再使用，例如用户注销登录状态，需要从存储中硬删除，那么可以调用 `RemoveAll` 方法。
+
+## 相关文档

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221//345/210/206/351/241/265/347/256/241/347/220/206//345/210/206/351/241/265/347/256/241/347/220/206-Ajax/345/210/206/351/241/265.md

@@ -0,0 +1,63 @@
+`Ajax` 分页与其他分页方式的区别在于，分页链接会使用 `Javascript` 方法来实现，该 `Javascript` 方法是分页方法，参数固定为该分页对应的分页 `URL` 地址。该 `Javascript` 方法通过 `Ajax` 获取到 `URL` 连接对应的分页内容后渲染到页面。
+
+完整示例如下：
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+    "github.com/gogf/gf/v2/os/gview"
+)
+
+func main() {
+    s := g.Server()
+    s.BindHandler("/page/ajax", func(r *ghttp.Request) {
+        page := r.GetPage(100, 10)
+        page.AjaxActionName = "DoAjax"
+        buffer, _ := gview.ParseContent(`
+        <html>
+            <head>
+                <style>
+                    a,span {padding:8px; font-size:16px;}
+                    div{margin:5px 5px 20px 5px}
+                </style>
+                <script src="https://cdn.bootcss.com/jquery/2.0.3/jquery.min.js"></script>
+                <script>
+                function DoAjax(url) {
+                     $.get(url, function(data,status) {
+                         $("body").html(data);
+                     });
+                }
+                </script>
+            </head>
+            <body>
+                <div>{{.page1}}</div>
+                <div>{{.page2}}</div>
+                <div>{{.page3}}</div>
+                <div>{{.page4}}</div>
+            </body>
+        </html>
+        `, g.Map{
+            "page1": page.GetContent(1),
+            "page2": page.GetContent(2),
+            "page3": page.GetContent(3),
+            "page4": page.GetContent(4),
+        })
+        r.Response.Write(buffer)
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+在该示例中，我们定义了一个 `DoAjax(url)` 方法用来执行分页操作，为演示需要它逻辑很简单，会加载指定分页页面的内容并覆盖掉当前页面的分页内容。
+
+```
+function DoAjax(url) {
+     $.get(url, function(data,status) {
+         $("body").html(data);
+     });
+}
+```

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221//345/210/206/351/241/265/347/256/241/347/220/206//345/210/206/351/241/265/347/256/241/347/220/206-URL/346/250/241/346/235/277.md

@@ -0,0 +1,45 @@
+`gpage` 支持自定义 `URL` 模板，在模板中可以使用 `{.page}` 内置变量替换页码的内容，我们来看一个简单的示例：
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+    "github.com/gogf/gf/v2/os/gview"
+)
+
+func main() {
+    s := g.Server()
+    s.BindHandler("/page/template/{page}.html", func(r *ghttp.Request) {
+        page := r.GetPage(100, 10)
+        page.UrlTemplate = "/order/list/{.page}.html"
+        buffer, _ := gview.ParseContent(`
+        <html>
+            <head>
+                <style>
+                    a,span {padding:8px; font-size:16px;}
+                    div{margin:5px 5px 20px 5px}
+                </style>
+            </head>
+            <body>
+                <div>{{.page1}}</div>
+                <div>{{.page2}}</div>
+                <div>{{.page3}}</div>
+                <div>{{.page4}}</div>
+            </body>
+        </html>
+        `, g.Map{
+            "page1": page.GetContent(1),
+            "page2": page.GetContent(2),
+            "page3": page.GetContent(3),
+            "page4": page.GetContent(4),
+        })
+        r.Response.Write(buffer)
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+在代码中，我们可以使用 `UrlTemplate` 属性设置 `URL` 模板，执行后，结果如下：

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221//345/210/206/351/241/265/347/256/241/347/220/206//345/210/206/351/241/265/347/256/241/347/220/206-/345/212/250/346/200/201/345/210/206/351/241/265.md

@@ -0,0 +1,46 @@
+动态分页是通过 `GET` 参数(通过 `QueryString`)传递分页参数，默认分页参数名称为 `page`。
+
+示例如下：
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+    "github.com/gogf/gf/v2/os/gview"
+)
+
+func main() {
+    s := g.Server()
+    s.BindHandler("/page/demo", func(r *ghttp.Request) {
+        page := r.GetPage(100, 10)
+        buffer, _ := gview.ParseContent(`
+        <html>
+            <head>
+                <style>
+                    a,span {padding:8px; font-size:16px;}
+                    div{margin:5px 5px 20px 5px}
+                </style>
+            </head>
+            <body>
+                <div>{{.page1}}</div>
+                <div>{{.page2}}</div>
+                <div>{{.page3}}</div>
+                <div>{{.page4}}</div>
+            </body>
+        </html>
+        `, g.Map{
+            "page1": page.GetContent(1),
+            "page2": page.GetContent(2),
+            "page3": page.GetContent(3),
+            "page4": page.GetContent(4),
+        })
+        r.Response.Write(buffer)
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+该示例中，我们展示了四种预定义的分页样式，并通过 `GET` 方式进行分页传参。执行后，输出的内容如下图所示：

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221//345/210/206/351/241/265/347/256/241/347/220/206//345/210/206/351/241/265/347/256/241/347/220/206-/350/207/252/345/256/232/344/271/211/345/210/206/351/241/265.md

@@ -0,0 +1,112 @@
+由于分页对象预定义的样式比较有限，有的时候我们想自定义分页的样式或者标签，由于分页对象的的所有属性和方法都是公开的，这便为开发者自定义分页样式提供了非常高的灵活度。开发者可以通过以下方式实现自定义分页内容：
+
+1. 对输出内容进行正则匹配替换实现自定义。
+2. 根据分页对象公开的属性和方法自行组织分页内容实现自定义。
+
+## 自定义标签替换
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+    "github.com/gogf/gf/v2/os/gview"
+    "github.com/gogf/gf/v2/text/gstr"
+    "github.com/gogf/gf/v2/util/gpage"
+)
+
+// wrapContent wraps each of the page tag with html li and ul.
+func wrapContent(page *gpage.Page) string {
+    content := page.GetContent(4)
+    content = gstr.ReplaceByMap(content, map[string]string{
+        "<span":  "<li><span",
+        "/span>": "/span></li>",
+        "<a":     "<li><a",
+        "/a>":    "/a></li>",
+    })
+    return "<ul>" + content + "</ul>"
+}
+
+func main() {
+    s := g.Server()
+    s.BindHandler("/page/custom1/*page", func(r *ghttp.Request) {
+        page := r.GetPage(100, 10)
+        content := wrapContent(page)
+        buffer, _ := gview.ParseContent(`
+        <html>
+            <head>
+                <style>
+                    a,span {padding:8px; font-size:16px;}
+                    div{margin:5px 5px 20px 5px}
+                </style>
+            </head>
+            <body>
+                <div>{{.page}}</div>
+            </body>
+        </html>
+        `, g.Map{
+            "page": content,
+        })
+        r.Response.Write(buffer)
+    })
+    s.SetPort(10000)
+    s.Run()
+}
+```
+
+执行后，页面输出结果为：
+
+## 定义分页标签名称
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+    "github.com/gogf/gf/v2/os/gview"
+    "github.com/gogf/gf/v2/util/gpage"
+)
+
+// pageContent customizes the page tag name.
+func pageContent(page *gpage.Page) string {
+    page.NextPageTag = "NextPage"
+    page.PrevPageTag = "PrevPage"
+    page.FirstPageTag = "HomePage"
+    page.LastPageTag = "LastPage"
+    pageStr := page.FirstPage()
+    pageStr += page.PrevPage()
+    pageStr += page.PageBar()
+    pageStr += page.NextPage()
+    pageStr += page.LastPage()
+    return pageStr
+}
+
+func main() {
+    s := g.Server()
+    s.BindHandler("/page/custom2/*page", func(r *ghttp.Request) {
+        page := r.GetPage(100, 10)
+        buffer, _ := gview.ParseContent(`
+        <html>
+            <head>
+                <style>
+                    a,span {padding:8px; font-size:16px;}
+                    div{margin:5px 5px 20px 5px}
+                </style>
+            </head>
+            <body>
+                <div>{{.page}}</div>
+            </body>
+        </html>
+        `, g.Map{
+            "page": pageContent(page),
+        })
+        r.Response.Write(buffer)
+    })
+    s.SetPort(10000)
+    s.Run()
+}
+```
+
+执行后，页面输出结果为：

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221//345/210/206/351/241/265/347/256/241/347/220/206//345/210/206/351/241/265/347/256/241/347/220/206-/351/235/231/346/200/201/345/210/206/351/241/265.md

@@ -0,0 +1,91 @@
+静态分页是指页面的分页参数使用的是路由传参，这种场景下分页对象与 `Server` 的路由定义耦合性比较大。路由定义中需要给定一个 `page` 名称的路由参数，可以使用模糊匹配路由 `*page`，也可以使用命名匹配路由 `:page`，也可以使用字段匹配路由 `{page}`。
+
+### 示例1，使用模糊匹配路由
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+    "github.com/gogf/gf/v2/os/gview"
+)
+
+func main() {
+    s := g.Server()
+    s.BindHandler("/page/static/*page", func(r *ghttp.Request) {
+        page := r.GetPage(100, 10)
+        buffer, _ := gview.ParseContent(`
+        <html>
+            <head>
+                <style>
+                    a,span {padding:8px; font-size:16px;}
+                    div{margin:5px 5px 20px 5px}
+                </style>
+            </head>
+            <body>
+                <div>{{.page1}}</div>
+                <div>{{.page2}}</div>
+                <div>{{.page3}}</div>
+                <div>{{.page4}}</div>
+            </body>
+        </html>
+        `, g.Map{
+            "page1": page.GetContent(1),
+            "page2": page.GetContent(2),
+            "page3": page.GetContent(3),
+            "page4": page.GetContent(4),
+        })
+        r.Response.Write(buffer)
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+执行后，我们手动访问 [http://127.0.0.1:8199/page/static/6](http://127.0.0.1:8199/page/static/6) 页面的结果如下：
+
+### 示例2，使用字段匹配路由
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+    "github.com/gogf/gf/v2/os/gview"
+)
+
+func main() {
+    s := g.Server()
+    s.BindHandler("/:obj/*action/{page}.html", func(r *ghttp.Request) {
+        page := r.GetPage(100, 10)
+        buffer, _ := gview.ParseContent(`
+        <html>
+            <head>
+                <style>
+                    a,span {padding:8px; font-size:16px;}
+                    div{margin:5px 5px 20px 5px}
+                </style>
+            </head>
+            <body>
+                <div>{{.page1}}</div>
+                <div>{{.page2}}</div>
+                <div>{{.page3}}</div>
+                <div>{{.page4}}</div>
+            </body>
+        </html>
+        `, g.Map{
+            "page1": page.GetContent(1),
+            "page2": page.GetContent(2),
+            "page3": page.GetContent(3),
+            "page4": page.GetContent(4),
+        })
+        r.Response.Write(buffer)
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+该示例的路由规则更加灵活，其中使用了 `{page}` 字段匹配规则，用于获取当前的分页页码信息。执行后，我们按照路由规则随意访问一个URL如： [http://127.0.0.1:8199/order/list/6.html](http://127.0.0.1:8199/order/list/6.html) ，结果如下图所示：