2 阅读

0

📖 通过实例了解 Fiber：深入探索内置函数 DEV 的全球展示挑战赛，由 Mux 呈现：展示你的项目！

📖 通过示例了解 Fiber：深入了解内置功能

由 Mux 主办的 DEV 全球展示挑战赛：展示你的项目！

介绍

嘿，开发者朋友们！👋

正如我在上周的文章中承诺的那样，今天我发布了我为Packt出版社撰写但最终未能出版的书稿的第二章，内容略有修改。如果你错过了，我在上一篇文章的开头就提到过。

第二章计划

在第二篇文章（或章节）中，我们将更深入地了解Fiber Web 框架的内部运作、其路由技术、内置组件和方法。

本文将涵盖以下主要主题👇

📝 目录

纤维应用
配置
路由技术
内置方法
- 静止的
- 路由处理程序
- 山
- 团体
- 服务器
- 堆
- 配置
- 处理程序
- 听
- ListenTLS
- 听众
- 测试
- 新错误
使用 Fiber Context 方法
- BodyParser
- JSON
- 参数
- 询问
- 放
- 状态和发送状态
概括

纤维应用

与其他许多 Web 框架一样，Fiber应用程序也是从创建一个新的命名实例开始的。要创建实例，只需导入包并调用相应的fiber.New方法即可：

// ./go/app.go

import "github.com/gofiber/fiber/v2"

func main() {
  // Create a new Fiber instance, called 'app'
  app := fiber.New()

  // ...
}

执行后，将在应用程序变量中创建一个新的 Fiber 实例，并使用默认配置。本文稍后将介绍该实例的手动配置。

配置

有时，默认设置不足以满足我们对应用程序的配置需求。为了满足这类用户的需求，Fiber提供了一种特殊的fiber.Config结构，其中包含许多用于微调的字段。

例如，我们来更改服务器标头的标准输出：

// Create config variable
config := fiber.Config{
  ServerHeader: "My Server", // add custom server header
}

// Create a new Fiber instance with custom config
app := fiber.New(config)

之后，对该应用程序的每个请求都会返回该服务器名称以及一个响应头。在实际应用程序中，它可能看起来像这样：

Access-Control-Allow-Origin: *
Content-Length: 51
Content-Type: application/json
Date: Mon, 03 May 2021 07:00:39 GMT
Server: My Server
Vary: Origin

很简单，对吧？ 🤔 现在让我们列出所有现有的光纤应用配置字段，并详细介绍每个字段。

预叉

类型：bool，默认值：false。

启用SO_REUSEPORT套接字选项。这将启动多个监听同一端口的Go进程。这也被称为套接字分片。如果启用，应用程序需要通过 shell 运行，因为 prefork 模式会设置环境变量。

☝️注意：使用Docker时，请确保应用程序在项目目录CMD ./app下运行。CMD ["sh", "-c", "/app"]Dockerfile

服务器头

类型：string，默认值：（""空字符串）。

启用具有给定值的服务器 HTTP 标头。

严格路由

类型：bool，默认值：false。

启用此功能后，光纤路由器会将两条路径/foo视为/foo/不同的路由。如果我们想要提升网站的搜索引擎优化 ( SEO ) 效果，这将非常有用。

区分大小写

类型：bool，默认值：false。

启用后，光纤路由器会将/Foo和/foo视为不同的路由。

不可更改的

类型：bool，默认值：false。

启用后，上下文方法返回的所有值都将是不可变的。默认情况下，这些值在处理程序返回之前一直有效。

转义路径

类型：bool，默认值：false。

在设置上下文路径之前，将路由中的所有编码字符转换回原始字符，以便路由也可以处理 URL 编码的特殊字符。

电子标签

类型：bool，默认值：false。

启用ETag标头生成，因为弱 ETag 和强 ETag 都是使用相同的哈希方法（CRC-32）生成的。

身体极限

类型：int，默认值：4 * 1024 * 1024。

设置请求体允许的最大大小。如果大小超过配置的限制，则会发送HTTP 413 Payload Too Large响应。

并发性

类型：int，默认值：256 * 1024。

最大并发连接数。

浏览量

Views是提供您自己的模板引擎的接口，并且包含Load和Render方法。

该方法由FiberLoad在应用初始化时执行，用于加载/解析模板。该方法与一个接受模板名称和绑定数据的函数相关联。Renderctx.Render

Fiber团队支持模板包，该模板包为多个模板引擎提供封装：

以下是一个简单的使用示例：

// ./go/views.go

package main

import (
  "github.com/gofiber/fiber/v2"
  "github.com/gofiber/template/html" // add engine
)

func main() {
  // Initialize a standard Go's html/template engine
  engine := html.New("./views", ".html")

  // Create a new Fiber template with template engine
  app := fiber.New(fiber.Config{
    Views: engine,
  })

  app.Get("/", func(c *fiber.Ctx) error {
    // Render a template named 'index.html' with content
    return c.Render("index", fiber.Map{
      "Title":       "Hello, World!",
      "Description": "This is a template.",
    })
  })

  // Start server on port 3000
  app.Listen(":3000")
}

以及用于渲染文件夹中内容的 HTML 模板本身./views：

<!-- ./go/views/index.html -->

<!DOCTYPE html>
<head>
  <title>{{.Title}}</title>
</head>
<body>
  <h1>{{.Title}}</h1>
  <p>{{.Description}}</p>
</body>
</html>

运行这段代码（go run ./go/views.go）并访问http://localhost:3000/，我们会看到代码的运行完全符合预期：

读取超时

类型：time.Duration，默认值：nil。

读取完整请求（包括请求体）所允许的时间。设置nil为 0 表示无限制超时。

写入超时

类型：time.Duration，默认值：nil。

响应写入超时前的最大持续时间。设置为 0nil表示无限制超时。

空闲超时

类型：time.Duration，默认值：nil。

启用 keep-alive 时，等待下一个请求的最长时间。

☝️注意：如果 IdleTimeout 为零，则使用 ReadTimeout 的值。

读取缓冲区大小

类型：int，默认值：4096。

每个连接用于读取请求的缓冲区大小。此设置也限制了最大标头大小。如果您的客户端发送的 RequestURI 和/或标头大小超过 KB，请增加此缓冲区大小。

写入缓冲区大小

类型：int，默认值：4096。

用于响应写入的每次连接的缓冲区大小。

压缩文件后缀

类型：string，默认值：".fiber.gz"。

在原始文件名后添加后缀，并尝试将生成的压缩文件保存为新文件名。

代理标头

类型：string，默认值：（""空字符串）。

这将ctx.IP返回给定标头键的值。默认情况下，ctx.IP它将返回 TCP 连接中的远程 IP 地址。

☝️注意：如果您位于负载均衡器后面，例如，此属性可能很有用X-Forwarded-*。

仅获取

类型：bool，默认值：false。

启用此选项后，服务器将拒绝所有非 GET 请求。此选项可作为仅接受 GET 请求的服务器的防拒绝服务 (DoS) 保护措施。

☝️注意：如果GETOnly设置为 true，则请求大小受限制ReadBufferSize。

错误处理程序

类型：ErrorHandler，默认值：DefaultErrorHandler。

ErrorHandler当从返回错误时执行fiber.Handler。

禁用保持活动状态

类型：bool，默认值：false。

禁用保持连接。服务器在向客户端发送第一个响应后将关闭所有传入连接。

禁用默认日期

类型：bool，默认值：false。

启用此true选项后，默认日期标头将从响应中排除。

禁用默认内容类型

类型：bool，默认值：false。

设置为 true 时，将默认Content-Type标头从响应中排除。

禁用标头规范化

类型：bool，默认值：false。

默认情况下，所有标头名称都会被规范化。例如，标头cOnteNT-tYPE将转换为更易读的格式Content-Type。

禁用启动消息

类型：bool，默认值：false。

设置为 true 时，将不会打印调试信息和启动消息，如下所示：

┌───────────────────────────────────────────────────┐ 
│                    Fiber v2.17.0                  │ 
│               http://127.0.0.1:5000               │ 
│       (bound on host 0.0.0.0 and port 5000)       │ 
│                                                   │ 
│ Handlers ............ 21  Processes ........... 1 │ 
│ Prefork ....... Disabled  PID ............. 92607 │ 
└───────────────────────────────────────────────────┘

路由技术

任何应用程序的核心部分，尤其是 REST API，都是将请求路由到相应的端点。Fiber 提供了一系列出色的选项，可以为任何任务创建路由器。

☝️注意：路由路径与请求方法结合使用，定义了可以发出请求的端点。路由路径可以是字符串或字符串模式。

路由模式是路由中的动态元素，可以是命名段，也可以是未命名段。这些段用于捕获 URL 中指定位置的值。

可以使用该函数检索获得的值ctx.Params，其中路径中指定的路由模式的名称作为其各自的键，或者对于未命名的模式，使用字符（*或+）和该字符的计数器。

字符:、+和*是引入模式的字符。
*贪婪模式用通配符（）或加号（）表示+。

路由功能还允许使用可选模式。对于已命名的模式，它们会以一个结尾?符号标记，而加号则不是可选的。您可以使用通配符来指定模式范围，该范围是可选的，并且会进行贪婪匹配。

让我们通过一些实际例子来探讨它们。

简单路线

此路由路径将匹配到根路由的请求/：

app.Get("/", func(c *fiber.Ctx) error {
  return c.SendString("root")
})

此路由路径将匹配以下请求/about：

app.Get("/about", func(c *fiber.Ctx) error {
  return c.SendString("about")
})

此路由路径将匹配指向特定目录的请求/random.txt，而不是匹配同名文件，这可能与您想象的不同。我们将在本文后面讨论如何提供文件服务。

app.Get("/random.txt", func(c *fiber.Ctx) error {
  return c.SendString("random.txt")
})

命名路线

这个动态路径示例希望在查询时输出作者姓名（在 author 参数中）和书籍标题（在 title 参数中）：

app.Get("/library/:author/books/:title", func(c *fiber.Ctx) error {
  str := fmt.Sprintf("%s, %s", c.Params("author"), c.Params("title"))
  return c.SendString(str)
})

如果在运行的Fiber应用程序中调用此路径，例如http://localhost:3000/user/Tolkien/books/Hobbit：，则会显示以下行：Tolkien, Hobbit。

有时，我们无法立即知道某个参数是否会传递给 URL。为此，Fiber开发人员引入了可选参数：

app.Get("/user/:name?", func(c *fiber.Ctx) error {
  return c.SendString(c.Params("name"))
})

如果未指定名称，则返回空字符串。

具有贪婪参数的路由

Fiber Web框架还支持所谓的贪婪参数。当我们需要为具有未知参数的端点构建地址时，这些参数非常有用。它们可以是可选的，也可以是必需的。

让我们来看下面这个需要贪婪参数的例子：

app.Get("/user/+", func(c *fiber.Ctx) error {
  return c.SendString(c.Params("+"))
})

在带有加号的地方，我们必须传递参数。但我们并不受任何限制，我们可以传递单个参数，也可以传递一整串参数：

http://localhost:3000/user/?name=Bilbo
http://localhost:3000/user/?name=Bilbo&family=Baggins&city=Shire

可选的贪婪参数的工作方式类似：

app.Get("/user/*", func(c *fiber.Ctx) error {
  return c.SendString(c.Params("*"))
})

如果一个端点中包含多个通配符，只需在星号后添加一个数字（从右到左）即可。例如，像这样：

app.Get("/user/*/work/*/job/*", func(c *fiber.Ctx) error {
  c.SendString(c.Params("*1")) // first wildcard
  c.SendString(c.Params("*2")) // second wildcard
  c.SendString(c.Params("*3")) // third wildcard
  // ...
})

更复杂的路线

由于连字符 ( -) 和点号 ( .) 会被按字面意思解释，因此它们可以与路由参数一起使用，以实现各种实用目的。光纤的智能路由器能够识别出这些开头参数字符在这种情况下应该作为请求路由的一部分，并能按此方式处理它们。

这使我们能够为几乎任何任务构建非常复杂的端点路径：

app.Get("/flights/:from-:to/time::at", func(c *fiber.Ctx) error {
  str := fmt.Sprintf("%s-%s at %s", c.Params("from"), c.Params("to"), c.Params("at"))
  return c.SendString(str)
})

通过向此 URL 发送请求，我们得到了http://localhost:3000/flights/LAX-SFO/time:10PM字符串。正如我们一开始所预期的那样。LAX-SFO10PM

因此，Fiber能够支持相当复杂的路由，但对于用户而言，这样的记录仍然尽可能清晰！

路径中字符的限制

路径中的所有特殊字符都必须使用反斜杠 ( \) 进行转义，否则它们将失去原有的值。例如，如果路由路径必须匹配到/resource/key:value，我们需要转义冒号 ( :)，如下所示：

app.Get("/resource/key\\:value", func(c *fiber.Ctx) error {
  return c.SendString("escaped key:value")
})

正则表达式路由

Fiber Web 框架的目标是成为Go 语言中最快、最清晰的 Web 框架之一，因此，为了支持某种特定情况而故意减慢路由速度并不在开发者的计划之内。

是的，Fiber目前不像其他框架那样支持路由中的正则表达式。但这并不重要，因为大多数路由场景都可以用上述方法解决。

内置方法

现在我们来谈谈Fiber Web 框架中内置的方法，这些方法旨在简化大多数日常操作，从而减少重复代码的编写。

静止的

使用此Static方法提供静态文件，例如图像、CSS 和 JavaScript 文件。默认情况下，它会index.html响应对目录的请求提供文件。

以下代码会处理./public项目根目录下名为 `<directory_name>` 的所有文件和文件夹：

app.Static("/", "./public")

运行该应用程序后，我们可以访问以下地址的文件夹内容（当然，前提是这些地址存在）：

http://localhost:3000/page.html
http://localhost:3000/js/script.js
http://localhost:3000/css/style.css

是的，我们可以轻松地在单个Fiber应用程序中提供位于完全不同目录中的文件，例如：

// Serve files from './public' directory
app.Static("/", "./public")

// Serve files from './storage/user-uploads' directory
app.Static("/files", "./storage/user-uploads")

这种方法非常适合创建完整的SPA（单页应用程序）。

此外，该Static方法还提供了一些设置，允许您微调Fiberfiber.Static应用程序在提供文件服务时的行为。要访问这些设置，请将接口作为第三个参数调用该方法：

// Create a new config for Static method
config := fiber.Static{
  Compress:      true,
  ByteRange:     true,
  Browse:        true,
  Index:         "page.html"
  CacheDuration: 60 * time.Second,
  MaxAge:        3600,
  Next:          nil
}

// Serve files from './public' directory with config
app.Static("/", "./public", config)

让我们更详细地分析一下每个设置项。

压缩

类型：bool，默认值：false。

设置为 true 时，服务器会尝试通过缓存压缩文件来最大限度地减少 CPU 使用率。

☝️注意：这与Fiber团队支持的压缩中间件的工作方式不同。

字节范围

类型：bool，默认值：false。

设置为时true，启用字节范围请求。

浏览

类型：bool，默认值：false。

设置为 0 时true，启用目录浏览功能。

指数

类型：string，默认值："index.html"。

用于提供目录服务的索引文件的名称。

缓存持续时间

类型：time.Duration，默认值：10 * time.Second。

非活动文件处理程序的过期时间。使用负值time.Duration可禁用此功能。

最大年龄

类型：int，默认值：0。

Cache-Control文件响应中设置的 HTTP 标头的值MaxAge以秒为单位定义。

下一个

类型：func(c *Ctx) bool，默认值：nil。

trueNext 定义了一个函数，当返回时跳过此中间件。

☝️注意：当由于某些外部状态变化或应用程序中的用户请求而需要提供包含文件的文件夹时，此设置非常有用。

路由处理程序

使用以下方法注册绑定到特定 HTTP 方法的路由。

// Create a new route with GET method
app.Get("/", handler)

// Create a new route with POST method
app.Post("/article/add", handler)

// Create a new route with PUT method
app.Put("/article/:id/edit", handler)

// Create a new route with PATCH method
app.Patch("/article/:id/edit", handler)

// Create a new route with DELETE method
app.Delete("/article/:id", handler)

// ...

Fiber Web Framework 具有以下用于处理 HTTP 方法的辅助方法：Add和All。

该Add方法允许您使用 HTTP 方法作为值：

// Set HTTP method to variable
method := "POST"

// Create a new route with this method
app.Add(method, "/form/create", handler)

这种All方法为我们注册一个可以接受任何有效 HTTP 方法的路由提供了可能，这在某些情况下非常有用：

// Create a new route for all HTTP methods
app.All("/all", handler)

山

使用Mount创建*Mount结构体的方法将一个 Fiber 实例挂载到另一个 Fiber 实例上。

// ./go/mount.go

package main

import "github.com/gofiber/fiber/v2"

func main() {
  // Create the first Fiber instance
  micro := fiber.New()

  // Create a new route for the first instance
  micro.Get("/doe", func(c *fiber.Ctx) error {
    return c.SendStatus(fiber.StatusOK) // send HTTP 200 OK
  })

  // Create the second Fiber instance
  app := fiber.New()

  // Create a new route for the second instance,
  // with included first instance's route
  app.Mount("/john", micro)

  // Start server on port 3000
  app.Listen(":3000")
}

/john/doe此Fiber应用程序的路由现在将返回HTTP 200 OK状态。

团体

使用Group创建*Group结构体的方法对路由进行分组。

// ./go/group.go

package main

import "github.com/gofiber/fiber/v2"

func main() {
  // Create a new Fiber instance
  app := fiber.New()

  // Create a new route group '/api'
  api := app.Group("/api", handler)

  // Create a new route for API v1
  v1 := api.Group("/v1", handler)
  v1.Get("/list", handler)

  // Create a new route for API v1
  v2 := api.Group("/v2", handler)
  v2.Get("/list", handler)

  // Start server on port 3000
  app.Listen(":3000")
}

这种内置方法非常适合对我们应用程序的 API 进行版本控制。

服务器

使用Server此方法返回底层fasthttp服务器。

// Set the fasthttp option 'MaxConnsPerIP' to '1'
app.Server().MaxConnsPerIP = 1

堆

使用Stack此方法返回原始路由堆栈。

// ./go/stack.go

package main

import (
  "encoding/json"
  "fmt"

  "github.com/gofiber/fiber/v2"
)

func main() {
  // Create a new Fiber instance
  app := fiber.New()

  // Create new routes
  app.Get("/john/:age", handler)
  app.Post("/register", handler)

  // Print the router stack in JSON format
  data, _ := json.MarshalIndent(app.Stack(), "", "  ")
  fmt.Println(string(data))

  // Start server on port 3000
  app.Listen(":3000")
}

结果将以格式良好的 JSON 格式列出所有路由：

[
  [
    {
      "method": "GET",
      "path": "/john/:age",
      "params": [
        "age"
      ]
    }
  ],
  [
    {
      "method": "POST",
      "path": "/register",
      "params": null
    }
  ]
]

配置

使用Config该方法返回应用程序配置值（只读）。

// Print ServerHeader value
fmt.Println(app.Config().ServerHeader)

处理程序

使用Handler该方法返回可用于处理自定义*fasthttp.RequestCtx请求的服务器处理程序（更多信息请参见此处）。

听

使用Listen此方法处理来自给定地址的 HTTP 请求。

// Listen on port 8080 
app.Listen(":8080")

// Listen on the custom host and port
app.Listen("127.0.0.2:9090")

ListenTLS

用户方法，用于从给定地址ListenTLS提供 HTTPS（安全 HTTPcertFile ）请求，并keyFile使用 TLS 证书和密钥的路径。

// Listen on port 443 with TLS cert and key
app.ListenTLS(":443", "./cert.pem", "./cert.key")

听众

使用Listener此方法传递自定义net.Listener。此方法可用于使用自定义tls.Config启用 TLS/HTTPS 。

// Create a new net.Listener TCP instance on port 3000
ln, _ := net.Listen("tcp", ":3000")

// Set TLS key pair (certificate and key)
certs, _ := tls.LoadX509KeyPair("./server.crt", "./server.key")

// Configure a new TLS listener with params
lr := tls.NewListener(
  ln,
  &tls.Config{
    Certificates: []tls.Certificate{
      certs,
    },
  },
)

// Start server with TLS listener
app.Listener(lr)

测试

使用 Test 方法测试您的应用程序。当您需要调试路由逻辑时，请使用此方法。

我们将在下一篇文章中更详细地探讨这种方法。敬请期待！ 😉

新错误

使用NewError此方法创建一个带有可选消息的新 HTTP 错误实例。

// Create a custom error with HTTP code 782
app.Get("/error", func(c *fiber.Ctx) error {
  return fiber.NewError(782, "Custom error message")
})
IsChild
Use IsChild method for determine, if the current process is a result of Prefork.
// Create a new Fiber instance with config
app := fiber.New(fiber.Config{
  Prefork: true, // enable Prefork
})

// Cheking current process
if fiber.IsChild() {
  fmt.Println("I'm a child process")
} else {
  fmt.Println("I'm the parent process")
}

// ...

使用 Fiber Context 方法

在Fiber Web 框架中，你会发现种类繁多的请求上下文处理方法。截至目前v2.17.0，共有55种，而且随着每个主要版本的发布，这个数字还在不断增长。因此，为了节省时间，我们不会逐一介绍所有方法，而只会重点介绍本系列教程（实践部分）中将要用到的方法。

☝️注意：如需查看所有方法、方法签名和代码示例的完整列表，请访问Fiber Web 框架Context的官方文档页面： https://docs.gofiber.io/api/ctx

BodyParser

将请求体绑定到一个结构体。BodyParser支持根据Content-Type请求头解码查询参数和以下内容类型：

application/json
application/xml
application/x-www-form-urlencoded
multipart/form-data

// ./go/body_parser.go

package main

import (
  "fmt"

  "github.com/gofiber/fiber/v2"
)

// Define the Person struct
type Person struct {
  Name  string `json:"name" xml:"name" form:"name"`
  Email string `json:"email" xml:"email" form:"email"`
}

func main() {
  // Create a new Fiber instance
  app := fiber.New()

  // Create a new route with POST method
  app.Post("/create", func(c *fiber.Ctx) error {
    // Define a new Person struct
    person := new(Person)

    // Binds the request body to the Person struct
    if err := c.BodyParser(person); err != nil {
      return err
    }

    // Print data from the Person struct
    fmt.Println(person.Name, person.Email)

    return nil
  })

  // Start server on port 3000
  app.Listen(":3000")
}

如果我们运行此应用程序并通过 POST 方法将表单数据发送到路由http://localhost:3000/create，我们将在控制台中看到我们发送的数据。

☝️注意：结构体中的字段名应以大写字母开头。

JSON

使用segmentio/encoding包将任何接口或字符串转换为 JSON 。此外，JSON 方法会将内容标头设置为application/json.

// ./go/json.go

package main

import "github.com/gofiber/fiber/v2"

func main() {
  // Create a new Fiber instance
  app := fiber.New()

  // Create a new route with GET method
  app.Get("/json", func(c *fiber.Ctx) error {
    // Return response in JSON format
    return c.JSON(fiber.Map{
      "name": "John",
      "age":  33,
    })
  })

  // Start server on port 3000
  app.Listen(":3000")
}

正如我们所见，本例中fiber.Map使用了一个特殊的辅助方法，它只是一个空的Go接口。该应用程序的结果将以 JSON 格式显示数据：{"name": "John", "age": 33}。

参数

该Params方法可用于获取路由参数。我们可以传递一个可选的默认值，如果参数键不存在，则返回该默认值。

// ./go/params.go

package main

import (
  "fmt"

  "github.com/gofiber/fiber/v2"
)

func main() {
  // Create a new Fiber instance
  app := fiber.New()

  // Create a new route with named params
  app.Get("/user/:name", func(c *fiber.Ctx) error {
    // Print name from params
    fmt.Println(c.Params("name"))

    return nil
  })

  // Create a new route with optional greedy params
  app.Get("/user/*", func(c *fiber.Ctx) error {
    // Print all data, given from '*' param
    fmt.Println(c.Params("*"))

    return nil
  })

  // Start server on port 3000
  app.Listen(":3000")
}

本文前面部分已经详细讨论过路由参数的问题。

询问

Query该方法是一个对象，其中包含路由中每个查询字符串参数的属性。我们可以传递一个可选的默认值，如果查询键不存在，则返回该默认值。

// ./go/query.go

package main

import (
  "fmt"

  "github.com/gofiber/fiber/v2"
)

func main() {
  // Create a new Fiber instance
  app := fiber.New()

  // Create a new route with query params
  app.Get("/user", func(c *fiber.Ctx) error {
    // Print name from query param
    fmt.Println(c.Query("name"))

    return nil
  })

  // Start server on port 3000
  app.Listen(":3000")
}

通过调用此端点并传递带有 name 键的查询参数，我们可以获取其值。

放

该Set方法将响应的 HTTP 标头字段设置为指定的键和值。

// Create a new route with text/plain content type
app.Get("/text", func(c *fiber.Ctx) error {
  // Set a new Content-Type for this route
  c.Set("Content-Type", "text/plain")

  // ...
})

状态和发送状态

Status`and`方法SendStatus用于设置响应的 HTTP 状态码，如果响应体为空，则在响应体中设置正确的状态消息。但使用这些方法时，选项略有不同。

该Status方法可链式调用。这意味着它可以与其他方法结合使用，例如：

// Create a new route with HTTP status
app.Get("/bad-request", func(c *fiber.Ctx) error {
  // Return status with a custom message
  return c.Status(fiber.StatusBadRequest).SendString("Bad Request")
})

SendStatus只有在只需要返回 HTTP 响应码时才应使用此方法。例如：

// Create a new route with HTTP status
app.Get("/forbidden", func(c *fiber.Ctx) error {
  // Return only status
  return c.SendStatus(fiber.StatusForbidden)
})

☝️注意：我们可以在这里查看所有受支持的用于 HTTP 状态的 Fiber 助手。

概括

这篇文章信息量非常大！

我们学习了Fiber框架的基本实例，并能够根据自己的喜好进行配置。
我们研究了光纤如何与路由配合使用，以及它能做什么和不能做什么。
学习了所有必要的内置 Web 框架方法，并学习了如何处理上下文。

下一篇文章中，我们将更深入地了解这种Test方法。

照片和视频

Aaron Burden feat. Vic Shóstak https://unsplash.com/photos/QJDzYT_K8Xg

PS

如果你想在这个博客上看到更多类似的文章，请在下方留言并订阅我。谢谢！😻

❗️您可以通过Boosty平台支持我，既可以长期支持，也可以一次性支持。所有收益都将用于支持我的开源软件项目，并激励我为社区创作新的产品和文章。

当然，您也可以帮助我让开发者的工作变得更好！只需以贡献者的身份加入我的项目即可。很简单！

我最需要你帮助（和点赞）的项目👇

🔥 gowebly：一款新一代 CLI 工具，可轻松使用 Go 在后端创建出色的 Web 应用程序，使用 htmx、hyperscript 或 Alpine.js 以及最流行的 CSS 框架在前端进行开发。
✨ create-go-app：通过运行一条 CLI 命令，创建一个包含 Go 后端、前端和部署自动化功能的新生产就绪项目。

我的其他一些小项目：yatr、gosl、json2csv、csv2api。

文章来源：https://dev.to/koddr/go- Fiber-by-examples-delving-into-built-in-functions-1p3k