罗罗编程学习记录
本页内容 展开查看

04.3.4.1 go-zero/kratos 与 wire/testify

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.3 Go / 04.3.4 微服务框架与工程

覆盖范围

  • go-zero:一站式微服务框架,自带代码生成、服务发现、熔断限流
  • kratos:B 站开源,模块化设计,HTTP/gRPC 双协议
  • wire:Google 出品的编译期依赖注入
  • testify:Go 最流行的测试断言库

高频题速览

编号 题目 难度 频率
04.3.4.1-001 go-zero 是什么,有什么特点 进阶 ★★★☆☆
04.3.4.1-002 kratos 是什么 进阶 ★★★☆☆
04.3.4.1-003 wire 依赖注入原理 进阶 ★★★★☆
04.3.4.1-004 wire 和运行时 DI 区别 进阶 ★★★☆☆
04.3.4.1-005 testify 常用断言 基础 ★★★★☆
04.3.4.1-006 Go 测试怎么写 基础 ★★★★☆
04.3.4.1-007 mock 测试怎么写 进阶 ★★★★☆
04.3.4.1-008 go-zero 和 kratos 怎么选 基础 ★★★☆☆

04.3.4.1-003 wire 依赖注入的原理是什么?

频率 ★★★★☆ | 难度 进阶

一句话结论

wire 是 Google 出品的编译期依赖注入工具:用代码声明依赖关系,wire 在编译时自动生成依赖注入的代码,不是运行时反射,所以性能好、类型安全、错误能在编译时发现。

概念解释

  • wire:编译期依赖注入,不是运行时反射。
  • Provider:提供某个类型的构造函数。
  • Injector:把所有 Provider 组合起来,生成一个注入函数。
  • 特点:
    • 编译期生成代码,性能好,没有运行时开销。
    • 类型安全,依赖错了编译就报错。
    • 生成的代码是人写的,可调试。

原理流程

  1. 写 wire.go,用 wire.NewSet 声明所有 Provider。
  2. 运行 wire 命令,生成 wire_gen.go。
  3. wire_gen.go 里自动生成了依赖注入的代码:先创建依赖的依赖,再创建当前对象。
  4. 编译时,所有依赖关系都确定了,没有运行时反射。

代码 / 示例

// wire.go
//go:build wireinject

package main

import (
    "github.com/google/wire"
)

func InitApp() *App {
    wire.Build(
        NewUserService,
        NewUserRepository,
        NewApp,
    )
    return nil
}

// 生成的 wire_gen.go
func InitApp() *App {
    userRepository := NewUserRepository()
    userService := NewUserService(userRepository)
    app := NewApp(userService)
    return app
}

常见误区

  • 误区:wire 是运行时依赖注入?正解:wire 是编译期的,生成代码,不是运行时反射。
  • 误区:wire 和 Java Spring 一样?正解:Spring 是运行时反射,wire 是编译期生成代码,性能更好。

追问 / 延伸

  • 什么是 Provider?答:一个函数,返回某个类型的实例,wire 把它当成依赖的提供者。
  • 什么是 Injector?答:把所有 Provider 组合起来,生成一个入口函数,调用它就能拿到根对象。

04.3.4.1-005 testify 常用断言有哪些?

频率 ★★★★☆ | 难度 基础

一句话结论

testify 是 Go 最流行的测试库,suite 提供测试套件,assert/require 提供断言;assert 失败继续跑,require 失败直接停;常用断言:Equal、Nil、Error、NotNil、Contains。

概念解释

  • assert:断言失败,测试继续跑,最后报告失败。
  • require:断言失败,测试立刻停止。
  • suite:测试套件,有 SetupTest、TearDownTest 等生命周期。
  • mock:mock 生成工具,配合 gomock 用。

原理流程

  1. 写测试函数,接收 *testing.T。
  2. 用 assert.Equal(t, expected, actual) 断言。
  3. 失败时,assert 会打印错误信息,但测试继续。
  4. require 失败时,测试立刻停止,后面的断言不跑。

代码 / 示例

import (
    "testing"
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/require"
)

func TestAdd(t *testing.T) {
    result := Add(1, 2)

    // assert:失败继续跑
    assert.Equal(t, 3, result, "1+2 应该等于 3")
    assert.NotNil(t, result)

    // require:失败直接停
    require.Equal(t, 3, result)
}

// 常用断言
func TestSomething(t *testing.T) {
    assert.Equal(t, 123, 123)
    assert.NotEqual(t, 123, 456)
    assert.Nil(t, nil)
    assert.NotNil(t, "hello")
    assert.True(t, true)
    assert.False(t, false)
    assert.Error(t, someError)
    assert.NoError(t, nil)
    assert.Contains(t, "hello world", "world")
    assert.Len(t, []int{1, 2, 3}, 3)
}

常见误区

  • 误区:assert 和 require 一样?正解:assert 失败继续跑,require 失败立刻停;重要的断言用 require。
  • 误区:testify 只能写单元测试?正解:testify 也能写集成测试,配合 suite 组织测试。

追问 / 延伸

  • 什么是 table-driven test?答:Go 的经典测试模式,用一个表存多个测试用例,循环跑。
  • 什么是 mock?答:模拟外部依赖,比如数据库、HTTP 服务,不用真的连数据库就能测试业务逻辑。

04.3.4.1-001 go-zero 是什么?有什么特点?

频率 ★★★☆☆ | 难度 进阶

一句话结论

go-zero 是国产开源的 Go 微服务框架,自带代码生成、服务发现、熔断限流、监控告警,一站式解决微服务开发的常见问题,适合快速构建生产级微服务。

概念解释

  • go-zero 特点:
    • 一站式:代码生成、RPC、HTTP、服务发现、熔断限流、监控都有。
    • 高性能:基于 Go 原生,性能好。
    • 代码生成工具:goctl,从 API 定义生成服务端代码。
    • 内置中间件:日志、链路追踪、限流、熔断。
  • 适用场景:快速开发微服务,不想自己搭各种中间件。

原理流程

  1. 写一个 .api 文件,定义接口和参数。
  2. 用 goctl 工具生成服务端代码骨架。
  3. 自己写业务逻辑。
  4. 框架自带服务发现(etcd)、熔断、限流、监控。

代码 / 示例

// user.api
type (
    UserRequest {
        Id int `path:"id"`
    }
    UserResponse {
        Id   int    `json:"id"`
        Name string `json:"name"`
    }
)

@server(
    prefix: /api/v1
)
service user {
    @handler getUser
    get /users/:id (UserRequest) returns (UserResponse)
}
# 生成代码
goctl api go -api user.api -dir .

常见误区

  • 误区:go-zero 是 Spring Cloud 那样的全家桶?正解:go-zero 更轻量,核心是代码生成和基础组件,不是很重的框架。
  • 误区:go-zero 只能做微服务?正解:也可以做单体 HTTP 服务,很方便。

追问 / 延伸

  • 什么是 goctl?答:go-zero 的代码生成工具,从 API 定义生成 Go 代码。
  • go-zero 用什么做服务发现?答:默认用 etcd。

04.3.4.1-002 kratos 是什么?

频率 ★★★☆☆ | 难度 进阶

一句话结论

kratos 是 B 站开源的 Go 微服务框架,模块化设计,HTTP/gRPC 双协议,强调工程规范和可维护性,适合大型团队长期维护的项目。

概念解释

  • kratos 特点:
    • B 站开源,生产验证。
    • 模块化:传输、中间件、日志、监控都是独立模块,可替换。
    • 双协议:同时支持 HTTP 和 gRPC。
    • 工程规范:目录结构、错误处理、配置管理都有约定。
  • 设计理念:简单、稳定、可维护。

原理流程

  1. kratos 把应用分成几个部分:transport(传输层)、service(业务层)、data(数据层)。
  2. 传输层接收 HTTP 或 gRPC 请求,调用 service。
  3. service 处理业务逻辑,调用 data 层操作数据库。
  4. 中间件在传输层和业务层之间,做日志、监控、鉴权。

代码 / 示例

// kratos 项目结构
// api/        - 接口定义
// cmd/        - 入口
// internal/
//   - biz/    - 业务逻辑
//   - data/   - 数据访问
//   - service/ - 业务服务
//   - transport/ - HTTP/gRPC 传输

常见误区

  • 误区:kratos 和 go-zero 差不多?正解:go-zero 更偏向代码生成和快速开发,kratos 更偏向工程规范和模块化设计。
  • 误区:kratos 很重?正解:kratos 模块化,不用的模块可以不引入,很轻量。

追问 / 延伸

  • kratos 名字怎么来的?答:来自希腊神话里的力量之神 Kratos。
  • kratos 适合什么团队?答:大型团队,需要严格工程规范和长期维护的项目。

04.3.4.1-008 go-zero 和 kratos 怎么选?

频率 ★★★☆☆ | 难度 基础

一句话结论

快速开发、要代码生成、不想搭各种中间件选 go-zero;大型团队、要严格工程规范、模块化设计选 kratos。

概念解释

  • go-zero:
    • 优点:代码生成快,一站式,适合快速开发。
    • 缺点:相对重,定制化空间小。
  • kratos:
    • 优点:模块化,工程规范好,适合大型团队。
    • 缺点:学习曲线陡,要自己搭一些东西。

原理流程

  1. 小团队、快速上线:选 go-zero,代码生成快,自带各种中间件。
  2. 大团队、长期维护:选 kratos,工程规范好,模块化易维护。

代码 / 示例

选型决策:
1. 快速开发、要代码生成? → go-zero
2. 大型团队、要工程规范? → kratos
3. 喜欢轻量、自己组装? → 直接用标准库 + 中间件

常见误区

  • 误区:一定要选最新的框架?正解:Go 标准库就很强大,很多项目直接用标准库,不用框架。
  • 误区:go-zero 不如 kratos?正解:各有适用场景,没有好坏,只有合适不合适。

追问 / 延伸

  • 为什么很多 Go 项目不用框架?正解:Go 标准库 net/http 就很强大,框架只是加了一些便利功能,小项目直接用标准库更轻量。
  • 什么是微服务框架?答:解决微服务的常见问题:服务发现、负载均衡、熔断限流、链路追踪、监控告警。

04.3.4.1-009 wire 的 Provider 有哪些类型?

频率 ★★★☆☆ | 难度 进阶

一句话结论

wire 有三种 Provider:普通 Provider(函数)、Struct Provider(结构体字段)、Set(一组 Provider 打包);方便组织依赖关系。

概念解释

  • Provider:提供某个类型的构造函数。
  • 普通 Provider:一个函数,返回某个类型。
  • Struct Provider:结构体的字段自动作为依赖。
  • Provider Set:把一组 Provider 打包成一个集合,方便复用。

原理流程

  1. 普通 Provider:func NewUserService(r *UserRepository) *UserService。
  2. Struct Provider:wire.Struct(new(UserService), "*"),把所有字段都当依赖。
  3. Provider Set:wire.NewSet(NewUserRepository, NewUserService),打包成一个集合。

代码 / 示例

// 普通 Provider
func NewUserRepository(db *sql.DB) *UserRepository {
    return &UserRepository{db: db}
}

func NewUserService(r *UserRepository) *UserService {
    return &UserService{repo: r}
}

// Provider Set
var UserSet = wire.NewSet(
    NewUserRepository,
    NewUserService,
)

// 在 injector 里用
func InitApp() *App {
    wire.Build(
        NewDB,
        UserSet, // 直接用整个 Set
        NewApp,
    )
    return nil
}

常见误区

  • 误区:wire 只能用函数做 Provider?正解:也可以用 Struct Provider,结构体的字段自动注入。
  • 误区:Provider Set 就是分组?正解:Provider Set 是可复用的依赖集合,多个 injector 可以共用。

追问 / 延伸

  • 什么是绑定接口?答:用 wire.Bind 把具体实现绑定到接口,比如 wire.Bind(new(Repository), new(UserRepository))。
  • 什么是 Build 标签?答:wire.go 文件要加 //go:build wireinject 标签,这样不会被编译进最终二进制。

待整理清单

  • [ ] go-zero 实战
  • [ ] kratos 实战
  • [ ] Go 测试最佳实践
  • [ ] gomock 与 mockery