本章将使您对 Gin 框架是什么、它是如何工作的以及它的特性有一个基本的了解。我们还将提供设置 Go 运行时和开发环境的指南。此外，我们将讨论使用 Gin 作为构建分布式应用程序的 Web 框架的优势。我们将通过学习编写我们的第一个基于 Gin 的 Web 应用程序来完成本章。

在本章中，我们将介绍以下主题：

• What is Gin?
• Go runtime and integrated development environment (IDE)
• Go modules and dependency management
• Writing a Gin web application

在本章结束时，您将能够使用 Gin Web 框架构建一个基本的 HTTP 服务器。

要学习本章，您将需要以下内容：

• Some programming experience. The code in this chapter is pretty simple, but it helps to know something about Go.
• A tool to edit your code with. Any text editor you have will work fine. Most text editors have good support for Go. The most popular are Visual Studio Code (VSCode) (free), GoLand (paid), and Vim (free).
• A command terminal. Go works well using any Terminal on Linux and Mac, and on PowerShell or CMD in Windows.

本章的代码包托管在 GitHub 上，地址为 https： //github.com/PacktPublishing/Building-Distributed-Applications-in-Gin/tree/main/chapter01。

在深入 了解 Gin Web 框架之前，我们需要了解为什么 Go 是构建可扩展和分布式应用程序的首选。

Go（也称为为 Golang）是一种开源编程语言，由 Google 内部的 Robert Griesemer、Rob Pike 和 Ken Thompson 于 2007 年开发。它是一种经过编译的静态类型旨在使用户能够轻松编写可靠、可扩展且高效的应用程序的语言。 Go 的主要特点如下：

• Simple and consistent: Go has a rich set of library packages with powerful standard libraries for testing, error management, and concurrency.
• Fast and scalable: Go is a general-purpose programming language developed for the multi-core reality of today's computers. It has built-in concurrency with Goroutines and channels. Goroutines provide lightweight, threaded execution. Declaring a Goroutine is as simple as adding the go keyword before a function.
• Efficient: Go provides efficient execution and compilation. Go is also statically linked, which means that the compiler invokes a linker in the last step that resolves all library references. This means we would get one binary executable after compiling a Go program with no external dependencies. Moreover, it offers efficient memory utilization with a built-in garbage collector (Go exhibits many similarities with low-level programming languages such as C or C++).
• Community and support: Go is backed by Google and has an ever growing ecosystem and numerous contributors to the language on GitHub. Moreover, many online resources (tutorials, videos, and books) are available for getting started with Go.

Go 在企业和开源社区中非常流行。基于 2020 年 StackOverflow 开发者调查（https://insights.stackoverflow.com/survey/2020 )，Go 在最受欢迎的编程语言中排名前 5 位：

图 1.1 – 根据 2020 年 StackOverflow 调查，最受欢迎的编程语言

众所周知，Golang 是构建大规模、复杂工具和基于云的应用程序的第一选择。下图突出显示了使用 Go 开发的主要开源项目：

• Docker: A solution that's used to create, deploy, and run applications using containers.
• Kubernetes: A container orchestration platform for managing containers across a fleet of nodes/machines.
• Etcd: A reliable distributed key-value store used to store data for a distributed system or application.
• InfluxDB: A scalable time-series database designed to handle high write and query loads.
• CoreOS: A lightweight operating system designed to deploy container-based applications.
• Terraform: An infrastructure-as-code tool for building, changing, and versioning cloud infrastructure.
• CockroachDB: A cloud-native SQL database for data-intensive applications.
• Consul: A distributed store with service discovery, service mesh, and health check monitoring capabilities:

图 1.2 – 由 Go 驱动的开源工具

正如我们所见，Go 是用于分布式系统和基础设施工具的可靠语言。 Docker、Kubernetes、Prometheus 等都是使用 Go 构建的。

Go 还以构建各种形状和大小的 Web 应用程序而闻名。这部分是由于在使标准库干净、一致和易于使用方面所做的出色工作。 net/http 包对于任何初露头角的 Go web 开发者来说可能最重要的包之一。这个包允许你在 Go 中使用其强大的组合结构构建 HTTP 服务器。

要构建 Web 应用程序，您需要构建 HTTP 服务器。客户端（例如，浏览器）发出带有一些信息的 HTTP 请求；然后服务器处理该请求并返回响应。响应可以是 JSON、XML 或 HTML 格式：

图 1.3 – HTTP 客户端-服务器通信

这种请求-响应模式是在 Go 中构建 Web 应用程序的关键焦点之一。

虽然 net/http 包可让您轻松构建 Web 应用程序，但路由机制并没有那么 强大，尤其是对于复杂的应用程序。这就是 Web 框架发挥作用的地方。下表列出了顶级 Golang Web 框架：

Gin 可能是使用最多、运行规模最大的 Go Web 框架。该框架已经在GitHub收获了48210个star和5100个fork，可见该框架非常受欢迎。这种模块化框架可以轻松扩展，无需大惊小怪。它非常好用，因为许多组件可以通过直接的 net/http 包重用。

重要的提示

另一个强大但保守的框架是 Gorilla/Mux。它拥有最大的在线社区之一，在互联网上拥有许多资源，可教您如何构建端到端 Web 应用程序。

根据官方文档https://gin-gonic.com /docs/，Gin 描述如下：

“Gin 是一个用 Go (Golang) 编写的 HTTP Web 框架。它具有类似 Martini 的 API，性能要好得多——速度提高了 40 倍。如果你需要出色的性能，那就给自己买点 Gin”。

Gin 是一个简约的 Web 框架，适用于构建 Web 应用程序、微服务和 RESTful API。它通过创建可重用和可扩展的代码片段来减少样板代码：您可以编写一个可以插入一个或多个请求处理程序的中间件。此外，它还具有以下主要功能：

• Well documented: The documentation for Gin is broad and comprehensive. Most tasks that you will need to do relating to the router can be found easily in the docs.
• Simplicity: Gin is a pretty minimalistic framework. Only the most essential features and libraries are included, with little to no boilerplate to bootstrap applications, making Gin a great framework for developing highly available REST APIs.
• Extensible: The Gin community has created numerous pieces of well-tested middleware that make developing for Gin a charm. Features include compression with GZip, authentication with an authorization middleware, and logging with external solutions such as Sentry.
• Performance: Gin runs 40x faster than Martini and runs comparatively well compared to other Golang frameworks. The following is the results of a benchmark I ran against multiple Go libraries:

图 1.4 – Golang web 框架基准

重要的提示

此基准测试在 macOS High Sierra、2.7 GHz Intel Core i7、16 GB DDR3 计算机上执行，运行时环境为 Go 1.15.6。

话虽如此，在您编写第一行 Go 代码之前，您需要设置环境。让我们从安装 Go 开始。

在编写本书时，Go 的最新版本是 Go 1.15.6。要安装 Go，您可以下载或使用官方二进制发行版，也可以从源代码安装 Go (https: //github.com/golang/go）。

重要的提示

官方二进制发行版可用于 FreeBSD（版本 8 及更高版本）、Linux（2.6.23 及更高版本）、macOS（Snow Leopard 及更高版本）和 Windows（XP 及更高版本）。支持 32 位 (386) 和 64 位 (amd64) x86 处理器架构。对于 FreeBSD 和 Linux，还支持 ARM 处理器架构。

要安装 Go，请从 https://golang.org/dl/ 网页下载分发包，如此处显示，然后选择适合您平台的文件：

图 1.5 – Golang 可用的包

获得分发包后，根据您选择的平台安装 Go。我们将在下面的章节ns 中介绍。

Linux/FreeBSD

要在 Linux 或 FreeBSD 上安装 Go ，您 必须下载go.-.tar.gz。在 64 位架构上的最新 Go for Linux 是 go1.15.6.linux-amd64.tar.gz：

wget -c https://golang.org/dl/go1.15.6.linux-amd64.tar.gz   //64bit
wget -c https://golang.org/dl/go1.15.6.linux-386.tar.gz     //32bit

下载存档并将其解压缩到 /usr/local 文件夹中。然后，以 root 身份或通过 sudo 运行以下命令：

tar -C /usr/local -xzf go1.15.6.linux-amd64.tar.gz

将 /usr/local/go/bin 添加到 PATH 环境变量中。您可以通过将以下行添加到 $HOME/.profile 或 /etc/profile 来做到这一点（用于系统范围的安装）：

export PATH=$PATH:/usr/local/go/bin

通过打开命令提示符并键入以下命令来验证您是否已安装 Go：

go version

此命令应显示已安装的 Go 版本：

图 1.6 – Go 的安装版本

让我们继续看看如何在 Windows 上设置 Go 环境。

Windows

要在 Windows 上安装 Go ，您可以使用 MSI 安装程序或 ZIP 存档。从 MSI 安装更容易。在 64 位架构上的最新 Go for Windows 是 go1.15.6.windows-amd64.msi。然后，您将需要根据您的系统执行以下命令之一：

wget -c https://golang.org/dl/go1.15.6.windows-amd64.msi   //64bit
wget -c https://golang.org/dl/go1.15.6.windows-386.msi     //32bit

打开您下载的 MSI 文件并按照提示安装 Go。默认情况下，安装程序会将 Go 放置在 C:\Go 并在您的 中设置 C:\Go\bin class="literal">PATH 环境变量。您可以根据需要更改位置：

图 1.7 – Golang 安装向导

安装 Go 后，您需要关闭并重新打开所有打开的命令提示符，以便安装程序对环境所做的更改反映在命令提示符中。

重要的提示

使用 ZIP 存档也很容易。将文件提取到一个目录（例如，C:\Go）并将 bin 子目录添加到您的 PATH 变量。

安装后，单击 开始 菜单。然后，在菜单的搜索框中，输入 cmd。之后，按 Enter 键。在出现的命令提示符窗口中，键入 go version 命令，如 所示 在这里：

图 1.8 – Go 的安装版本

您将看到 go version go1.15.6 windows/amd64，如前面的屏幕截图所示。有了这个，你们都准备好了！

MacOS

对于MacOS，您可以下载相应的PKG文件；即 go1.15.6.darwin-amd64.pkg（在撰写本书时）。下载后，运行安装向导。该软件包会将分发安装到 /usr/local/go 并将 /usr/local/go/bin 目录放在您的 PATH 环境变量：

图 1.9 – 在 MacOS 上安装 Go

你需要重启你的终端，或者在你的终端中运行这个命令：

source ~/.profile

或者，您可以使用 Homebrew 安装 Go。这可以像执行以下操作一样简单：

brew install [email protected]

终端窗口将为您提供有关 Go 安装过程的反馈。安装完成可能需要几分钟时间。通过打开命令提示符并键入 go version 命令来验证您是否已安装 Go。

重要的提示

将来，要更新 Go，您可以运行以下命令更新 Homebrew，然后更新 Go。您现在不必这样做，因为您刚刚安装了最新版本：

brew update
brew upgrade golang

现在您已经安装了 Go，您需要正确设置它。 Go 开发工具旨在与维护在公共存储库中的代码一起使用，并且模型是相同的，无论您是在开发开源程序还是其他东西。 Go 代码是在工作区中开发的。一个工作区由三个目录组成，即如下：

• bin: This will contain all you Go executable binaries.
• src: This will store your source files, which are organized in packages, with one subdirectory in the src directory representing one package.
• pkg: This will store your package objects.

Go 工作区的默认目录是带有 go 子目录或 $HOME/go 的主目录。发出以下命令为 Go 工作区创建目录结构：

mkdir -p $HOME/go/{bin,src,pkg}

-p 选项告诉 mkdir 创建目录中的所有父级，即使它们当前不存在。使用 {bin, src, pkg} 为 mkdir 创建一组参数并告诉它创建 bin、src 和 pkg 目录。这将确保以下目录结构现在到位：

The go, bin and  src folders should be at the same level (remove extra spaces from go and src folders, so the folders are aligned with bin folder)
$HOME 
 └── go 
 ├── bin 
 └── src 

接下来需要设置GOPATH环境变量，如下：

export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin

您可以通过使用 echo 命令并检查输出来验证您的 $PATH 是否已更新：

echo $PATH

您应该在您的主目录中看到您的 $GOPATH/bin。如果您以 USER 身份登录，您将在路径中看到 /Users/USER/go/bin：

/Users/USER/go/bin:/usr/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin

随着 Go 工作区 和 GOPATH 创建，我们可以继续设置开发环境。

Integrated development environment

通过这本书，我将使用一个IDE来编写RESTful API 和服务。使用 IDE 可以提高您的工作效率，因为它提供了丰富的功能，例如自动完成、突出显示代码、强大的内置调试器和自定义扩展。有许多可用的 IDE。在本书中，我将使用VSCode。

要安装 VSCode，请根据您的系统从 https://code.visualstudio.com/download:

图 1.10 – VS Code – 可用的包

笔记

Mac 用户 也可以使用 Brew 安装 VSCode ，命令如下：

brew install --cask visual-studio-code

下载后，运行设置向导并按照说明进行操作。安装完成后，启动 VSCode。您将看到以下开始屏幕：

图 1.11 – VSCode 用户界面

VSCode默认支持所有流行的编程语言和Git集成。您还可以安装扩展程序来扩展 VSCode 的功能。 VS Code 市场包含大量免费的社区插件和扩展。要启用对 Golang 的支持，您需要通过导航到左侧边栏中的 Extensions 选项卡来安装名为 Go 的扩展：

图 1.12 – VSCode 的 Golang 扩展

单击 Install 按钮，然后重新启动 VSCode 以使更改生效。

Installing Go tools

接下来，我们将安装 以下 Go 工具，它们是一组包，可帮助您在编写代码时改善开发工作流程和整体体验：

重要的提示

可以在 https://pkg.go.dev 找到可用 Go 工具的完整列表/golang.org/x/tools。

要安装这些工具，请点击查看 | 命令面板，或使用 Ctrl + Shift + P 快捷方式并输入 goinstall update/tools：

图 1.13 – VSCode 上可用的 Go 工具

检查所有依赖项并点击OK。下载所有依赖项需要一些时间：

图 1.14 – Go 工具安装

在您的计算机上安装和配置 Go 后，您现在可以安装 Gin 框架了。

Gin 是一个第三方包。要在 Go 项目中安装 Gin，我们需要使用 go get 命令。该命令将要安装的包的 URL 作为参数。发出以下命令以从 GitHub 安装 gin 包：

go get github.com/gin-gonic/gin

笔记

如果您运行的是 Go 1.16 及更高版本，则需要通过 GO111MODULE=off 选项禁用 Go 模块。

签出 gin 包时，go get 命令会在 $ 中创建一个 Gin 目录GOPATH/src 路径。该目录将包含 Gin 框架的源代码：

图 1.15 – Gin 包源代码

首先在 $GOHOME/src/hello-world 或任何看起来合适的目录下创建 hello-world 项目目录：

mkdir -p $GOHOME/src/hello-world 
cd $GOHOME/src/hello-world

使用 VSCode 打开文件夹并在项目文件夹中创建一个 main.go 文件，其中包含 以下内容：

package main
import "github.com/gin-gonic/gin"
func main() {
   router := gin.Default()
   router.GET("/", func(c *gin.Context) {
       c.JSON(200, gin.H{
           "message": "hello world",
       })
   })
   router.Run()
}

第一行 package main 表示这是本项目的主模块。 import 部分用于导入 gin 包。这个包为我们提供了 router 变量，该变量在 import 下方声明，以及我们发送在我们的 main 函数中响应。

接下来，我们在根 (/) 资源上创建一个 HTTP GET 方法，并定义一个在 HTTP 请求命中时调用的函数根端点。该函数发送一个 JSON 响应，其状态码为 200（OK），正文为 "message": "test successful"。

最后，我们必须使用 router.Run() 方法在端口 8080 上部署路由器。下图总结了 Gin 中如何处理 HTTP 请求：

图 1.16 – 使用 Gin 解析传入的 HTTP 请求

要运行 应用程序，请在终端会话中执行 以下命令：

go run main.go

此后执行的所有文件和命令都将在此目录中。如果您按照设置过程进行操作，您应该会在终端中看到以下输出：

图 1.17 – Gin 服务器日志

将您喜欢的浏览器指向 http://localhost:8080。您应该会看到 "hello world" 消息：

图 1.18 – Hello world 示例

太棒了——你已经使用 Gin 框架成功地在 Go 中启动了一个 HTTP 服务器。

回到 终端，Gin 将跟踪 HTTP 请求：

图 1.19 – 跟踪传入的 HTTP 请求

您可以使用 cURL 命令发出 HTTP 请求：

curl -X GET http://localhost:8080

或者，您可以使用高级 REST 客户端，例如 Postman。您可以根据您的平台从以下 URL 下载正确的版本：https://www.getpostman.com/apps< /a>。

下载后，运行向导并打开 Postman。如下设置字段：

• HTTP method: GET
• URL: http://localhost:8080
• Headers: Set Content-Type to application/json

请求应该像这样配置：

图 1.20 – Postman 客户端的 GET 请求

值得一提的是，默认情况下，HTTP 服务器正在侦听端口 8080。但是，如果 端口正被另一个应用程序使用，您可以通过向 运行方法：

r.Run(":5000")

此命令将在端口 5000 上运行服务器，如以下屏幕截图所示：

图 1.21 – 在端口 5000 上运行 Gin 服务器

请注意，port 参数需要作为字符串传递，并以冒号标点符号开头。

您现在应该熟悉构建和运行简单 Web 应用程序的基础知识。在接下来的几节中，我们将介绍如何使用第三方软件包增强这些功能。但在此之前，让我们先了解一下如何管理 Go 依赖项。

目前， 代码 存储在本地。但是，建议将源代码存储在远程存储库中以进行版本控制。这就是 GitHub 等解决方案发挥作用的地方。在 https://github.com 注册一个免费帐户。然后，创建一个名为 hello-world 的新 GitHub 存储库：

图 1.22 – 新的 GitHub 存储库

接下来，使用以下命令初始化存储库：

git init 
git remote add origin https://github.com/mlabouardy/hello-world.git

通过执行以下命令将 main.go 文件提交到远程存储库：

git add . 
git commit -m "initial commit" 
git push origin master

您的存储库现在应该如下所示：

图 1.23 – Git 中的 main.go 版本控制

我们可以在这里停下来。但是，如果您在一个团队中工作，则需要某种方式来确保所有 团队成员使用相同的 Go 版本和 a> 包。这就是 Go 模块出现的地方。 Go 模块于 2018 年推出，使依赖管理变得更加容易。

笔记

从 Go 1.16 开始，Go 模块是管理外部依赖项的默认方式。

在项目文件夹中，运行以下命令来创建一个新模块：

go mod init hello-world

此命令将创建一个包含以下内容的 go.mod 文件。该文件定义项目需求并将依赖项锁定到其正确版本（类似于 Node 中的 package.json 和 package-lock.json .js）：

module github.com/mlabouardy/hello-world
go 1.15

要添加 Gin 包，我们可以发出 go get 命令。现在，我们的 go.mod 文件将如下所示：

module github.com/mlabouardy/hello-world
go 1.15
require github.com/gin-gonic/gin v1.6.3

添加 Gin 框架后将生成一个名为 go.sum 的新文件（为简洁起见，对输出进行了裁剪）。您可能会认为它是一个锁定文件。但事实上，go.mod 已经为 100% 可重现的构建提供了足够的信息。另一个文件仅用于验证目的：它包含特定模块版本内容的预期加密校验和。您可以将其视为一个额外的安全层，以确保您的项目所依赖的 模块不会意外更改 ，无论是恶意或意外原因：

github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
github.com/gin-gonic/gin v1.6.3 h1:ahKqKTFpO5KTPHxWZjEdPScmYaGtLo8Y4DMHoEsnp14=
github.com/gin-gonic/gin v1.6.3/go.mod h1:75u5sXoLsGZoRN5Sgbi1eraJ4GU3++wFwWzhwvtwp4M=
github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
github.com/go-playground/locales v0.13.0/go.mod

您可以使用以下命令列出您的依赖项：

go list -m all

输出如下：

github.com/mlabouardy/hello-world
github.com/davecgh/go-spew v1.1.1
github.com/gin-contrib/sse v0.1.0
github.com/gin-gonic/gin v1.6.3
github.com/go-playground/assert/v2 v2.0.1
github.com/go-playground/locales v0.13.0
github.com/go-playground/universal-translator v0.17.0
github.com/go-playground/validator/v10 v10.2.0
github.com/golang/protobuf v1.3.3
github.com/google/gofuzz v1.0.0
github.com/json-iterator/go v1.1.9
github.com/leodido/go-urn v1.2.0
github.com/mattn/go-isatty v0.0.12
github.com/modern-go/concurrent v0.0.0-20180228061459
e0a39a4cb421
github.com/modern-go/reflect2 v0.0.0-20180701023420
4b7aa43c6742
github.com/pmezard/go-difflib v1.0.0
github.com/stretchr/objx v0.1.0
github.com/stretchr/testify v1.4.0
github.com/ugorji/go v1.1.7
github.com/ugorji/go/codec v1.1.7
golang.org/x/sys v0.0.0-20200116001909-b77594299b42
golang.org/x/text v0.3.2
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405
gopkg.in/yaml.v2 v2.2.8

重要的提示

要删除未使用的依赖项，您可以使用 go mod tidy 命令。

最后，将 go.mod 和 go.sum 文件添加到使用以下命令远程 存储库：

git add .
git commit -m "dependency management"
git push origin master

更新后的存储库将如下所示：

图 1.24 – 使用 Go 模块管理依赖项

值得一提的是，下载的模块本地存储在您的 $GOPATH/pkg/mod 目录中。但是，有时，将项目所依赖的模块或第三方包存储起来并将它们放在一个文件夹中是很有用的，这样它们就可以被检入到版本控制中。幸运的是，Go 模块支持 vendoring：

go mod vendor

此命令将在您的项目文件夹中创建一个 vendor 目录，其中包含您所有的第三方依赖项。您现在可以将此文件夹提交到您的远程 Git 存储库，以确保您未来构建的稳定性，而无需依赖外部服务：

图 1.25 – 供应商依赖关系

有时，您 可能想知道为什么特定的包是 依赖项。您可以通过分析或可视化项目依赖关系来回答这个问题。为此，我们可以使用 go mod graph 命令显示 go.mod 文件中的模块列表：

go mod graph | sed -Ee 's/@[^[:blank:]]+//g' | sort | uniq >unver.txt

此命令将生成一个名为 unver.txt 的新文件，其中包含以下内容（为简洁起见，已对输出进行了裁剪）：

github.com/gin-contrib/sse github.com/stretchr/testify
github.com/gin-gonic/gin github.com/gin-contrib/sse
github.com/gin-gonic/gin github.com/go-playground/validator/v10
github.com/gin-gonic/gin github.com/golang/protobuf
github.com/gin-gonic/gin github.com/json-iterator/go
github.com/gin-gonic/gin github.com/mattn/go-isatty
github.com/gin-gonic/gin github.com/stretchr/testify
github.com/gin-gonic/gin github.com/ugorji/go/codec
github.com/gin-gonic/gin gopkg.in/yaml.v2

然后，创建一个包含以下内容的 graph.dot 文件：

digraph {
    graph [overlap=false, size=14];
    root="$(go list -m)";
    node [ shape = plaintext, fontname = "Helvetica", 
          fontsize=24];
    "$(go list -m)" [style = filled, 
                     fillcolor = "#E94762"];

此内容将使用 DOT 语言生成图形结构。我们可以使用 DOT 来描述图（有向或无向图）。话虽如此，我们将使用以下命令将 unvert.txt 的输出注入 graph.dot 文件：

cat unver.txt | awk '{print "\""$1"\" -> \""$2"\""};' >>graph.dot
echo "}" >>graph.dot
sed -i '' 's+\("github.com/[^/]*/\)\([^"]*"\)+\1\\n\2+g' graph.dot

这会产生一个模块依赖关系图：

图 1.26 – 模块依赖图

我们现在可以 使用 Graphviz 渲染结果。根据您的操作系统，可以使用以下命令安装此工具：

• Linux: You can download the official package based on your package manager. For Ubuntu/Debian, use the following command:

  apt-get install graphviz

  Copy
• MacOS: You can use the Homebrew utility for MacOS:

  brew install graphviz

  Copy
• Windows: You can use the Chocolatey (https://chocolatey.org/install) package manager for Windows:

  choco install graphviz.portable

  Copy

安装 Graphviz 后，执行以下命令将 graph.dot 文件转换为 .svg 格式：

sfdp -Tsvg -o graph.svg graph.dot

将生成一个 graph.svg 文件。使用以下命令打开文件：

open graph.svg

这导致 在 以下有向图：

图 1.27 – 可视化分析模块依赖关系

该图完美地显示了 hello-world 项目的模块/包之间的依赖关系。

笔记

生成依赖关系图的另一种方法是使用 modgv 实用程序 (https ://github.com/lucasepe/modgv）。该工具通过单个命令将 go mod graph 输出转换为 GraphViz 的 DOT 语言。

现在 源代码已经在 GitHub 上进行了版本控制，我们可以进一步探索如何编写自定义函数处理程序 fo< a id="_idTextAnchor029">r 杜松子酒路线。

您可以创建 一个处理函数，它以 *gin.Context 作为参数并提供状态码为 200 的 JSON 响应. 然后，您可以使用 router.Get() 函数注册处理程序：

package main
import "github.com/gin-gonic/gin"
func IndexHandler(c *gin.Context){
   c.JSON(200, gin.H{
       "message": "hello world",
   })
}
func main() {
   router := gin.Default()
   router.GET("/", IndexHandler)
   router.Run()
}

重要的提示

在本书的高级章节中，当处理单元测试时，将处理程序函数与路由器分离将很有用。

Gin 框架的最大优势在于它能够从请求 URL 中提取片段。考虑以下示例：

/users/john
/hello/mark

此 URL 有一个动态段：

• Username: Mark, John, Jessica, and so on

您可以使用以下 :variable 模式实现 动态段：

func main() {
   router := gin.Default()
   router.GET("/:name", IndexHandler)
   router.Run()
}

我们必须做的最后一件事是从变量中获取数据。 gin 包自带c.Params.ByName() 函数，该函数接受参数名称并返回值：

func IndexHandler(c *gin.Context) {
   name := c.Params.ByName("name")
   c.JSON(200, gin.H{
       "message": "hello " + name,
   })
}

使用 go run 命令重新运行应用程序。点击浏览器上的 http://localhost:8080/mohamed 链接；用户将被退回：

图 1.28 – 路径参数示例

现在，我们知道 每次我们点击 GET /user 路由时，我们都会收到“hello user”的响应。如果我们点击任何其他路由，它应该以 404 错误消息响应：

图 1.29 – Gin 中的错误处理

Gin 还可以处理 XML 格式的 HTTP 请求和响应。为此，请使用 firstName 和 lastName 作为属性定义一个用户结构。然后，使用 c.XML() 方法渲染 XML：

func main() {
   router := gin.Default()
   router.GET("/", IndexHandler)
   router.Run()
}
type Person struct {
     XMLName xml.Name `xml:"person"`
     FirstName     string   `xml:"firstName,attr"`
     LastName     string   `xml:"lastName,attr"`
}
func IndexHandler(c *gin.Context) {
     c.XML(200, Person{FirstName: "Mohamed", 
                       LastName: "Labouardy"})
}

现在，重新运行 应用程序。如果导航到 http://localhost:8080，服务器将返回一个 XML 响应，如下所示：

图 1.30 – XML 响应

恭喜！此时，您已经在本地机器上设置了 Go 编程工作区，并配置了 Gin。现在，您可以开始一个 coding 项目了！

在本章中，我们向您介绍了 Go 编程语言。我们学习了如何设置运行时和开发环境。我们还了解了 GOPATH 环境变量，它是 Go 中的工作区定义，我们现在知道所有包和项目都驻留在该路径上。

后来，我们探索了不同的 Go web 框架，并了解了为什么 Gin 最流行用于构建分布式 web 应用程序。最后，我们学会了如何从头开始用 Gin 编写我们的第一个 hello world 项目。

在下一章中，我们将亲自动手并开始使用 Gin 框架构建分布式 RESTful API。

1. Why is Golang popular?
2. Which are the best Golang frameworks for web development?
3. What's a Go module?
4. What's the default port of an HTTP server written in the Gin framework?
5. What methods are used to render JSON and XML responses?

• Hands-On Serverless Applications with Go, Mohamed Labouardy, by Packt Publishing
• Hands-On RESTful Web Services with Go - Second Edition, Naren Yellavula, by Packt Publishing