@colin4k1024/tsp 2.4.0

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221//350/267/257/347/224/261/347/256/241/347/220/206//350/267/257/347/224/261/347/256/241/347/220/206-/350/267/257/347/224/261/346/263/250/345/206/214//350/267/257/347/224/261/346/263/250/345/206/214-/345/257/271/350/261/241/346/263/250/345/206/214.md

@@ -0,0 +1,431 @@
+**对象注册** 是通过一个实例化的对象来执行路由注册，以后每一个请求都交给该对象（同一对象）处理， **该对象常驻内存不释放**。
+
+**相关方法**：
+
+```go
+func (s *Server) BindObject(pattern string, object interface{}, methods ...string) error
+func (s *Server) BindObjectMethod(pattern string, object interface{}, method string) error
+func (s *Server) BindObjectRest(pattern string, object interface{}) error
+```
+
+**前置约定**：需要进行路由注册的方法必须为 **公开方法**，并且 **方法定义** 如下：
+
+```go
+func(r *ghttp.Request)
+```
+
+否则无法完成注册，路由注册时将会有错误提示，例如：
+
+```
+panic: interface conversion: interface {} is xxx, not func(*ghttp.Request)
+```
+
+## 对象注册- `BindObject`
+
+我们可以通过 `BindObject` 方法完成对象的注册。
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+)
+
+type Controller struct{}
+
+func (c *Controller) Index(r *ghttp.Request) {
+    r.Response.Write("index")
+}
+
+func (c *Controller) Show(r *ghttp.Request) {
+    r.Response.Write("show")
+}
+
+func main() {
+    s := g.Server()
+    c := new(Controller)
+    s.BindObject("/object", c)
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+可以看到，对象在进行路由注册时便生成了一个对象（对象在 `Server` 启动时便生成），此后不管多少请求进入， `Server` 都是将请求转交给该对象对应的方法进行处理。该示例执行后，终端输出的路由表如下：
+
+```text
+SERVER | DOMAIN  | ADDRESS | METHOD |     ROUTE     |         HANDLER          | MIDDLEWARE
+|---------|---------|---------|--------|---------------|--------------------------|------------|
+  default | default | :8199   | ALL    | /object       | main.(*Controller).Index |
+|---------|---------|---------|--------|---------------|--------------------------|------------|
+  default | default | :8199   | ALL    | /object/index | main.(*Controller).Index |
+|---------|---------|---------|--------|---------------|--------------------------|------------|
+  default | default | :8199   | ALL    | /object/show  | main.(*Controller).Show  |
+|---------|---------|---------|--------|---------------|--------------------------|------------|
+```
+
+随后可以通过 [http://127.0.0.1:8199/object/show](http://127.0.0.1:8199/object/show) 查看效果。
+:::tip
+控制器中的 `Index` 方法是一个特殊的方法，例如，当注册的路由规则为 `/user` 时，HTTP请求到 `/user` 时，将会自动映射到控制器的 `Index` 方法。也就是说，访问地址 `/user` 和 `/user/index` 将会达到相同的执行效果。
+:::
+### 路由内置变量
+
+当使用 `BindObject` 方法进行对象注册时，在路由规则中可以使用两个内置的变量： `{.struct}` 和 `{.method}`，前者表示当前 **对象名称**，后者表示当前注册的 **方法名**。我们来看一个例子：
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+)
+
+type Order struct{}
+
+func (o *Order) List(r *ghttp.Request) {
+    r.Response.Write("list")
+}
+
+func main() {
+    s := g.Server()
+    o := new(Order)
+    s.BindObject("/{.struct}-{.method}", o)
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+执行后，终端输出的路由表如下：
+
+```text
+SERVER | DOMAIN  | ADDRESS | METHOD |    ROUTE    |      HANDLER       | MIDDLEWARE
+|---------|---------|---------|--------|-------------|--------------------|------------|
+  default | default | :8199   | ALL    | /order-list | main.(*Order).List |
+|---------|---------|---------|--------|-------------|--------------------|------------|
+```
+
+我们尝试着访问 [http://127.0.0.1:8199/order-list](http://127.0.0.1:8199/order-list) ，可以看到页面输出 `list`。如果路由规则中不使用内置变量，那么默认的情况下，方法将会被追加到指定的路由规则末尾。
+
+### 命名风格规则
+
+通过对象进行路由注册时，可以根据对象及方法名称自动生成路由规则，默认的路由规则为：当方法名称带有多个 `单词`（按照字符大写区分单词）时，路由控制器默认会自动使用英文连接符号 `-` 进行拼接，因此访问的时候方法名称需要带 `-` 号。
+
+例如，方法名为 `UserName` 时，生成的路由为 `user-name`；方法名为 `ShowListItems` 时，生成的路由为 `show-list-items`；以此类推。
+
+此外，我们可以通过 `.Server.SetNameToUriType` 方法来设置对象方法名称的路由生成方式。支持的方式目前有 `4` 种，对应 `4` 个常量定义：
+
+```
+UriTypeDefault  = 0 // （默认）全部转为小写，单词以'-'连接符号连接
+UriTypeFullName = 1 // 不处理名称，以原有名称构建成URI
+UriTypeAllLower = 2 // 仅转为小写，单词间不使用连接符号
+UriTypeCamel    = 3 // 采用驼峰命名方式
+```
+
+注意：需要在通过对象进行路由注册前进行该参数的设置，在路由注册后设置将不会生效，那么将使用默认规则。
+
+我们来看一个示例：
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+)
+
+type User struct{}
+
+func (u *User) ShowList(r *ghttp.Request) {
+    r.Response.Write("list")
+}
+
+func main() {
+    u := new(User)
+    s1 := g.Server("UriTypeDefault")
+    s2 := g.Server("UriTypeFullName")
+    s3 := g.Server("UriTypeAllLower")
+    s4 := g.Server("UriTypeCamel")
+
+    s1.SetNameToUriType(ghttp.UriTypeDefault)
+    s2.SetNameToUriType(ghttp.UriTypeFullName)
+    s3.SetNameToUriType(ghttp.UriTypeAllLower)
+    s4.SetNameToUriType(ghttp.UriTypeCamel)
+
+    s1.BindObject("/{.struct}/{.method}", u)
+    s2.BindObject("/{.struct}/{.method}", u)
+    s3.BindObject("/{.struct}/{.method}", u)
+    s4.BindObject("/{.struct}/{.method}", u)
+
+    s1.SetPort(8100)
+    s2.SetPort(8200)
+    s3.SetPort(8300)
+    s4.SetPort(8400)
+
+    s1.Start()
+    s2.Start()
+    s3.Start()
+    s4.Start()
+
+    g.Wait()
+}
+```
+
+为了对比演示效果，这个示例采用了 `多Server` 运行方式，将不同的名称转换方式使用了不同的 `Server` 来配置运行，因此我们可以方便地在同一个程序中，访问不同的 `Server`（通过不同的端口绑定）看到不同的结果。
+
+执行后，终端输出的路由表如下：
+
+```text
+      SERVER    | DOMAIN  | ADDRESS | METHOD |      ROUTE      |        HANDLER        | MIDDLEWARE
+-----------------|---------|---------|--------|-----------------|-----------------------|-------------
+  UriTypeDefault | default | :8100   | ALL    | /user/show-list | main.(*User).ShowList |
+-----------------|---------|---------|--------|-----------------|-----------------------|-------------
+
+      SERVER      | DOMAIN  | ADDRESS | METHOD |     ROUTE      |        HANDLER        | MIDDLEWARE
+------------------|---------|---------|--------|----------------|-----------------------|-------------
+  UriTypeFullName | default | :8200   | ALL    | /User/ShowList | main.(*User).ShowList |
+------------------|---------|---------|--------|----------------|-----------------------|-------------
+
+      SERVER      | DOMAIN  | ADDRESS | METHOD |     ROUTE      |        HANDLER        | MIDDLEWARE
+------------------|---------|---------|--------|----------------|-----------------------|-------------
+  UriTypeAllLower | default | :8300   | ALL    | /user/showlist | main.(*User).ShowList |
+------------------|---------|---------|--------|----------------|-----------------------|-------------
+
+     SERVER    | DOMAIN  | ADDRESS | METHOD |     ROUTE      |        HANDLER        | MIDDLEWARE
+---------------|---------|---------|--------|----------------|-----------------------|-------------
+  UriTypeCamel | default | :8400   | ALL    | /user/showList | main.(*User).ShowList |
+---------------|---------|---------|--------|----------------|-----------------------|-------------
+```
+
+可以分别访问以下 `URL` 地址得到期望的结果：
+
+```
+http://127.0.0.1:8100/user/show-list
+http://127.0.0.1:8200/User/ShowList
+http://127.0.0.1:8300/user/showlist
+http://127.0.0.1:8400/user/showList
+```
+
+### 对象方法注册
+
+假如控制器中有若干公开方法，但是我只想注册其中几个，其余的方法我不想对外公开，怎么办？我们可以通过 `BindObject` 传递 **第三个非必需参数** 替换实现，参数支持传入 **多个** 方法名称，多个名称以英文 `,` 号分隔（ **方法名称参数区分大小写**）。
+
+使用示例：
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+)
+
+type Controller struct{}
+
+func (c *Controller) Index(r *ghttp.Request) {
+    r.Response.Write("index")
+}
+
+func (c *Controller) Show(r *ghttp.Request) {
+    r.Response.Write("show")
+}
+
+func main() {
+    s := g.Server()
+    c := new(Controller)
+    s.BindObject("/object", c, "Show")
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+执行后，终端输出路由表为：
+
+```text
+SERVER | DOMAIN  | ADDRESS | METHOD |    ROUTE     |         HANDLER         | MIDDLEWARE
+|---------|---------|---------|--------|--------------|-------------------------|------------|
+  default | default | :8199   | ALL    | /object/show | main.(*Controller).Show |
+|---------|---------|---------|--------|--------------|-------------------------|------------|
+```
+
+## 绑定路由方法- `BindObjectMethod`
+
+我们可以通过 `BindObjectMethod` 方法绑定指定的路由到指定的方法执行（ **方法名称参数区分大小写**）。
+:::tip
+`BindObjectMethod` 和 `BindObject` 的区别： `BindObjectMethod` 将对象中的指定方法与指定路由规则进行绑定，第三个 `method` 参数只能指定一个方法名称； `BindObject` 注册时，所有的路由都是对象方法名称按照规则生成的，第三个 `methods` 参数可以指定多个注册的方法名称。
+:::
+来看一个例子：
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+)
+
+type Controller struct{}
+
+func (c *Controller) Index(r *ghttp.Request) {
+    r.Response.Write("index")
+}
+
+func (c *Controller) Show(r *ghttp.Request) {
+    r.Response.Write("show")
+}
+
+func main() {
+    s := g.Server()
+    c := new(Controller)
+    s.BindObjectMethod("/show", c, "Show")
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+执行后，终端输出的路由表如下：
+
+```text
+SERVER | DOMAIN  | ADDRESS | METHOD | ROUTE |         HANDLER         | MIDDLEWARE
+|---------|---------|---------|--------|-------|-------------------------|------------|
+  default | default | :8199   | ALL    | /show | main.(*Controller).Show |
+|---------|---------|---------|--------|-------|-------------------------|------------|
+```
+
+## `RESTful` 对象注册- `BindObjectRest`
+
+`RESTful` 设计方式的控制器，通常用于 `API` 服务。 **在这种模式下， `HTTP` 的 `Method` 将会映射到控制器对应的方法名称**，例如： `POST` 方式将会映射到控制器的 `Post` 方法中(公开方法，首字母大写)， `DELETE` 方式将会映射到控制器的 `Delete` 方法中，以此类推。其他非 `HTTP Method` 命名的方法，即使是定义的包公开方法，将不会自动注册，对于应用端不可见。当然，如果控制器并未定义对应 `HTTP Method` 的方法，该 `Method` 请求下将会返回 `HTTP Status 404`。
+:::warning
+`GoFrame` 的这种 `RESTful` 对象注册方式是一种严格的 `REST` 路由注册方式，我们可以将控制器的对象看做 `REST` 中的资源，而其中的 `HTTP Method` 方法即为 `REST` 规范的资源操作方法。如果大家不太熟悉 `REST` 规范，或者不想太过严格的 `RESTful` 路由设计，那么请忽略该章节。
+:::
+我们可以通过 `BindObjectRest` 方法完成 `REST` 对象的注册，示例：
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+)
+
+type Controller struct{}
+
+// RESTFul - GET
+func (c *Controller) Get(r *ghttp.Request) {
+    r.Response.Write("GET")
+}
+
+// RESTFul - POST
+func (c *Controller) Post(r *ghttp.Request) {
+    r.Response.Write("POST")
+}
+
+// RESTFul - DELETE
+func (c *Controller) Delete(r *ghttp.Request) {
+    r.Response.Write("DELETE")
+}
+
+// 该方法无法映射，将会无法访问到
+func (c *Controller) Hello(r *ghttp.Request) {
+    r.Response.Write("Hello")
+}
+
+func main() {
+    s := g.Server()
+    c := new(Controller)
+    s.BindObjectRest("/object", c)
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+执行后，终端输出路由表如下;
+
+```text
+SERVER | DOMAIN  | ADDRESS | METHOD |  ROUTE  |          HANDLER          | MIDDLEWARE
+|---------|---------|---------|--------|---------|---------------------------|------------|
+  default | default | :8199   | DELETE | /object | main.(*Controller).Delete |
+|---------|---------|---------|--------|---------|---------------------------|------------|
+  default | default | :8199   | GET    | /object | main.(*Controller).Get    |
+|---------|---------|---------|--------|---------|---------------------------|------------|
+  default | default | :8199   | POST   | /object | main.(*Controller).Post   |
+|---------|---------|---------|--------|---------|---------------------------|------------|
+```
+
+## 构造方法 `Init` 与析构方法 `Shut`
+
+对象中的 `Init` 和 `Shut` 是两个在 `HTTP` 请求流程中被 `Server` 自动调用的特殊方法（类似 `构造函数` 和 `析构函数` 的作用）。
+
+1. `Init` 回调方法
+
+对象收到请求时的初始化方法，在服务接口调用之前被回调执行。
+
+方法定义：
+
+```go
+// "构造函数"对象方法
+func (c *Controller) Init(r *ghttp.Request) {
+
+}
+```
+
+2. `Shut` 回调方法
+
+当请求结束时被 `Server` 自动调用，可以用于对象执行一些收尾处理的操作。
+
+方法定义：
+
+```go
+// "析构函数"对象方法
+func (c *Controller) Shut(r *ghttp.Request) {
+
+}
+```
+
+举个例子：
+
+```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()
+}
+```
+
+执行后，终端输出路由表如下：
+
+```text
+SERVER | DOMAIN  | ADDRESS | METHOD |     ROUTE     |         HANDLER          | MIDDLEWARE
+|---------|---------|---------|--------|---------------|--------------------------|------------|
+  default | default | :8199   | ALL    | /object/hello | main.(*Controller).Hello |
+|---------|---------|---------|--------|---------------|--------------------------|------------|
+```
+
+可以看到，并没有自动注册 `Init` 和 `Shut` 这两个方法的路由，我们访问 [http://127.0.0.1:8199/object/hello](http://127.0.0.1:8199/object/hello) 后，输出结果为：
+
+```Init
+Hello
+Shut
+```

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221//350/267/257/347/224/261/347/256/241/347/220/206//350/267/257/347/224/261/347/256/241/347/220/206-/350/267/257/347/224/261/346/263/250/345/206/214//350/267/257/347/224/261/346/263/250/345/206/214-/350/247/204/350/214/203/350/267/257/347/224/261//350/247/204/350/214/203/350/267/257/347/224/261-/345/237/272/346/234/254/347/244/272/344/276/213.md

@@ -0,0 +1,99 @@
+## 配置文件
+
+这里使用 `YAML` 配置文件： `config.yaml`
+
+```yaml
+server:
+  address:     ":8199"
+  openapiPath: "/api.json"
+  swaggerPath: "/swagger"
+```
+
+## 示例代码
+
+我们从一个简单的 `Hello` 例子开始：
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+)
+
+type HelloReq struct {
+    g.Meta `path:"/hello" method:"get"`
+    Name   string `v:"required" dc:"Your name"`
+}
+type HelloRes struct {
+    Reply string `dc:"Reply content"`
+}
+
+type Hello struct{}
+
+func (Hello) Say(ctx context.Context, req *HelloReq) (res *HelloRes, err error) {
+    g.Log().Debugf(ctx, `receive say: %+v`, req)
+    res = &HelloRes{
+        Reply: fmt.Sprintf(`Hi %s`, req.Name),
+    }
+    return
+}
+
+func main() {
+    s := g.Server()
+    s.Use(ghttp.MiddlewareHandlerResponse)
+    s.Group("/", func(group *ghttp.RouterGroup) {
+        group.Bind(
+            new(Hello),
+        )
+    })
+    s.Run()
+}
+```
+
+拷贝这段代码，我们运行起来试试，终端输出信息如下：
+
+```html
+2021-11-19 23:31:35.277 25580: http server started listening on [:8199]
+
+  SERVER  | DOMAIN  | ADDRESS | METHOD |   ROUTE    |                          HANDLER                          |    MIDDLEWARE
+----------|---------|---------|--------|------------|-----------------------------------------------------------|--------------------
+  default | default | :8199   | ALL    | /*         | github.com/gogf/gf/v2/net/ghttp.MiddlewareHandlerResponse | GLOBAL MIDDLEWARE
+----------|---------|---------|--------|------------|-----------------------------------------------------------|--------------------
+  default | default | :8199   | ALL    | /api.json  | github.com/gogf/gf/v2/net/ghttp.(*Server).openapiSpec-fm  |
+----------|---------|---------|--------|------------|-----------------------------------------------------------|--------------------
+  default | default | :8199   | GET    | /hello     | main.(*Hello).Say                                         |
+----------|---------|---------|--------|------------|-----------------------------------------------------------|--------------------
+  default | default | :8199   | ALL    | /swagger/* | github.com/gogf/gf/v2/net/ghttp.(*Server).swaggerUI-fm    | HOOK_BEFORE_SERVE
+----------|---------|---------|--------|------------|-----------------------------------------------------------|--------------------
+```
+
+可以看到，除了我们的业务路由之外， `Server` 自动帮我们注册了两个路由： `/api.json` 和 `/swagger/*`。前者是自动生成的基于标准的 `OpenAPIv3` 协议的接口文档，后者是自动生成 `SwaggerUI` 页面，方便开发者查看和调试。这两个功能默认是关闭的，开发者可以通过前面示例中的 `openapiPath` 和 `swaggerPath` 两个配置项开启。
+
+## 接口文档
+
+接口文档通过 `OpenAPIv3` 协议生成，一般来说需要结合相应的 `UI` 工具查看，地址： [http://127.0.0.1:8199/api.json](http://127.0.0.1:8199/api.json)
+:::tip
+由于 `OpenAPIv3` 协议是规范的接口定义协议，因此开发者根据协议内容可以做很多事，例如：自定义UI展示、Client代码生成、协议转换等等。
+:::
+## SwaggerUI
+
+我们来看看这个 `SwaggerUI` 页面： [http://127.0.0.1:8199/swagger/](http://127.0.0.1:8199/swagger/)
+
+这里只有一个我们的路由地址以及对应的输入输出结构体。当然，这只是个简单的示例，你可以在真实的项目中通过一些配置使得页面更加丰富多彩。
+
+我们接着在这个页面上做下接口测试吧：
+
+嗯，接口返回了一个固定数据格式的 `Json` 内容，但是能看到其中的 `data` 为我们需要的返回结果。
+:::tip
+提示：最新版本的 `SwaggerUI` 页面已经不支持接口测试功能，如果对此有要求的同学可以自定义 `SwaggerUI`（参考 [接口文档-自定义UI](../../../接口文档/接口文档-自定义UI.md)）， 也可以导入接口文件 `api.json` 到第三方工具（例如 `apifox`）进行测试：
+:::
+
+## 返回中间件
+
+等等，似乎漏掉了什么东西？是的，我们这里使用了一个 `Server` 组件提供的中间件，它是拿来做什么的呢？我们开看看它的方法定义：
+
+是的，它在我们没有提供自定义的返回数据格式处理中间件时，使用了一个默认的中间件处理我们的请求，并返回了一个默认的数据格式。

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221//350/267/257/347/224/261/347/256/241/347/220/206//350/267/257/347/224/261/347/256/241/347/220/206-/350/267/257/347/224/261/346/263/250/345/206/214//350/267/257/347/224/261/346/263/250/345/206/214-/350/247/204/350/214/203/350/267/257/347/224/261//350/247/204/350/214/203/350/267/257/347/224/261-/345/246/202/344/275/225/344/275/277/347/224/250.md

@@ -0,0 +1,87 @@
+## 路由方法定义
+
+从上面的例子中，我们可以看到，路由方法定义使用固定的格式：
+
+```go
+func Handler(ctx context.Context, req *Request) (res *Response, err error)
+```
+
+其中输入参数和输出参数都是两个，并且都是必须的一个都不能少。简单介绍下：
+
+| 参数 | 说明 | 注意事项 |
+| --- | --- | --- |
+| `ctx context.Context` | 上下文 | `Server` 组件会自动从请求中获取并传递给接口方法 |
+| `req *Request` | 请求对象 | 就算没有接收参数也要定义，因为请求结构体中不仅仅包含请求参数的定义，也包含了接口的请求定义。 |
+| `res *Response` | 返回对象 | 就算没有返回参数也要定义，因为返回结构体中不仅仅包含返回参数的定义，也可以包含接口返回定义。 |
+| `err error` | 错误对象 | `Server` 通过该参数判断接口执行成功或失败。 |
+
+## 路由统一注册
+
+### `Group.Bind` 方法
+
+我们推荐使用对象化的方式来管理所有路由方法，并通过 **分组路由** 的 `Bind` 方法执行统一注册。需要注意的是，在规范化路由方式下，路由地址以及请求方式将由请求结构体在 `g.Meta` 元数据对象中通过标签定义，通过分组路由可以定义分组下的所有路由前缀。
+
+### `BindHandler` 方法
+
+我们也可以通过基础的 `BindHandler` 方法来注册规范路由，但是该方法只能注册一个路由函数。使用示例：
+
+```go
+s := g.Server()
+s.BindHandler("/user/{uid}", func(ctx context.Context, req *SaveReq) (res *SaveRes, err error) {
+    // ...
+})
+```
+
+## 规范参数结构
+
+在规范化路由注册中，非常重要的是请求/返回参数结构体的定义，在该结构体不仅仅包含了输入参数的定义，也包含了接口的定义，特别是路由地址、请求方法、接口描述等信息。通过结构体方式的数据结构参数维护，更有利于更丰富的接口能力扩展、团队间的接口交互、长期的接口维护、自动化的接口文档生成。
+
+为保证命名规范化，输入数据结构以`XxxReq`方式命名，输出数据结构以`XxxRes`方式命名。即便输入或者输出参数为空，也需要定义相应的数据结构，这样的目的一个是便于后续扩展，另一个是便于接口信息的管理。关于结构体中涉及到 `OpenAPIv3` 协议的标签介绍请查看后续章节。
+:::tip
+请求参数自动转换到请求数据结构，字段映射转换不区分大小写，也会自动忽略特殊字符。
+:::
+#### 
+
+## 输入数据校验
+
+请求结构体在进入 `API` 接口执行前将会被自动执行校验，如果其中一条规则校验失败，那么将终止后续规则的校验（自动使用了 `bail` 校验修饰规则）。校验功能使用的是框架统一的校验组件，具体请参考： [数据校验](../../../../核心组件/数据校验/数据校验.md)
+:::warning
+需要特别注意：如果参数校验存在多条校验规则，并且规则中存在 `required*` 规则时，那么建议将 `required*` 校验规则放置于所有规则之前，否则规范路由中内置启用的 `bail` 校验规则的特性（校验失败即停止后续校验）有可能会引起后续规则的 `required*` 规则不生效。
+:::
+## 统一返回中间件
+
+接口的数据返回处理需要设置 **统一的后置中间件**，当然也可以使用 `Server` 默认提供的数据返回中间件。开发者自定义中间件时可以参考 `Server` 默认提供的中间件 `MiddlewareHandlerResponse`。
+
+这里顺便提一下，在自定义返回中间件时一个重要的方法：
+
+```go
+// GetHandlerResponse retrieves and returns the handler response object and its error.
+func (r *Request) GetHandlerResponse() interface{}
+```
+
+通过后置中间件执行时通过请求对象的 `GetHandlerResponse` 方法获取当前业务执行的结果，并根据需要做相应处理。
+
+## 扩展介绍
+
+### `OpenAPIv3` 协议
+
+`Server` 组件自动生成的接口文档使用的是最新的 `OpenAPIv3` 协议。更多介绍请参考章节： [接口文档](../../../接口文档/接口文档.md)
+
+### `Ctx` 中的 `Request` 对象
+
+我们可以通过 `RequestFromCtx/g.RequestFromCtx` 方法从 `ctx` 中获取 `Request` 对象。
+
+方法定义：
+
+```go
+func RequestFromCtx(ctx context.Context) *Request
+```
+
+使用示例：
+
+```go
+func (c *cHello) Hello(ctx context.Context, req *apiv1.HelloReq) (res *apiv1.HelloRes, err error) {
+    g.RequestFromCtx(ctx).Response.Writeln("Hello World!")
+    return
+}
+```

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221//350/267/257/347/224/261/347/256/241/347/220/206//350/267/257/347/224/261/347/256/241/347/220/206-/350/267/257/347/224/261/346/263/250/345/206/214//350/267/257/347/224/261/346/263/250/345/206/214-/350/247/204/350/214/203/350/267/257/347/224/261//350/247/204/350/214/203/350/267/257/347/224/261-/345/270/270/350/247/201/351/227/256/351/242/230.md

@@ -0,0 +1,33 @@
+## 在规范路由下，同一接口如何支持多种 `HTTP Method` 提交方式
+
+首先，一个接口应当只做一件事情， `HTTP Method` 是有意义的（例如 `RESTful` 接口风格设计），一个接口支持多种 `HTTP Method` 方式通常是接口设计不合理，建议重新审视接口设计。
+
+通常是不存在一个 `API` 需要绑定多个 `HTTP Method` 的场景的。例如，拿用户接口来讲，一个 `CRUD` 接口在 `RESTful` 实现应当有 `4-5` 个 `API` 定义，实现不同的业务逻辑。那么可能存在以下 `API` 定义的 `RESTful` 接口：
+
+```
+接口名称    Method    Path
+创建用户    PUT       /user
+用户列表    GET       /user
+用户详情    GET       /user/{uid}
+修改用户    POST      /user/{uid}
+删除用户    DELETE    /user/{uid}
+```
+
+如果确实存在一个接口支持多个 `HTTP Method` 的场景，那么可以通过在 `Meta` 标签中的 `method` 属性中使用英文 `,` 号分隔各个 `HTTP Method` 即可，例如：
+
+```go
+type SaveReq struct {
+    g.Meta `path:"/user/{uid}" method:"put,post" summary:"保存用户" tags:"用户管理"`
+    Uid    int64  `dc:"用户ID"`
+    Name   string `dc:"用户名"`
+    // ...
+}
+```
+
+## 使用默认提供的 `Response` 结构体，如何让 `Data` 字段只返回数组而无需指定名称的键值对
+
+使用类型别名即可。
+
+源码地址：[JSON数组响应](../../../../../examples/httpserver/response-json-array/response-json-array.md)
+
+结果示例：

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221//350/267/257/347/224/261/347/256/241/347/220/206//350/267/257/347/224/261/347/256/241/347/220/206-/350/267/257/347/224/261/346/263/250/345/206/214//350/267/257/347/224/261/346/263/250/345/206/214-/350/247/204/350/214/203/350/267/257/347/224/261//350/267/257/347/224/261/346/263/250/345/206/214-/350/247/204/350/214/203/350/267/257/347/224/261.md

@@ -0,0 +1,17 @@
+## 基本介绍
+
+从 `v2.0` 版本开始，框架的 `Server` 组件额外提供了规范化的路由注册方式，更加适合团队规范化的使用场景、业务复杂度更高的项目。规范路由实现了以下特性：
+
+- 规范化 `API` 按照结构化编程设计
+- 规范化 `API` 接口方法参数风格定义
+- 更加简化的路由注册与维护
+- 统一接口返回数据格式设计
+- 保障代码与接口文档同步维护
+- 自动的 `API` 参数对象化接收与校验
+- 自动生成基于标准 `OpenAPIv3` 协议的接口文档
+- 自动生成 `SwaggerUI` 页面
+:::tip
+注意一下哦： **规范路由** 与原有的 **函数、对象、分组** 路由方式都是框架的 `HTTP Server` 组件并存支持的路由注册方式，是为了解决一些规范化和自动化管理接口的场景，更适用于团队多人协作使用。其他的路由方式，特别是框架 `v1` 版本的函数、对象注册方式也是在新版本支持的哈！看个人使用习惯进行合理选择哟。
+:::
+
+## 相关文档

package/skills/goframe-v2/references/WEB/346/234/215/345/212/241/345/274/200/345/217/221//350/267/257/347/224/261/347/256/241/347/220/206//350/267/257/347/224/261/347/256/241/347/220/206-/350/267/257/347/224/261/346/263/250/345/206/214//350/267/257/347/224/261/347/256/241/347/220/206-/350/267/257/347/224/261/346/263/250/345/206/214.md

@@ -0,0 +1,13 @@
+## 基本介绍
+
+`WebServer` 提供服务需要方法/对象的支持， `ghttp` 包支持多种路由注册模式，为开发者提供非常强大和灵活的接口功能。
+
+路由注册是整个 `WebServer` 最核心的部分，也是 `goframe` 框架中最精心设计的一个模块。
+
+接口文档： [https://pkg.go.dev/github.com/gogf/gf/v2/net/ghttp](https://pkg.go.dev/github.com/gogf/gf/v2/net/ghttp)
+
+## 注意事项
+
+从框架 `v2` 版本开始，增加了 **规范路由** 的特性，更符合业务项目工程化的场景，推荐在复杂的业务项目中使用规范路由： [路由注册-规范路由](路由注册-规范路由/路由注册-规范路由.md)
+
+## 相关文档