@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/350/247/204/345/210/231.md

@@ -0,0 +1,335 @@
+`GoFrame` 框架自建了非常强大的路由功能，提供了比任何同类框架更加出色的路由特性，支持流行的命名匹配规则、模糊匹配规则及字段匹配规则，并提供了优秀的优先级管理机制。
+
+## 一个示例
+
+在真正开启本章的核心内容之前，我们先来看一个简单的动态路由使用示例：
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/net/ghttp"
+    "github.com/gogf/gf/v2/frame/g"
+)
+
+func main() {
+    s := g.Server()
+    s.BindHandler("/:name", func(r *ghttp.Request){
+       r.Response.Writeln(r.Router.Uri)
+    })
+    s.BindHandler("/:name/update", func(r *ghttp.Request){
+        r.Response.Writeln(r.Router.Uri)
+    })
+    s.BindHandler("/:name/:action", func(r *ghttp.Request){
+        r.Response.Writeln(r.Router.Uri)
+    })
+    s.BindHandler("/:name/*any", func(r *ghttp.Request){
+       r.Response.Writeln(r.Router.Uri)
+    })
+    s.BindHandler("/user/list/{field}.html", func(r *ghttp.Request){
+        r.Response.Writeln(r.Router.Uri)
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+以上示例中展示了 `goframe` 框架支持的三种模糊匹配路由规则， `:name`、 `*any`、 `{field}` 分别表示 **命名匹配规则**、 **模糊匹配规则** 及 **字段匹配规则**。不同的规则中使用 `/` 符号来划分层级，路由检索采用 **深度优先算法**，层级越深的规则优先级也会越高。我们运行以上示例，通过访问几个 `URL` 来看看效果：
+
+```html
+URL                                         结果
+http://127.0.0.1:8199/user/list/2.html      /user/list/{field}.html
+http://127.0.0.1:8199/user/update           /:name/update
+http://127.0.0.1:8199/user/info             /:name/:action
+http://127.0.0.1:8199/user                  /:name/*any
+```
+
+在这个示例中我们也可以看到，由于优先级的限制，路由规则 `/:name` 会被 `/:name/*any` 规则覆盖，将会无法被匹配到，所以在分配路由规则的时候，需要进行统一规划和管理，避免类似情况的产生。
+
+## 注册规则
+
+### 路由注册参数
+
+**最基础的** 路由绑定方法是 `BindHandler` 方法，我们来看一下之前一直使用的 `BindHandler` 的原型：
+
+```go
+func (s *Server) BindHandler(pattern string, handler interface{})
+```
+
+#### `pattern` 参数
+
+其中的 `pattern` 为路由注册规则字符串，在其他路由注册方法中也会使用到，参数格式如下：
+
+```html
+[HTTPMethod:]路由规则[@域名]
+```
+
+其中 `HTTPMethod`（ `GET/PUT/POST/DELETE/PATCH/HEAD/CONNECT/OPTIONS/TRACE`）和 `@域名` 为 **非必需参数**，大部分场景下直接给定路由规则参数即可， `BindHandler` 会自动绑定 **所有的** 请求方式，如果给定 `HTTPMethod`，那么路由规则仅会在该请求方式下有效。 `@域名` 可以指定生效的域名名称，那么该路由规则仅会在该域名下生效。
+:::tip
+`BindHandler` 是最原生的路由注册方法，在大部分场景中，我们通常使用 **分组路由** 方式来管理理由，后续章节将会介绍： [路由注册-分组路由](路由管理-路由注册/路由注册-分组路由.md)。
+:::
+#### `handler` 参数
+
+其中的 `handler` 参数通常用于指定路由函数，我们最基础的示例都是使用函数来注册路由，一个路由函数需要满足以下定义，即只要能接收请求对象 `ghttp.Request` 即可：
+
+```go
+func(r *ghttp.Request) {
+    // ...
+}
+```
+
+我们来看一个例子：
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/net/ghttp"
+    "github.com/gogf/gf/v2/frame/g"
+)
+
+func main() {
+    s := g.Server()
+    // 该路由规则仅会在GET请求下有效
+    s.BindHandler("GET:/{table}/list/{page}.html", func(r *ghttp.Request){
+        r.Response.WriteJson(r.Router)
+    })
+    // 该路由规则仅会在GET请求及localhost域名下有效
+    s.BindHandler("GET:/order/info/{order_id}@localhost", func(r *ghttp.Request){
+        r.Response.WriteJson(r.Router)
+    })
+    // 该路由规则仅会在DELETE请求下有效
+    s.BindHandler("DELETE:/comment/{id}", func(r *ghttp.Request){
+        r.Response.WriteJson(r.Router)
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+其中返回的参数 `r.Router` 是当前匹配的路由规则信息，访问当该方法的时候，服务端会输出当前匹配的路由规则信息。执行后，我们在终端使用 `curl` 命令进行测试：
+
+```bash
+$ curl -XGET http://127.0.0.1:8199/order/list/1.html
+{"Domain":"default","Method":"GET","Priority":3,"Uri":"/{table}/list/{page}.html"}
+
+$ curl -XGET http://127.0.0.1:8199/order/info/1
+Not Found
+
+$ curl -XGET http://localhost:8199/order/info/1
+{"Domain":"localhost","Method":"GET","Priority":3,"Uri":"/order/info/{order_id}"}
+
+$ curl -XDELETE http://127.0.0.1:8199/comment/1000
+{"Domain":"default","Method":"DELETE","Priority":2,"Uri":"/comment/{id}"}
+
+$ curl -XGET http://127.0.0.1:8199/comment/1000
+Not Found
+```
+
+### 精准匹配规则
+
+精准匹配规则即 **未使用任何动态规则** 的规则，如： `user`、 `order`、 `info` 等等这种 **确定名称** 的规则。在大多数场景下，精准匹配规则会和动态规则一起使用来进行路由注册(例如： `/:name/list`，其中层级1 `:name` 为命名匹配规则，层级2 `list` 是精准匹配规则)。
+
+### 动态路由规则
+
+动态路由规则分为三种： **命名匹配规则**、 **模糊匹配规则** 和 **字段匹配规则**。动态路由的底层数据结构是由层级 `哈希表` 和 `双向链表` 构建的 `路由树`，层级哈希表便于高效率地层级匹配 `URI`；数据链表用于优先级控制，同一层级的路由规则按照优先级进行排序，优先级高的规则排在链表头。底层的路由规则与请求 `URI` 的匹配计算采用的是正则表达式，并充分使用了缓存机制，执行效率十分高效。
+
+所有匹配到的参数都将会以 `Router` 参数的形式传递给业务层，可以通过 `ghttp.Request` 对象的以下方法获取匹配到的路由参数：
+
+```go
+func (r *Request) GetRouter(key string, def ...interface{}) *gvar.Var
+```
+
+也可以使用 `ghttp.Request.Get` 方法获取匹配到的路由参数。
+
+#### 命名匹配规则
+
+使用 `:name` 方式进行匹配( `name` 为自定义的匹配名称)，对 `URI` 指定层级的参数进行命名匹配（类似正则 `([^/]+)`，该 `URI` 层级必须有值），对应匹配参数会被解析为 `Router` 参数并传递给注册的服务接口使用。
+
+匹配示例1：
+
+```html
+rule: /user/:user
+
+/user/john                match
+/user/you                 match
+/user/john/profile        no match
+/user/                    no match
+```
+
+匹配示例2：
+
+```html
+rule: /:name/action
+
+/john/name                no match
+/john/action              match
+/smith/info               no match
+/smith/info/age           no match
+/smith/action             match
+```
+
+匹配示例3：
+
+```html
+rule: /:name/:action
+
+/john/name                match
+/john/info                match
+/smith/info               match
+/smith/info/age           no match
+/smith/action/del         no match
+```
+
+#### 模糊匹配规则
+
+使用 `*any` 方式进行匹配( `any` 为自定义的匹配名称)，对 `URI` 指定位置之后的参数进行模糊匹配（类似正则 `(.*)`，该 `URI` 层级可以为空），并将匹配参数解析为 `Router` 参数并传递给注册的服务接口使用。
+
+匹配示例1：
+
+```html
+rule: /src/*path
+
+/src/                     match
+/src/somefile.go          match
+/src/subdir/somefile.go   match
+/user/                    no match
+/user/john                no match
+```
+
+匹配示例2：
+
+```html
+rule: /src/*path/:action
+
+/src/                     no match
+/src/somefile.go          match
+/src/somefile.go/del      match
+/src/subdir/file.go/del   match
+```
+
+匹配示例3：
+
+```html
+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
+```
+
+#### 字段匹配规则
+
+使用 `{field}` 方式进行匹配( `field` 为自定义的匹配名称)，可对 `URI` **任意位置** 的参数进行截取匹配（类似正则 `([\w\.\-]+)`，该 `URI` 层级必须有值，并且可以在同一层级进行多个字段匹配），并将匹配参数解析为 `Router` 参数并传递给注册的服务接口使用。
+
+匹配示例1：
+
+```html
+rule: /order/list/{page}.php
+
+/order/list/1.php          match
+/order/list/666.php        match
+/order/list/2.php5         no match
+/order/list/1              no match
+/order/list                no match
+```
+
+匹配示例2：
+
+```html
+rule: /db-{table}/{id}
+
+/db-user/1                     match
+/db-user/2                     match
+/db/user/1                     no match
+/db-order/100                  match
+/database-order/100            no match
+```
+
+匹配示例3：
+
+```html
+rule: /{obj}-{act}/*param
+
+/user-delete/10                match
+/order-update/20               match
+/log-list                      match
+/log/list/1                    no match
+/comment/delete/10             no match
+```
+
+### 动态路由示例
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/net/ghttp"
+    "github.com/gogf/gf/v2/frame/g"
+)
+
+func main() {
+    s := g.Server()
+    // 一个简单的分页路由示例
+    s.BindHandler("/user/list/{page}.html", func(r *ghttp.Request){
+        r.Response.Writeln(r.Get("page"))
+    })
+    // {xxx} 规则与 :xxx 规则混合使用
+    s.BindHandler("/{object}/:attr/{act}.php", func(r *ghttp.Request){
+        r.Response.Writeln(r.Get("object"))
+        r.Response.Writeln(r.Get("attr"))
+        r.Response.Writeln(r.Get("act"))
+    })
+    // 多种模糊匹配规则混合使用
+    s.BindHandler("/{class}-{course}/:name/*act", func(r *ghttp.Request){
+        r.Response.Writeln(r.Get("class"))
+        r.Response.Writeln(r.Get("course"))
+        r.Response.Writeln(r.Get("name"))
+        r.Response.Writeln(r.Get("act"))
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+执行后，我们可以通过 `curl` 命令或者浏览器访问的方式进行测试，以下为测试结果：
+
+```bash
+$ curl -XGET http://127.0.0.1:8199/user/list/1.html
+1
+
+$ curl -XGET http://127.0.0.1:8199/user/info/save.php
+user
+info
+save
+
+$ curl -XGET http://127.0.0.1:8199/class3-math/john/score
+class3
+math
+john
+score
+```
+
+## 优先级控制
+
+优先级控制按照 **深度优先策略**，简要计算策略：
+
+1. **层级越深的规则优先级越高**；
+2. **同一层级下，精准匹配优先级高于模糊匹配**；
+3. **同一层级下，模糊匹配优先级：字段匹配 > 命名匹配 \> 模糊匹配**；
+
+我们来看示例（左边的规则优先级比右边高）：
+
+```html
+/:name                   >            /*any
+/user/name               >            /user/:action
+/:name/info              >            /:name/:action
+/:name/:action           >            /:name/*action
+/:name/{action}          >            /:name/:action
+/src/path/del            >            /src/path
+/src/path/del            >            /src/path/:action
+/src/path/*any           >            /src/path
+```

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/CORS/350/267/250/345/237/237/345/244/204/347/220/206.md

@@ -0,0 +1,200 @@
+允许接口跨域往往是需要结合 [路由管理-中间件/拦截器](../%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) 一起使用，来统一设置某些路由规则下的接口可以跨域访问。同时，针对允许 `WebSocket` 的跨域请求访问，也是通过该方式来实现。
+
+相关方法： [https://pkg.go.dev/github.com/gogf/gf/v2/net/ghttp#Response](https://pkg.go.dev/github.com/gogf/gf/v2/net/ghttp#Response)
+
+```go
+func (r *Response) CORS(options CORSOptions)
+func (r *Response) CORSAllowedOrigin(options CORSOptions) bool
+func (r *Response) CORSDefault()
+func (r *Response) DefaultCORSOptions() CORSOptions
+```
+
+### `CORS` 对象
+
+`CORS` 是 `W3` 互联网标准组织对HTTP跨域请求的标准，在 `ghttp` 模块中，我们可以通过 `CORSOptions` 对象来管理对应的跨域请求选项。定义如下：
+
+```go
+// See https://www.w3.org/TR/cors/ .
+// 服务端允许跨域请求选项
+type CORSOptions struct {
+    AllowDomain      []string // Used for allowing requests from custom domains
+    AllowOrigin      string   // Access-Control-Allow-Origin
+    AllowCredentials string   // Access-Control-Allow-Credentials
+    ExposeHeaders    string   // Access-Control-Expose-Headers
+    MaxAge           int      // Access-Control-Max-Age
+    AllowMethods     string   // Access-Control-Allow-Methods
+    AllowHeaders     string   // Access-Control-Allow-Headers
+}
+```
+
+具体参数的介绍请查看W3组织 [官网手册](https://www.w3.org/TR/cors/)。
+
+### `CORS` 配置
+
+#### 默认 `CORSOptions`
+
+当然，为方便跨域设置，在 `ghttp` 模块中也提供了默认的跨域请求选项，通过 `DefaultCORSOptions` 方法获取。大多数情况下，我们在需要允许跨域请求的接口中（一般情况下使用中间件）可以直接使用 `CORSDefault()` 允许该接口跨域访问。
+
+#### 限制 `Origin` 来源
+
+大多数时候，我们需要限制请求来源为我们受信任的域名列表，我们可以使用 `AllowDomain` 配置，使用方式：
+
+```go
+// 允许跨域请求中间件
+func Middleware(r *ghttp.Request) {
+    corsOptions := r.Response.DefaultCORSOptions()
+    corsOptions.AllowDomain = []string{"goframe.org", "johng.cn"}
+    r.Response.CORS(corsOptions)
+    r.Middleware.Next()
+}
+```
+
+### `OPTIONS` 请求
+
+有的客户端，部分浏览器在发送 `AJAX` 请求之前会首先发送 `OPTIONS` 预请求检测后续请求是否允许发送。 `GoFrame` 框架的 `Server` 完全遵守 `W3C` 关于 `OPTIONS` 请求方法的规范约定，因此只要服务端设置好 `CORS` 中间件， `OPTIONS` 请求也将会自动支持。
+
+### 示例1，基本使用
+
+我们来看一个简单的接口示例：
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+)
+
+func Order(r *ghttp.Request) {
+    r.Response.Write("GET")
+}
+
+func main() {
+    s := g.Server()
+    s.Group("/api.v1", func(group *ghttp.RouterGroup) {
+        group.GET("/order", Order)
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+接口地址是 [http://localhost/api.v1/order](http://localhost/api.v1/order) ，当然这个接口是不允许跨域的。我们打开一个不同的域名，例如：百度首页(正好用了 `jQuery`，方便调试)，然后按 `F12` 打开开发者面板，在 `console` 下执行以下 `AJAX` 请求：
+
+```
+$.get("http://localhost:8199/api.v1/order", function(result){
+    console.log(result)
+});
+```
+
+结果如下：
+
+返回了不允许跨域请求的提示错误，接着我们修改一下服务端接口的测试代码，如下：
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+)
+
+func MiddlewareCORS(r *ghttp.Request) {
+    r.Response.CORSDefault()
+    r.Middleware.Next()
+}
+
+func Order(r *ghttp.Request) {
+    r.Response.Write("GET")
+}
+
+func main() {
+    s := g.Server()
+    s.Group("/api.v1", func(group *ghttp.RouterGroup) {
+        group.Middleware(MiddlewareCORS)
+        group.GET("/order", Order)
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+我们增加了针对于路由 `/api.v1` 的前置中间件 `MiddlewareCORS`，该事件将会在所有服务执行之前调用。我们通过调用 `CORSDefault` 方法使用默认的跨域设置允许跨域请求。该绑定的事件路由规则使用了模糊匹配规则，表示所有 `/api.v1` 开头的接口地址都允许跨域请求。
+
+返回刚才的百度首页，再次执行请求 `AJAX` 请求，这次便成功了：
+
+当然我们也可以通过 `CORSOptions` 对象以及 `CORS` 方法对跨域请求做更多的设置。
+
+### 示例2，授权跨域 `Origin`
+
+在大多数场景中，我们是需要自定义授权跨域的 `Origin`，那么我们可以将以上的例子改进如下，在该示例中，我们仅允许 `goframe.org` 及 `baidu.com` 跨域请求访问。
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+)
+
+func MiddlewareCORS(r *ghttp.Request) {
+    corsOptions := r.Response.DefaultCORSOptions()
+    corsOptions.AllowDomain = []string{"goframe.org", "baidu.com"}
+    r.Response.CORS(corsOptions)
+    r.Middleware.Next()
+}
+
+func Order(r *ghttp.Request) {
+    r.Response.Write("GET")
+}
+
+func main() {
+    s := g.Server()
+    s.Group("/api.v1", func(group *ghttp.RouterGroup) {
+        group.Middleware(MiddlewareCORS)
+        group.GET("/order", Order)
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+### 示例3，自定义检测授权
+
+不知大家是否有注意，在以上的示例中有个细节，即使当前接口不允许跨域访问，但是只要接口被调用，接口完整逻辑仍会被执行，在服务端其实也已经走完了一次请求流程。针对于这个问题，我们可以通过自定义授权 `Origin` 并在中间件中通过 `CORSAllowedOrigin` 方法来做判断，如果当前请求的 `Origin` 在服务端是被允许执行的，那么才会执行后续流程，否则便会终止执行。
+
+在以下示例中，仅允许来自 `goframe.org` 域名的跨域请求，而来自其他域名的请求将会失败并返回 `403`：
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+)
+
+func MiddlewareCORS(r *ghttp.Request) {
+    corsOptions := r.Response.DefaultCORSOptions()
+    corsOptions.AllowDomain = []string{"goframe.org"}
+    if !r.Response.CORSAllowedOrigin(corsOptions) {
+        r.Response.WriteStatus(http.StatusForbidden)
+        return
+    }
+    r.Response.CORS(corsOptions)
+    r.Middleware.Next()
+}
+
+func Order(r *ghttp.Request) {
+    r.Response.Write("GET")
+}
+
+func main() {
+    s := g.Server()
+    s.Group("/api.v1", func(group *ghttp.RouterGroup) {
+        group.Middleware(MiddlewareCORS)
+        group.GET("/order", Order)
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```

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/CSRF/351/230/262/345/276/241/350/256/276/347/275/256.md

@@ -0,0 +1,113 @@
+**跨站请求伪造**（英语： `Cross-Site Request Forgery`），也被称为**one-click attack**或者**session riding**，通常缩写为**CSRF** 或者**XSRF**， 是一种挟制用户在当前已登录的Web应用程序上执行非本意的操作的攻击方法。跟跨网站脚本（ `XSS`）相比， **XSS** 利用的是用户对指定网站的信任， `CSRF` 利用的是网站对用户网页浏览器的信任。
+
+## 如何防御
+
+这里我们选择通过 `token` 的方式对请求进行校验，通过中间件的方式实现， `CSRF` 跨站点防御插件由社区包提供。
+
+开发者可以通过对接口添加中间件的方式，增加 `token` 校验功能。
+
+感兴趣的朋友可以阅读插件源码 [https://github.com/gogf/csrf](https://github.com/gogf/csrf)
+
+## 使用方式
+
+### 引入插件包
+
+```go
+import "github.com/gogf/csrf"
+```
+
+### 配置接口中间件
+
+`csrf` 插件支持自定义 `csrf.Config` 配置， `Config` 中的 `Cookie.Name` 是中间件设置到请求返回 `Cookie` **中** `token` 的名称， `ExpireTime` 是 `token` 超时时间， `TokenLength` 是 `token` 长度， `TokenRequestKey` 是后续请求需求带上的参数名。
+
+```go
+s := g.Server()
+s.Group("/api.v2", func(group *ghttp.RouterGroup) {
+    group.Middleware(csrf.NewWithCfg(csrf.Config{
+        Cookie: &http.Cookie{
+            Name: "_csrf",// token name in cookie
+        },
+        ExpireTime:      time.Hour * 24,
+        TokenLength:     32,
+        TokenRequestKey: "X-Token",// use this key to read token in request param
+    }))
+    group.ALL("/csrf", func(r *ghttp.Request) {
+        r.Response.Writeln(r.Method + ": " + r.RequestURI)
+    })
+})
+```
+
+### 前端对接
+
+通过配置后，前端在POST请求前从 `Cookie` 中读取 `_csrf` 的值（即 `token`），然后请求发出时将 `token` 以 `X-Token`（ `TokenRequestKey` 所设置）参数名置入请求中（可以是 `Header` 或者 `Form`）即可通过 `token` 校验。
+
+## 代码示例
+
+### 使用默认配置
+
+```go
+package main
+
+import (
+    "net/http"
+    "time"
+
+    "github.com/gogf/csrf"
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+)
+
+// default cfg
+func main() {
+    s := g.Server()
+    s.Group("/api.v2", func(group *ghttp.RouterGroup) {
+        group.Middleware(csrf.New())
+        group.ALL("/csrf", func(r *ghttp.Request) {
+            r.Response.Writeln(r.Method + ": " + r.RequestURI)
+        })
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+### 使用自定义配置
+
+```go
+package main
+
+import (
+    "net/http"
+    "time"
+
+    "github.com/gogf/csrf"
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+)
+
+// set cfg
+func main() {
+    s := g.Server()
+    s.Group("/api.v2", func(group *ghttp.RouterGroup) {
+        group.Middleware(csrf.NewWithCfg(csrf.Config{
+            Cookie: &http.Cookie{
+                Name: "_csrf",// token name in cookie
+                Secure:   true,
+                SameSite: http.SameSiteNoneMode,// 自定义samesite
+            },
+            ExpireTime:      time.Hour * 24,
+            TokenLength:     32,
+            TokenRequestKey: "X-Token",// use this key to read token in request param
+        }))
+        group.ALL("/csrf", func(r *ghttp.Request) {
+            r.Response.Writeln(r.Method + ": " + r.RequestURI)
+        })
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+## 通过请求体验效果
+
+[http://localhost:8199/api.v2/csrf](http://localhost:8199/api.v2/csrf)