【Go 语言主流 Web】框架详细解析

文章目录

[Go 语言主流 Web 框架详细解析](#Go 语言主流 Web 框架详细解析)
- 一、框架核心对比总表
- 二、主流框架详细解析（附实战代码）
- - [1. Gin：最流行的轻量级 Web 框架](#1. Gin：最流行的轻量级 Web 框架)
  - - 核心特点
    - 安装与快速入门
    - [实战示例：完整 API 服务](#实战示例：完整 API 服务)
    - 核心功能扩展
    - 优缺点
    - 测试方法
  - [2. Echo：简洁高效的轻量级框架](#2. Echo：简洁高效的轻量级框架)
  - - 核心特点
    - 安装与快速入门
    - [实战示例：RESTful API](#实战示例：RESTful API)
    - 核心优势
    - 优缺点
  - [3. Fiber：极致性能的 Web 框架](#3. Fiber：极致性能的 Web 框架)
  - - 核心特点
    - 安装与快速入门
    - [实战示例：高并发 API](#实战示例：高并发 API)
    - 核心优势
    - 注意事项
  - [4. Beego：全栈 MVC 框架](#4. Beego：全栈 MVC 框架)
  - - 核心特点
    - 安装与快速入门
    - [实战示例：MVC 全栈应用](#实战示例：MVC 全栈应用)
    - 核心优势
    - 优缺点
  - [5. Iris：功能全面的企业级框架](#5. Iris：功能全面的企业级框架)
  - - 核心特点
    - 安装与快速入门
    - [实战示例：WebSocket + JSON API](#实战示例：WebSocket + JSON API)
    - 核心优势
    - 优缺点
  - [6. 微服务框架补充](#6. 微服务框架补充)
  - - （1）Kratos（字节跳动开源）
    - （2）Go-Micro
- 三、框架选择建议
- 四、总结

Go 语言主流 Web 框架详细解析

若对您有帮助的话，请点赞收藏加关注哦，您的关注是我持续创作的动力！有问题请私信或联系邮箱：funian.gm@gmail.com

Go 语言的 Web 框架生态围绕 "简洁、高性能、并发友好" 核心设计，主流框架分为两类：

「轻量级框架」：基于标准库 net/http 扩展，专注路由、中间件等核心能力（如 Gin、Echo）；
「全栈/微服务框架」：内置 ORM、缓存、配置、服务发现等全套功能（如 Beego、Kratos）。

本文将详细介绍 最常用的 5 个框架（Gin、Echo、Fiber、Beego、Iris），包括核心特性、安装配置、实战示例、优缺点及适用场景，同时补充微服务框架选型建议。

一、框架核心对比总表

框架	核心特点	性能水平	学习成本	生态完善度	适用场景
Gin	轻量、高性能、路由高效、中间件丰富	优秀（net/http）	低	🌟🌟🌟🌟🌟	绝大多数 Web 场景（API、后端服务）
Echo	简洁、低开销、功能完备、扩展性强	优秀（net/http）	低	🌟🌟🌟🌟	轻量 API、微服务网关
Fiber	极致性能（基于 Fasthttp）、Express 风格	顶级（≈2x Gin）	低	🌟🌟🌟🌟	高并发场景（秒杀、直播接口）
Beego	全栈 MVC、内置 ORM/缓存/日志、一键部署	良好（net/http）	中	🌟🌟🌟🌟	快速开发、中小型全栈应用
Iris	功能全面、支持 HTTP/2/WebSocket、生态灵活	优秀（net/http）	中	🌟🌟🌟🌟	复杂 Web 应用（实时通讯、管理系统）
Kratos	企业级微服务、内置治理、兼容云原生	优秀	高	🌟🌟🌟🌟🌟	大规模微服务集群（企业级）

二、主流框架详细解析（附实战代码）

1. Gin：最流行的轻量级 Web 框架

核心特点

基于 httprouter 路由引擎（比标准库路由快 40 倍），支持 RESTful 路由、参数绑定、分组路由；
内置中间件机制（日志、恢复、CORS 等），支持自定义中间件；
强大的请求解析（JSON/Form/Query/路径参数）和响应渲染（JSON/HTML/文件）；
生态最完善：第三方库覆盖 ORM（GORM）、缓存（Redis）、验证（go-playground/validator）等。

安装与快速入门

bash 复制代码

# 安装 Gin（稳定版 v1.9+）
go get -u github.com/gin-gonic/gin

实战示例：完整 API 服务

go 复制代码

// main.go
package main

import (
	"net/http"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
)

// 定义请求/响应结构体
type UserRequest struct {
	Name string `json:"name" binding:"required,min=2"` // 验证规则：必填、最小长度2
	Age  int    `json:"age" binding:"required,gt=0"`   // 验证规则：必填、大于0
}

type UserResponse struct {
	ID        string    `json:"id"`
	Name      string    `json:"name"`
	Age       int       `json:"age"`
	CreatedAt time.Time `json:"created_at"`
}

func main() {
	// 1. 初始化 Gin 引擎（默认模式：debug；生产模式：gin.ReleaseMode）
	gin.SetMode(gin.ReleaseMode)
	r := gin.Default() // 包含 Logger + Recovery 中间件

	// 2. 自定义中间件（示例：请求耗时统计）
	r.Use(func(c *gin.Context) {
		start := time.Now()
		c.Next() // 执行后续处理函数
		cost := time.Since(start)
		c.Header("X-Request-Cost", cost.String()) // 响应头添加耗时
	})

	// 3. 路由分组（如 /api/v1）
	apiV1 := r.Group("/api/v1")
	{
		// GET 请求：查询用户（路径参数 + Query 参数）
		apiV1.GET("/users/:id", func(c *gin.Context) {
			// 解析路径参数
			userID := c.Param("id")
			// 解析 Query 参数（默认值 "false"）
			detail := c.DefaultQuery("detail", "false")

			// 响应 JSON
			c.JSON(http.StatusOK, gin.H{
				"id":     userID,
				"name":   "张三",
				"age":    25,
				"detail": detail,
			})
		})

		// POST 请求：创建用户（JSON 请求体绑定）
		apiV1.POST("/users", func(c *gin.Context) {
			var req UserRequest
			// 绑定并验证 JSON 请求体（失败自动返回 400）
			if err := c.ShouldBindJSON(&req); err != nil {
				c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
				return
			}

			// 模拟业务逻辑
			res := UserResponse{
				ID:        "user-1001",
				Name:      req.Name,
				Age:       req.Age,
				CreatedAt: time.Now(),
			}

			// 响应 201 Created
			c.JSON(http.StatusCreated, res)
		})
	}

	// 4. 启动服务（监听 8080 端口）
	r.Run(":8080")
}

核心功能扩展

中间件 ：内置 gin.Logger()（日志）、gin.Recovery()（异常恢复），支持第三方中间件（如 cors、ratelimit）；
参数验证 ：结合 go-playground/validator 实现复杂验证（如 email、max=100）；
静态文件 ：r.Static("/static", "./static") 托管静态资源；
模板渲染 ：r.LoadHTMLGlob("templates/*") 支持 HTML 模板。

优缺点

✅ 优点：生态最完善、文档丰富（中文支持好）、性能优秀、社区活跃；
❌ 缺点：部分高级功能（如 ORM、缓存）需依赖第三方库，不适合"零配置"全栈开发。

测试方法

bash 复制代码

# 运行服务
go run main.go

# 测试 GET 接口
curl http://localhost:8080/api/v1/users/1001?detail=true

# 测试 POST 接口
curl -X POST -H "Content-Type: application/json" -d '{"name":"李四","age":30}' http://localhost:8080/api/v1/users

2. Echo：简洁高效的轻量级框架

核心特点

基于标准库 net/http，无多余依赖，体积小、性能接近 Gin；
路由支持参数、通配符、分组，支持自定义路由匹配规则；
内置请求绑定（JSON/Form/Query/Header）、响应渲染、错误处理；
中间件支持全局、分组、路由级别的精细化控制。

安装与快速入门

bash 复制代码

# 安装 Echo v4（稳定版）
go get -u github.com/labstack/echo/v4

实战示例：RESTful API

go 复制代码

// main.go
package main

import (
	"net/http"
	"time"

	"github.com/labstack/echo/v4"
	"github.com/labstack/echo/v4/middleware"
)

// 结构体与 Gin 示例一致（UserRequest、UserResponse）
type UserRequest struct {
	Name string `json:"name" validate:"required,min=2"`
	Age  int    `json:"age" validate:"required,gt=0"`
}

type UserResponse struct {
	ID        string    `json:"id"`
	Name      string    `json:"name"`
	Age       int       `json:"age"`
	CreatedAt time.Time `json:"created_at"`
}

func main() {
	// 1. 初始化 Echo 引擎
	e := echo.New()

	// 2. 全局中间件
	e.Use(middleware.Logger())   // 日志中间件
	e.Use(middleware.Recover())  // 异常恢复
	e.Use(middleware.CORS())     // 跨域支持

	// 3. 路由分组
	apiV1 := e.Group("/api/v1", middleware.Gzip()) // 分组中间件：Gzip 压缩

	// GET：查询用户（路径参数 + Query 参数）
	apiV1.GET("/users/:id", func(c echo.Context) error {
		userID := c.Param("id")
		detail := c.QueryParam("detail")
		if detail == "" {
			detail = "false"
		}

		// Echo 响应方式：Return error（内置状态码）
		return c.JSON(http.StatusOK, map[string]interface{}{
			"id":     userID,
			"name":   "王五",
			"age":    28,
			"detail": detail,
		})
	})

	// POST：创建用户（JSON 绑定 + 验证）
	apiV1.POST("/users", func(c echo.Context) error {
		var req UserRequest
		// 绑定并验证 JSON（需配合 go-playground/validator）
		if err := c.Bind(&req); err != nil {
			return c.JSON(http.StatusBadRequest, map[string]string{"error": err.Error()})
		}
		if err := c.Validate(&req); err != nil {
			return c.JSON(http.StatusBadRequest, map[string]string{"error": err.Error()})
		}

		res := UserResponse{
			ID:        "user-1002",
			Name:      req.Name,
			Age:       req.Age,
			CreatedAt: time.Now(),
		}
		return c.JSON(http.StatusCreated, res)
	})

	// 4. 启动服务
	e.Logger.Fatal(e.Start(":8080"))
}

核心优势

路由灵活性 ：支持自定义路由函数（如正则匹配），示例：

go 复制代码

// 匹配 /users/123、/users/abc（不匹配 /users/123/456）
e.GET("/users/:id", handler)
// 匹配 /files/xxx.txt、/files/doc/xxx.pdf（通配符 * 匹配任意路径）
e.GET("/files/*", fileHandler)

中间件粒度 ：支持全局（e.Use）、分组（group.Use）、单个路由（e.GET("/path", handler, middleware)）；
低开销：比 Gin 更轻量，无多余依赖，适合资源受限场景。

优缺点

✅ 优点：简洁易用、性能优秀、扩展性强、中间件控制精细；
❌ 缺点：生态略逊于 Gin，部分第三方库集成需手动配置。

3. Fiber：极致性能的 Web 框架

核心特点

基于 Fasthttp（替代标准库 net/http），性能是 Gin 的 2-3 倍（支持百万级并发）；
语法风格类似 Node.js Express，降低前端开发者学习成本；
内置路由、中间件、请求绑定、响应渲染，支持 WebSocket、HTTP/2；
内存占用低，适合高并发场景（如秒杀、直播弹幕、API 网关）。

安装与快速入门

bash 复制代码

# 安装 Fiber v2（稳定版）
go get -u github.com/gofiber/fiber/v2

实战示例：高并发 API

go 复制代码

// main.go
package main

import (
	"time"

	"github.com/gofiber/fiber/v2"
	"github.com/gofiber/fiber/v2/middleware/cors"
	"github.com/gofiber/fiber/v2/middleware/logger"
)

type UserRequest struct {
	Name string `json:"name" validate:"required,min=2"`
	Age  int    `json:"age" validate:"required,gt=0"`
}

type UserResponse struct {
	ID        string    `json:"id"`
	Name      string    `json:"name"`
	Age       int       `json:"age"`
	CreatedAt time.Time `json:"created_at"`
}

func main() {
	// 1. 初始化 Fiber 引擎（配置并发数、读取超时等）
	app := fiber.New(fiber.Config{
		Concurrency: 1024 * 1024, // 支持 100 万并发连接
		ReadTimeout: 3 * time.Second,
	})

	// 2. 中间件
	app.Use(logger.New()) // 日志
	app.Use(cors.New())   // 跨域

	// 3. 路由分组
	apiV1 := app.Group("/api/v1")

	// GET：查询用户
	apiV1.Get("/users/:id", func(c *fiber.Ctx) error {
		userID := c.Params("id")       // 路径参数
		detail := c.Query("detail", "false") // Query 参数（默认值）

		// 响应 JSON（Fiber 简化语法）
		return c.Status(fiber.StatusOK).JSON(fiber.Map{
			"id":     userID,
			"name":   "赵六",
			"age":    32,
			"detail": detail,
		})
	})

	// POST：创建用户（JSON 绑定 + 验证）
	apiV1.Post("/users", func(c *fiber.Ctx) error {
		var req UserRequest
		// 绑定 JSON（失败返回 400）
		if err := c.BodyParser(&req); err != nil {
			return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
		}

		// 模拟验证（可结合 go-playground/validator）
		if req.Name == "" || req.Age <= 0 {
			return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "参数无效"})
		}

		res := UserResponse{
			ID:        "user-1003",
			Name:      req.Name,
			Age:       req.Age,
			CreatedAt: time.Now(),
		}
		return c.Status(fiber.StatusCreated).JSON(res)
	})

	// 4. 启动服务（支持优雅关闭）
	app.Listen(":8080")
}

核心优势

性能碾压 ：Fasthttp 采用连接复用、内存池等优化，比标准库 net/http 快 5-10 倍；
语法简洁 ：c.Params()、c.Query()、c.BodyParser() 等 API 直观，类似 Express；
功能丰富：内置 WebSocket、HTTP/2、Gzip、静态文件服务、速率限制等功能。

注意事项

❗ 兼容性：Fasthttp 不完全兼容 net/http 接口，部分依赖 net/http 的库（如某些 OAuth 库）无法直接使用；
❗ 生态：虽在快速发展，但第三方库数量仍少于 Gin。

4. Beego：全栈 MVC 框架

核心特点

遵循 MVC 架构（Model-View-Controller），内置全套 Web 开发组件：
- 路由自动注册、ORM 数据库访问、模板引擎、缓存（Redis/Memcached）；
- 配置管理、日志、监控、一键部署（bee 工具）；
适合"快速开发"，无需手动整合第三方库，开箱即用。

安装与快速入门

bash 复制代码

# 安装 Beego 框架
go get -u github.com/beego/beego/v2@latest
# 安装 bee 命令行工具（代码生成、运行、部署）
go install github.com/beego/bee/v2@latest

实战示例：MVC 全栈应用

创建项目 （通过 bee 工具快速初始化）：

bash 复制代码

bee new beego-demo
cd beego-demo

项目结构（MVC 分层）：

复制代码

beego-demo/
├── controllers/  # 控制器（C）
│   └── default.go
├── models/       # 模型（M）
│   └── user.go
├── views/        # 视图（V）
│   └── index.tpl
├── conf/         # 配置文件
│   └── app.conf
└── main.go       # 入口文件

核心代码实现：

「模型层」models/user.go（ORM 映射数据库表）：

go 复制代码

package models

import (
	"github.com/beego/beego/v2/client/orm"
	_ "github.com/go-sql-driver/mysql" // MySQL 驱动
)

// User 结构体映射数据库表（自动创建表）
type User struct {
	ID        int       `orm:"auto;pk"` // 自增主键
	Name      string    `orm:"size(50)"` // 字段长度 50
	Age       int       `orm:"default(0)"`
	CreatedAt time.Time `orm:"auto_now_add"` // 创建时自动赋值
}

// 初始化 ORM
func init() {
	// 注册数据库（配置来自 conf/app.conf）
	orm.RegisterDataBase("default", "mysql", "root:123456@tcp(127.0.0.1:3306)/beego_demo?charset=utf8")
	// 注册模型
	orm.RegisterModel(new(User))
	// 自动创建表（仅开发环境使用）
	orm.RunSyncdb("default", false, true)
}

「控制器层」controllers/default.go（处理请求）：

go 复制代码

package controllers

import (
	"beego-demo/models"
	"github.com/beego/beego/v2/server/web"
	"github.com/beego/beego/v2/client/orm"
)

type MainController struct {
	web.Controller // 继承 Beego 控制器
}

// GET /users/:id：查询用户
func (c *MainController) GetUser() {
	userID, _ := c.GetInt(":id") // 路径参数
	o := orm.NewOrm()
	user := models.User{ID: userID}

	if err := o.Read(&user); err == nil {
		c.Data["json"] = user // 响应 JSON
	} else {
		c.Data["json"] = map[string]string{"error": "用户不存在"}
		c.Ctx.ResponseWriter.Status = 404
	}
	c.ServeJSON() // 发送 JSON 响应
}

// POST /users：创建用户
func (c *MainController) CreateUser() {
	var user models.User
	// 绑定 JSON 请求体
	if err := c.ParseJSON(&user); err != nil {
		c.Data["json"] = map[string]string{"error": err.Error()}
		c.Ctx.ResponseWriter.Status = 400
		c.ServeJSON()
		return
	}

	o := orm.NewOrm()
	if _, err := o.Insert(&user); err == nil {
		c.Data["json"] = user
		c.Ctx.ResponseWriter.Status = 201
	} else {
		c.Data["json"] = map[string]string{"error": err.Error()}
		c.Ctx.ResponseWriter.Status = 500
	}
	c.ServeJSON()
}

「路由配置」conf/app.conf（或代码注册）：

ini 复制代码

# app.conf
appname = beego-demo
httpport = 8080
runmode = dev # 开发模式（debug）

「入口文件」main.go：

go 复制代码

package main

import (
	"beego-demo/controllers"
	"github.com/beego/beego/v2/server/web"
)

func main() {
	// 注册路由（RESTful 风格）
	web.Router("/api/v1/users/:id", &controllers.MainController{}, "get:GetUser")
	web.Router("/api/v1/users", &controllers.MainController{}, "post:CreateUser")

	// 启动服务
	web.Run()
}

运行项目：

bash 复制代码

bee run # 自动热重载

核心优势

「全栈集成」：ORM 支持 MySQL/PostgreSQL/MongoDB 等，无需额外引入；
「开发效率高」：bee 工具支持代码生成（bee generate model）、数据库迁移、压力测试；
「监控完善」：内置监控面板（/debug/pprof），支持性能分析。

优缺点

✅ 优点：开箱即用、开发速度快、文档完善，适合中小型全栈应用；
❌ 缺点：MVC 架构略显笨重，灵活性不足，不适合微服务场景；部分组件（如模板引擎）更新较慢。

5. Iris：功能全面的企业级框架

核心特点

支持 HTTP/1.1、HTTP/2、WebSocket、gRPC 等多种协议；
内置路由、中间件、请求验证、模板引擎、依赖注入；
提供丰富的企业级功能：速率限制、JWT 认证、CORS、CSRF 防护；
兼容性好，同时支持 net/http 和自定义引擎。

安装与快速入门

bash 复制代码

# 安装 Iris v12（稳定版）
go get -u github.com/kataras/iris/v12@latest

实战示例：WebSocket + JSON API

go 复制代码

// main.go
package main

import (
	"time"

	"github.com/kataras/iris/v12"
	"github.com/kataras/iris/v12/middleware/logger"
	"github.com/kataras/iris/v12/middleware/recover"
)

type UserRequest struct {
	Name string `json:"name" validate:"required,min=2"`
	Age  int    `json:"age" validate:"required,gt=0"`
}

func main() {
	// 1. 初始化 Iris 引擎
	app := iris.New()
	app.Logger().SetLevel("info")

	// 2. 中间件
	app.Use(recover.New()) // 异常恢复
	app.Use(logger.New())  // 日志

	// 3. JSON API 路由
	apiV1 := app.Party("/api/v1") // 路由分组
	{
		apiV1.Get("/users/:id", func(ctx iris.Context) {
			userID := ctx.Params().Get("id")
			ctx.JSON(iris.Map{
				"id":   userID,
				"name": "孙七",
				"age":  35,
			})
		})

		apiV1.Post("/users", func(ctx iris.Context) {
			var req UserRequest
			if err := ctx.ReadJSON(&req); err != nil {
				ctx.StatusCode(iris.StatusBadRequest)
				ctx.JSON(iris.Map{"error": err.Error()})
				return
			}

			ctx.StatusCode(iris.StatusCreated)
			ctx.JSON(iris.Map{
				"id":        "user-1004",
				"name":      req.Name,
				"age":       req.Age,
				"created_at": time.Now(),
			})
		})
	}

	// 4. WebSocket 示例（实时通讯）
	app.Get("/ws", func(ctx iris.Context) {
		ctx.Websocket().OnConnect(func(ws iris.WebsocketConnection) {
			app.Logger().Info("客户端连接成功")
			ws.Emit("welcome", "Hello WebSocket!")
		})

		ctx.Websocket().OnMessage(func(ws iris.WebsocketConnection, msg []byte) {
			// 广播消息给所有连接
			ws.To(iris.Broadcast).Emit("message", string(msg))
		})
	})

	// 5. 启动服务（支持 HTTP/2）
	app.Run(iris.Addr(":8080"), iris.WithConfiguration(iris.YAML("./configs/iris.yml")))
}

核心优势

「多协议支持」：原生支持 WebSocket、gRPC，无需第三方库；
「企业级功能」：内置 JWT 认证、速率限制、CSRF 防护，适合复杂应用；
「灵活性」：可切换引擎（net/http 或自定义），兼容现有 net/http 中间件。

优缺点

✅ 优点：功能全面、扩展性强、适合企业级应用；
❌ 缺点：学习曲线略陡，文档以英文为主，生态不如 Gin 活跃。

6. 微服务框架补充

（1）Kratos（字节跳动开源）

核心定位：企业级微服务框架，基于 Go 1.18+ 泛型和模块化设计；
内置功能：服务注册发现（Consul/Eureka）、配置中心（Nacos/Apollo）、链路追踪（Jaeger）、限流熔断；
协议支持：HTTP/REST、gRPC、Thrift；
适用场景：大规模微服务集群（如电商、金融），适合团队协作开发。

（2）Go-Micro

核心定位：云原生微服务框架，专注服务发现、负载均衡、消息队列；
内置功能：服务注册（etcd/consul）、配置管理、熔断降级、分布式事务；
适用场景：轻量级微服务，适合快速搭建分布式系统。

三、框架选择建议

应用场景	推荐框架	理由
快速开发 API、后端服务	Gin/Echo	生态完善、学习成本低、性能满足需求
高并发场景（秒杀、直播）	Fiber	极致性能，支持百万级并发
中小型全栈应用（MVC）	Beego	全栈集成，无需整合第三方库
企业级复杂应用（多协议）	Iris	支持 WebSocket/gRPC，内置企业级功能
大规模微服务（企业级）	Kratos	模块化、可观测性强，适合团队协作
轻量级微服务	Go-Micro/Echo	轻量、灵活，无多余依赖
资源受限场景（嵌入式）	Echo/Chi	体积小、内存占用低

四、总结

Go 语言 Web 框架的核心差异在于 "功能覆盖范围"和"性能取向"：

「轻量级框架」（Gin/Echo/Fiber）：专注核心能力，灵活度高，适合大多数 Web 场景；
「全栈框架」（Beego）：开箱即用，开发效率高，适合中小型全栈应用；
「企业级/微服务框架」（Iris/Kratos）：功能全面，支持多协议和分布式特性，适合复杂系统。

最佳实践：

入门首选 Gin：文档丰富、社区活跃，遇到问题容易解决；
追求性能选 Fiber：适合高并发 API 或网关；
微服务优先 Kratos：企业级特性完善，适合大规模团队；
全栈快速开发选 Beego：无需关注底层组件整合。

【Go 语言主流 Web】 框架详细解析

文章目录

Go 语言主流 Web 框架详细解析

一、框架核心对比总表

二、主流框架详细解析（附实战代码）

1. Gin：最流行的轻量级 Web 框架

核心特点

安装与快速入门

实战示例：完整 API 服务

核心功能扩展

优缺点

测试方法

2. Echo：简洁高效的轻量级框架

核心特点

安装与快速入门

实战示例：RESTful API

核心优势

优缺点

3. Fiber：极致性能的 Web 框架

核心特点

安装与快速入门

实战示例：高并发 API

核心优势

注意事项

4. Beego：全栈 MVC 框架

核心特点

安装与快速入门

实战示例：MVC 全栈应用

核心优势

优缺点

5. Iris：功能全面的企业级框架

核心特点

安装与快速入门

实战示例：WebSocket + JSON API

核心优势

优缺点

6. 微服务框架补充

（1）Kratos（字节跳动开源）

（2）Go-Micro

三、框架选择建议

四、总结

【Go 语言主流 Web】框架详细解析