Go 語言微服務框架 Kratos 開發 HTTP API
1.介紹
Kratos 一套輕量級 Go 微服務框架，包含大量微服務相關框架及工具。
本文我們分為開發環境，創建項目，代碼目錄，HTTP API，四個部分介紹 Kratos 微服務框架。
2.開發環境
使用 Kratos 微服務框架，我們需要準備 Go 開發環境，我們選擇使用 Go 當前最新版本 go v1.23。
因為 Kratos 微服務框架通過 Protobuf IDL 定義 API，所以我們需要安裝工具 protoc，以及相關插件，比如 protoc-gen-go 等。
因為 Kratos 微服務框架使用依賴注入，所以我們需要安裝依賴工具 wire。
此外，Kratos 微服務框架提供了腳手架工具 kratos。
3.創建項目
我們可以使用 Kartos 微服務框架的腳手架工具 kratos 創建項目。
示例代碼：
kratos new user-center -r https://gitee.com/go-kratos/kratos-layout.git閱讀上面這段代碼，我們可以發現使用 kratos 的 new 命令創建項目名稱為 user-center 的項目，使用 -r 指定模板源。
此外，也可以使用環境變量指定模板源，例如：KRATOS_LAYOUT_REPO=https://gitee.com/go-kratos/kratos-layout.git。
4.代碼目錄
在使用 kratos 創建項目之后，我們再介紹一下項目的代碼目錄。
示例代碼：
.
└── user-center
├── api
│ ├── helloworld
├── cmd
│ └── user-center
├── configs
│ └── config.yaml
├── Dockerfile
├── go.mod
├── go.sum
├── internal
│ ├── biz
│ ├── conf
│ ├── data
│ ├── server
│ └── service
├── LICENSE
├── Makefile
├── openapi.yaml
├── README.md
└── third_party
├── errors
├── google
├── openapi
├── README.md
└── validate閱讀上面的代碼目錄，我們分別介紹每個目錄的作用，api 目錄中是 proto 文件以及 protoc 生成的 go 文件；cmd 目錄中是項目入口文件 main.go 和 wire 工具的文件 wire.go 以及 wire 生成的 go 文件；configs 目錄中是配置文件；
internal 目錄中是業務邏輯代碼，其中 biz 目錄中是 DDD 的 domain 和 usecase，data 目錄中是 DDD 的 repository，service 目錄中是 DDD 的 delivery；
conf 目錄中是使用 proto 格式的配置文件，server 目錄中是 http 和 grpc 的實例。
5.HTTP API
創建 proto 文件
Kratos 微服務框架開發 HTTP API 和 RPC API 都是通過定義 proto。
我們可以使用 kratos 腳手架工具生成 proto 模板文件，然后按照自己的需求修改。
示例代碼：
kratos proto add api/user/v1/user.proto也可以手動創建 proto 文件，并且編寫相關代碼。
示例代碼：
syntax = "proto3";
package user.v1;
import "google/api/annotations.proto";
option go_package = "user-center/api/user/v1;v1";
service User {
rpc Login (LoginReq) returns (LoginRes) {
option (google.api.http) = {
post: "/login",
body: "*",
}
}
}
message LoginReq {
string email = 1;
string password = 2;
}
message LoginRes {
string name = 1;
}在創建 proto 文件之后，我們生成 go 文件，可以直接使用 protoc 工具，也可以使用 kratos 腳手架，本文我們使用 kratos 腳手架。
生成 client 源碼
示例代碼：
kratos proto client api/user/v1/user.proto生成 server 源碼
示例代碼：
kratos proto server api/user/v1/user.proto -t internal/service接入 XORM
修改 internal/data/data.go 文件。
示例代碼：
// Data .
type Data struct {
// TODO wrapped database client
dbEngine *xorm.Engine
}
// NewData .
func NewData(c *conf.Data, logger log.Logger, dbEngine *xorm.Engine) (*Data, func(), error) {
cleanup := func() {
log.NewHelper(logger).Info("closing the data resources")
}
return &Data{
dbEngine: dbEngine,
}, cleanup, nil
}
// NewDbEngine .
func NewDbEngine(c *conf.Data) (dbEngine *xorm.Engine, err error) {
dbEngine, err = xorm.NewEngine(c.Database.Driver, c.Database.Source)
return
}修改配置文件
修改 configs/config.yaml 文件。
示例代碼：
data:
database:
driver: mysql
source: frank:123456@tcp(192.168.110.156:3306)/user?parseTime=True&loc=Localdomain 層和 usecase 層
在 internal/biz/user.go 文件中，編寫 domain 層和 usecase 層代碼。
示例代碼：
package biz
import (
"context"
pb "user-center/api/user/v1"
)
type User struct {
Email string
Password string
}
type UserRepo interface {
Create(ctx context.Context, loginReq *pb.LoginReq) (int64, error)
}
type UserUsecase struct {
ur UserRepo
}
func NewUserUsecase(ur UserRepo) *UserUsecase {
return &UserUsecase{
ur: ur,
}
}
func (u *UserUsecase) Register(ctx context.Context, loginReq *pb.LoginReq) (id int64, err error) {
id, err = u.ur.Create(ctx, loginReq)
return
}repository 層
在 internal/data/user.go 文件中，編寫 reporitory 層代碼。
示例代碼：
package data
import (
"context"
"fmt"
pb "user-center/api/user/v1"
"user-center/internal/biz"
)
type userRepo struct {
data *Data
}
func NewUserRepo(data *Data) biz.UserRepo {
return &userRepo{
data: data,
}
}
func (u *userRepo) Create(ctx context.Context, loginReq *pb.LoginReq) (id int64, err error) {
fmt.Println(loginReq)
id, err = u.data.dbEngine.InsertOne(loginReq)
return
}delivery 層
在 internal/service/user.go 文件中，編寫 delivery 層代碼。
示例代碼：
package service
import (
"context"
"user-center/internal/biz"
pb "user-center/api/user/v1"
)
// UserService is a user service.
type UserService struct {
pb.UnimplementedUserServer
uc *biz.UserUsecase
}
// NewUserService new a user service.
func NewUserService(uc *biz.UserUsecase) *UserService {
return &UserService{
uc: uc,
}
}
// Login implements user.UserService.
func (u *UserService) Login(ctx context.Context, req *pb.LoginReq) (res *pb.LoginRes, err error) {
_, err = u.uc.Register(ctx, req)
return
}注冊 HTTP API
在生成 server 源碼之后，我們需要注冊 HTTP API。
在 internal/server/http.go 文件中，修改代碼，導入 v1 blog/api/user/v1 ，在 NewHTTPServer 函數的參數列表中添加 user *service.UserService ，在函數體中添加 v1.RegisterUserHTTPServer(srv, user) 。
wire 生成
接下來，我們需要修改 wire 的 provider。
在 internal/service/service.go 文件中，新增 NewUserService。
示例代碼：
var ProviderSet = wire.NewSet(NewGreeterService, NewUserService)在 internal/biz/biz.go 文件中，新增 NewUserUsecase。
示例代碼：
var ProviderSet = wire.NewSet(NewGreeterUsecase, NewUserUsecase)在 internal/data/data.go 文件中，新增 NewUserRepo。
示例代碼：
var ProviderSet = wire.NewSet(NewData, NewDbEngine, NewGreeterRepo, NewUserRepo)執行 wire 生成命令：
示例代碼：
cd cmd/user-center
wire查看 wire_gen.go 文件。
示例代碼：
// wireApp init kratos application.
func wireApp(confServer *conf.Server, confData *conf.Data, logger log.Logger) (*kratos.App, func(), error) {
engine, err := data.NewDbEngine(confData)
if err != nil {
return nil, nil, err
}
dataData, cleanup, err := data.NewData(confData, logger, engine)
if err != nil {
return nil, nil, err
}
greeterRepo := data.NewGreeterRepo(dataData, logger)
greeterUsecase := biz.NewGreeterUsecase(greeterRepo, logger)
greeterService := service.NewGreeterService(greeterUsecase)
grpcServer := server.NewGRPCServer(confServer, greeterService, logger)
userRepo := data.NewUserRepo(dataData)
userUsecase := biz.NewUserUsecase(userRepo)
userService := service.NewUserService(userUsecase)
httpServer := server.NewHTTPServer(confServer, userService, logger)
app := newApp(logger, grpcServer, httpServer)
return app, func() {
cleanup()
}, nil
}閱讀上面代碼，我們可以發現 wire 工具已經生成依賴注入代碼。
運行代碼
示例代碼：
kratos run6.總結
本文我們介紹使用 kratos 微服務框架，怎么創建 HTTP API，介紹了怎么通過 kratos 腳手架創建項目和生成 proto 文件。
Kratos 微服務框架使用 DDD 和 DI 的代碼架構，我們介紹 kratos 模板生成的代碼目錄的作用。
關于 proto 和 wire 工具，以及 DDD 和 DI 的詳細介紹，我們在之前的文章中都介紹過，讀者朋友們可以按需翻閱。
