Go框架三件套详解：Web/RPC/ORM ｜ 青训营

须臾呀xjj
436 阅读5分钟

"Go框架三件套" 通常指的是在 Go 语言中用于构建应用程序的三个关键领域的框架：Web 框架、RPC 框架和 ORM 框架。

  1. Web 框架： Web 框架用于构建 Web 应用程序，它们提供了处理 HTTP 请求、路由、中间件、模板引擎等功能，使开发者能够更轻松地构建可扩展的 Web 应用。在 Go 中，一些知名的 Web 框架包括：

    • Gin：Gin 是一个轻量级的 Web 框架，提供了快速的路由和中间件支持，适用于构建高性能的 Web 应用。
    • Echo：Echo 也是一个轻量级的 Web 框架，专注于快速的路由和中间件处理，具有类似 Gin 的特性。
    • net/http 包：Go 本身的标准库中就包含了用于构建 Web 应用的 net/http 包，它提供了基本的 HTTP 服务器和路由功能。

  2. RPC 框架： RPC（Remote Procedure Call）框架用于构建分布式应用程序，允许不同计算机上的进程通过网络调用彼此的函数，就像调用本地函数一样。在 Go 中，一些常用的 RPC 框架包括：

    • gRPC：gRPC 是一个高性能、通用的 RPC 框架，使用 Protocol Buffers（ProtoBuf）作为接口描述语言，支持多种编程语言。
    • Go 的 net/rpc 包：Go 标准库中的 net/rpc 包提供了基本的 RPC 功能，可以用于实现简单的分布式应用。

  3. ORM 框架： ORM（Object-Relational Mapping）框架用于简化在关系型数据库和编程语言对象之间的转换。它们允许开发者使用面向对象的方式操作数据库，而不必直接编写 SQL 查询。在 Go 中，一些常见的 ORM 框架包括：

    • Gorm：Gorm 是一个流行的 ORM 框架，提供了简单的 API 来处理数据库操作，支持多种数据库系统。
    • XORM：XORM 是另一个支持多种数据库的 ORM 框架，具有类似 Gorm 的特性。
    • sqlx：虽然不是严格意义上的 ORM 框架，但 sqlx 是一个扩展了标准库 database/sql 的库，提供了更方便的数据库操作方式。

这三个领域的框架在不同的应用场景下具有不同的优势，开发者可以根据项目需求选择合适的框架来构建高效、可维护的应用程序。无论是构建 Web 应用、分布式系统还是与数据库交互，Go 社区提供了丰富的工具和框架来帮助开发者更轻松地实现这些功能。

环境搭建

在开始学习Go框架的三个组成部分之前，首先需要搭建开发环境以及安装所需的软件。

  1. 安装Docker/Postman/Git/Golang：

    • 安装Docker：用于容器化部署应用。可以前往Docker官网下载并按照说明安装。
    • 安装Postman：用于API接口测试。前往Postman官网下载并安装。
    • 安装Git：版本控制工具，用于代码管理。可以从Git官网下载并安装。
    • 安装Golang：Go语言开发环境，可以从Go官网下载并按照说明安装。

  2. 安装Minikube/Docker Desktop：

    • 安装Minikube：用于在本地运行Kubernetes集群。可以前往Minikube官网下载并按照说明安装。
    • 安装Docker Desktop：也可用于容器化部署，适用于Windows和Mac。可以从Docker官网下载并安装。

框架体验部分

部分 1：Web 框架体验 - 使用 Gin 构建一个任务清单应用

使用 Gin 框架构建一个简单的任务清单应用，实现添加和列出任务的功能。

  1. 安装 Gin：使用以下命令安装 Gin 框架。

    go get -u github.com/gin-gonic/gin

  2. 创建主应用文件：创建一个名为 main.go 的文件，用于编写应用代码。

    package main

import (
    "github.com/gin-gonic/gin"
    "net/http"
)

func main() {
    router := gin.Default()

    tasks := []string{}

    router.GET("/", func(c *gin.Context) {
        c.HTML(http.StatusOK, "index.tmpl", gin.H{
            "tasks": tasks,
        })
    })

    router.POST("/add", func(c *gin.Context) {
        task := c.PostForm("task")
        tasks = append(tasks, task)
        c.Redirect(http.StatusSeeOther, "/")
    })

    router.LoadHTMLGlob("templates/*")
    router.Run(":8080")
}

  3. 创建模板文件：在项目根目录下创建一个名为 templates 的文件夹，并在其中创建一个名为 index.tmpl 的文件。

    <!DOCTYPE html>
<html>
<head>
    <title>Task List</title>
</head>
<body>
    <h1>Task List</h1>
    <ul>
    {{ range .tasks }}
        <li>{{ . }}</li>
    {{ end }}
    </ul>
    <form action="/add" method="post">
        <input type="text" name="task" placeholder="Add a task">
        <button type="submit">Add</button>
    </form>
</body>
</html>

  4. 运行应用：在命令行中运行应用。

    go run main.go

部分 2：RPC 框架体验 - 使用 gRPC 实现简单的计算服务

使用 gRPC 框架实现一个简单的远程过程调用服务，提供加法和乘法操作。

  1. 定义 gRPC 服务：首先，我们需要定义 gRPC 服务和消息。

    创建一个名为 calculator.proto 的文件。

    syntax = "proto3";

package calculator;

service CalculatorService {
    rpc Add (AddRequest) returns (AddResponse);
    rpc Multiply (MultiplyRequest) returns (MultiplyResponse);
}

message AddRequest {
    int32 a = 1;
    int32 b = 2;
}

message AddResponse {
    int32 result = 1;
}

message MultiplyRequest {
    int32 a = 1;
    int32 b = 2;
}

message MultiplyResponse {
    int32 result = 1;
}

  2. 生成代码：使用 protoc 工具生成 Go 代码。

    protoc --go_out=plugins=grpc:. calculator.proto

  3. 实现 gRPC 服务：在项目目录下创建一个名为 calculator.go 的文件，实现 gRPC 服务。

    package main

import (
    "context"
    "fmt"
    "net"
    "github.com/gin-gonic/gin"
    "google.golang.org/grpc"
    pb "your_module_path/calculator"
)

type server struct{}

func (s *server) Add(ctx context.Context, req *pb.AddRequest) (*pb.AddResponse, error) {
    result := req.GetA() + req.GetB()
    return &pb.AddResponse{Result: result}, nil
}

func (s *server) Multiply(ctx context.Context, req *pb.MultiplyRequest) (*pb.MultiplyResponse, error) {
    result := req.GetA() * req.GetB()
    return &pb.MultiplyResponse{Result: result}, nil
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        fmt.Printf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    pb.RegisterCalculatorServiceServer(s, &server{})
    if err := s.Serve(lis); err != nil {
        fmt.Printf("failed to serve: %v", err)
    }
}

  4. 运行 gRPC 服务：在命令行中运行 gRPC 服务。

    go run calculator.go

部分 3：ORM 框架体验 - 使用 Gorm 进行数据库操作

使用 Gorm 框架实现一个简单的数据库操作，对任务清单应用中的任务进行持久化。

  1. 安装 Gorm：使用以下命令安装 Gorm 框架。

    go get -u gorm.io/gorm

  2. 定义任务模型：在 main.go 文件中定义任务模型。

    import (
    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
)

type Task struct {
    gorm.Model
    Description string
}

  3. 连接数据库并迁移模型：在 main 函数中添加以下代码，连接数据库并进行模型迁移。

    db, err := gorm.Open(sqlite.Open("tasks.db"), &gorm.Config{})
if err != nil {
    panic("failed to connect database")
}
db.AutoMigrate(&Task{})

  4. 使用 Gorm 进行操作：在路由处理函数中使用 Gorm 进行数据库操作。

    router.POST("/add", func(c *gin.Context) {
    taskDescription := c.PostForm("task")
    task := Task{Description: taskDescription}
    db.Create(&task)
    c.Redirect(http.StatusSeeOther, "/")
})

router.GET("/", func(c *gin.Context) {
    var tasks []Task
    db.Find(&tasks)
    c.HTML(http.StatusOK, "index.tmpl", gin.H{
        "tasks": tasks,
    })
})

  5. 运行应用：在命令行中运行应用。

    go run main.go

总结

在学习过程中，我体验了如何使用 Go 的三个关键领域框架：Web 框架（Gin）、RPC 框架（gRPC）以及 ORM 框架（Gorm）。了解了如何构建一个简单的任务清单应用，包括添加和列出任务的功能，以及如何使用 gRPC 实现远程过程调用服务，提供加法和乘法操作，以及如何使用 Gorm 进行数据库操作，对任务进行持久化。

avatar
文章
阅读
粉丝