开篇先吐槽几句～
我个人有一些习惯， 比如在服务设计时会考虑的比较长远，会考虑到到未来的扩展等等…然后程序设计的抽象成度就会比较高，各个模块之间解耦，但这样往往就会带来程序的复杂度提升。
这其实在一些公司里面是不被喜欢的， 因为这可能会延长开发周期（主要的）， 增加开发成本， 以及其他同学接手项目是的学习成本。
interface多了确实对一个初接手项目的同学不太友好，找起来对应的实现真的是太麻烦了, 大家应该都有这个感觉吧？
现实的场景是大家往往都忙着交差， 代码丝毫没有设计（可能也有，但不多），能跑能实现功能就行。 特别是ToB模式的公司， 往往项目/客户需求驱动， 项目周期短， 代码质量也就不会太高。
我就在这样的公司， 这里的工作模式/交互模式甚是让我苦恼。
我对于项目整体的规范性和整洁性有比较高的要求， 所以对抽象也比较热衷。
其实他说的也对，我也认同， 但是我还是有我自己的执念吧～ （或者说强迫症）。而且把自己的理念强加给别人我觉得也不太好~
下面开始正题吧，聊聊几个有趣的框架。因为大家的功能都比较完备， 所以讨论更偏向于设计理念吧。挑了几个我认为比较好玩的框架和大家分享。
【go-kit】 一个将抽象设计暴露给用户的框架
githut: https://github.com/go-kit/kit?tab=readme-ov-file
第一眼看见go-kit的时候就觉得： 哇，这个框架也与我抽象的理念太符合了吧。 后来觉得， 太抽象了… 确实开发的复杂度变高了. (或者简单来说， 麻烦了～)
go-kit里面以Transport，Endpoint，Service，Middleware等等概念来抽象服务， 以及服务之间的调用。
- Transport 负责对外暴露服务，对不同的协议的提供支持， 现在支持http，grpc，thrift等等
- Endpoint 很关键的一层抽象， 真实提供功能的对象屏蔽掉， 以此来实现解耦和对各种不同协议的支持
- Service 真正提供功能的对象， 也就是我们平时写的业务逻辑
- Middleware 包裹endpoint， 用于实现日志，监控，限流等等
graph LR
cliet[http、grpc、...] -->
Transport --> Endpoint
Endpoint --> Service
假如我们要实现一个服务， 提供字符串的大小写转换和计数功能。
在service中编写功能逻辑：
import "context"
// interface是抽象的关键
type StringService interface {
Uppercase(string) (string, error)
Count(string) int
}
type stringService struct{}
func (stringService) Uppercase(s string) (string, error) {
if s == "" {
return "", ErrEmpty
}
return strings.ToUpper(s), nil
}
func (stringService) Count(s string) int {
return len(s)
}
var ErrEmpty = errors.New("Empty string")
然后显示声明request和response的结构体：
我觉得显示声明是必要的， 因为这样可以让我们更清晰的知道我们的服务提供了什么功能， 以及对应的输入输出是什么。
type uppercaseRequest struct {
S string `json:"s"`
}
type uppercaseResponse struct {
V string `json:"v"`
Err string `json:"err,omitempty"`
}
type countRequest struct {
S string `json:"s"`
}
type countResponse struct {
V int `json:"v"`
}
这时功能已经有了， 但是不可以直接用service提供服务， 因为样会打破抽象， 所以需要定一个endpoint作为中间层, endpoint的定义是这样的：
可以看见request和response都是interface。
type Endpoint func(ctx context.Context, request interface{}) (response interface{}, err error)
定义一个我们自己的endpoint：
每个函数都需要去做转换， 是不是已经感觉到麻烦了？
import (
"context"
"github.com/go-kit/kit/endpoint"
)
func makeUppercaseEndpoint(svc StringService) endpoint.Endpoint {
return func(_ context.Context, request interface{}) (interface{}, error) {
req := request.(uppercaseRequest)
v, err := svc.Uppercase(req.S)
if err != nil {
return uppercaseResponse{v, err.Error()}, nil
}
return uppercaseResponse{v, ""}, nil
}
}
func makeCountEndpoint(svc StringService) endpoint.Endpoint {
return func(_ context.Context, request interface{}) (interface{}, error) {
req := request.(countRequest)
v := svc.Count(req.S)
return countResponse{v}, nil
}
}
目前已经抽象好了我们的服务， 接下来需要把它暴露出去， 那么就需要transport了：
其实也可用mvc的模式去理解， 只不过抽象带来的复杂度比较高～
import (
"context"
"encoding/json"
"log"
"net/http"
httptransport "github.com/go-kit/kit/transport/http"
)
func main() {
svc := stringService{}
uppercaseHandler := httptransport.NewServer(
makeUppercaseEndpoint(svc),
decodeUppercaseRequest,
encodeResponse,
)
countHandler := httptransport.NewServer(
makeCountEndpoint(svc),
decodeCountRequest,
encodeResponse,
)
http.Handle("/uppercase", uppercaseHandler)
http.Handle("/count", countHandler)
log.Fatal(http.ListenAndServe(":8080", nil))
}
// 去解码请求， 其实相当于mvc中的controller
func decodeUppercaseRequest(_ context.Context, r *http.Request) (interface{}, error) {
var request uppercaseRequest
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
return nil, err
}
return request, nil
}
func decodeCountRequest(_ context.Context, r *http.Request) (interface{}, error) {
var request countRequest
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
return nil, err
}
return request, nil
}
func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
return json.NewEncoder(w).Encode(response)
}
那如何定义一个中间件呢？ 那可真是杨宗纬的《洋葱》啊～
func loggingMiddleware(logger log.Logger) Middleware {
return func(next endpoint.Endpoint) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (interface{}, error) {
logger.Log("msg", "calling endpoint")
defer logger.Log("msg", "called endpoint")
return next(ctx, request)
}
}
}
// 然后在transport中使用包裹后的endpoint
var uppercase endpoint.Endpoint
uppercase = makeUppercaseEndpoint(svc)
uppercase = loggingMiddleware(log.With(logger, "method", "uppercase"))(uppercase)
也可以用结构体的方式:
其实所有框架的实现逻辑都差不多， 只不过go-kit更多的暴露给了用户， 其他的框架将其隐藏在了自己的实现中。
type loggingMiddleware struct {
logger log.Logger
next StringService
}
func (mw loggingMiddleware) Uppercase(s string) (output string, err error) {
defer func(begin time.Time) {
mw.logger.Log(
"method", "uppercase",
"input", s,
"output", output,
"err", err,
"took", time.Since(begin),
)
}(time.Now())
output, err = mw.next.Uppercase(s)
return
}
func (mw loggingMiddleware) Count(s string) (n int) {
defer func(begin time.Time) {
mw.logger.Log(
"method", "count",
"input", s,
"n", n,
"took", time.Since(begin),
)
}(time.Now())
n = mw.next.Count(s)
return
}
最终的目录结构可能是这个样子：
.
├── README.md
├── cmd
│ ├── addcli
│ │ └── addcli.go
│ └── addsvc
│ └── addsvc.go
├── pb
│ ├── addsvc.pb.go
│ ├── addsvc.proto
│ └── compile.sh
└── pkg
├── addendpoint
│ ├── middleware.go
│ └── set.go
├── addservice
│ ├── middleware.go
│ └── service.go
└── addtransport
├── grpc.go
├── http.go
└── jsonrpc.go
如果你赞同go-kit的这种理念， 但是又觉得麻烦， 可以看看https://github.com/nytimes/gizmo这个项目。他封装了一些复杂的、繁琐的，在go-kit中需要自己实现的逻辑。
【gotalk】 一个使用tcp实现的双向通信框架
github: https://github.com/rsms/gotalk
这个框架也挺有意思, 官方给的使用示例是这样的:
type GreetIn struct {
Name string `json:"name"`
}
type GreetOut struct {
Greeting string `json:"greeting"`
}
// 服务端代码
func server() {
gotalk.Handle("greet", func(in GreetIn) (GreetOut, error) {
return GreetOut{"Hello " + in.Name}, nil
})
if err := gotalk.Serve("tcp", "localhost:1234"); err != nil {
log.Fatalln(err)
}
}
// 客户端代码
func client() {
s, err := gotalk.Connect("tcp", "localhost:1234")
if err != nil {
log.Fatalln(err)
}
greeting := &GreetOut{}
if err := s.Request("greet", GreetIn{"Rasmus"}, greeting); err != nil {
log.Fatalln(err)
}
log.Printf("greeting: %+v\n", greeting)
s.Close()
}
乍一看， 没有什么特殊的地方嘛。 他的特别之处在于它数据传输的方式：
Gotalk采用双向和并发通信, 他并不是基于http或者grpc这些现有的应用层协议，而是使用tcp为基础， 自己实现一套通信规则。
Gotalk协议的传输格式是基于ASCII的。例如，一条代表操作请求的协议消息：r0001005hello00000005world。 正是因为这种特性， 它可以轻松实现一个websocket服务：
而且gotalk还有对应的js客户端…
package main
import (
"net/http"
"github.com/rsms/gotalk"
)
func main() {
gotalk.Handle("echo", func(in string) (string, error) {
return in, nil
})
// 注册websocket服务
http.Handle("/gotalk/", gotalk.WebSocketHandler())
http.Handle("/", http.FileServer(http.Dir(".")))
err := http.ListenAndServe("localhost:1234", nil)
if err != nil {
panic(err)
}
}
消息最终会被转换为字节进行传输，消息包含自己的载荷类型、操作类型、载荷长度和载荷本身等。
比如单次请求得内容可能是这样的：
+------------------ SingleRequest
| +---------------- requestID "0001"
| | +--------- operation "echo" (text3Size 4, text3Value "echo")
| | | +- payloadSize 25
| | | |
r0001004echo00000019{"message":"Hello World"}
响应是这样的：
+------------------ SingleResult
| +---------------- requestID "0001"
| | +-------- payloadSize 25
| | |
R000100000019{"message":"Hello World"}
也可以发起流式的请求：
+------------------ StreamRequest
| +---------------- requestID "0001"
| | +--------- operation "echo" (text3Size 4, text3Value "echo")
| | | +- payloadSize 11
| | | |
s0001004echo0000000b{"message":
+------------------ streamReqPart
| +---------------- requestID "0001"
| | +-------- payloadSize 14
| | |
p00010000000e"Hello World"}
+------------------ streamReqPart
| +---------------- requestID "0001"
| | +-------- payloadSize 0 (end of stream)
| | |
p000100000000
流式的的响应:
+------------------ StreamResult (1st part)
| +---------------- requestID "0001"
| | +-------- payloadSize 11
| | |
S00010000000b{"message":
+------------------ StreamResult (2nd part)
| +---------------- requestID "0001"
| | +-------- payloadSize 14
| | |
S00010000000e"Hello World"}
+------------------ StreamResult
| +---------------- requestID "0001"
| | +-------- payloadSize 0 (end of stream)
| | |
S000100000000
【goa】 一个有代码生成器并且使用简单编码的方式来描述功能的框架
github: [goa](https://github.com/goadesign/goa)
这个项目理念上其实与go-kit比较类似，但是他没有transport的概念， 而且因为有生成工具的存在， 所以使用起来比较方便，省掉了跟多重复的编码工作。
它可以使用一段go代码来描述服务的所要实现的功能， 生成工具（goa）以此来生成服务代码。
mkdir -p calcsvc/design
cd calcsvc
go mod init calcsvc
比如要生成一个实现计算器功能的服务, 需要创建一个design/design.go:
package design
import . "goa.design/goa/v3/dsl"
// 描述这个api的属性信息
var _ = API("calc", func() {
Title("Calculator Service")
Description("HTTP service for multiplying numbers, a goa teaser")
Server("calc", func() {
Host("localhost", func() { URI("http://localhost:8088") })
})
})
// 描述服务需要实现的功能细节
var _ = Service("calc", func() {
Description("The calc service performs operations on numbers")
// 一个名字为"multiply"的方法
Method("multiply", func() {
// 方法接收的载荷
Payload(func() {
// 一个int类型的a字段
Attribute("a", Int, "Left operand")
// 一个int类型的b字段
Attribute("b", Int, "Right operand")
// Required表示这个字段是必须的
Required("a", "b")
})
// 返回结果是一个int
Result(Int)
// 这提供http服务
HTTP(func() {
// GET请求的路径，并从路径中获取a和b的值
GET("/multiply/{a}/{b}")
// 返回状态码
Response(StatusOK)
})
})
})
使用命令生成服务代码：
goa gen calcsvc/design
会生成如下的目录结构:
gen
├── calc
│ ├── client.go
│ ├── endpoints.go
│ └── service.go
└── http
├── calc
│ ├── client
│ │ ├── cli.go
│ │ ├── client.go
│ │ ├── encode_decode.go
│ │ ├── paths.go
│ │ └── types.go
│ └── server
│ ├── encode_decode.go
│ ├── paths.go
│ ├── server.go
│ └── types.go
├── cli
│ └── calc
│ └── cli.go
├── openapi.json
└── openapi.yaml
7 directories, 15 files
目前生成的代码还不能直接使用，可以理解为是一些抽象出来的框架， 需要我们自己实现服务的功能。
运行生成示例代码的命令, 会根据定义生成程序入口和功能代码的文件:
goa example calcsvc/design
运行后在目录中会多出以下几个文件：
calc.go
cmd/calc-cli/http.go
cmd/calc-cli/main.go
cmd/calc/http.go
cmd/calc/main.go
calc.go是我们的功能实现文件:
package calcapi
import (
calc "calcsvc/gen/calc"
"context"
"log"
)
// calc service example implementation.
// The example methods log the requests and return zero values.
type calcsrvc struct {
logger *log.Logger
}
// NewCalc returns the calc service implementation.
func NewCalc(logger *log.Logger) calc.Service {
return &calcsrvc{logger}
}
// Multiply implements multiply.
func (s *calcsrvc) Multiply(ctx context.Context, p *calc.MultiplyPayload) (res int, err error) {
// 填写自己的功能实现
s.logger.Print("calc.multiply")
return
}
然后就可运行服务/客户端了：
# 服务端
cd cmd/calc
go build
./calc
[calcapi] 16:10:47 HTTP "Multiply" mounted on GET /multiply/{a}/{b}
[calcapi] 16:10:47 HTTP server listening on "localhost:8088"
# 客户端
cd calcsvc/cmd/calc-cli
go build
./calc-cli calc multiply -a 2 -b 3
6
其他的一些框架
一些功能完备，开发成本较低的框架：
- go-micro 自带认证、配置热加载、服务发现、多种通信协议等等
- kratos 通过protobuf的定义实现http/grpc服务，支持多种config源，支持trancing等等，并且使用Wire 进行依赖注入。
- go-zero 功能十分全面， 但是使用起来比较复杂，好在文档丰富，并且有自己的生成工具，
框架其实非常多了， 上面列举的三个是star数量比较多的， 你也可以在github上使用 language:go microservices的方式搜索， 会有很多的结果。
