Go - Kit 笔记 - 01 - Endpoint

Endpoint – 端点

位于github.com/go-kit/kit/endpoint/包,里面有一个endpoint.go文件,定义了Endpoint的相关接口。

//端点 -- go-kit的基本模块,实则是一个(函数类型)。
//定义好函数后,把函数注册到http或grpc上,就可以实现业务函数的回调。
type Endpoint func(ctx context.Context, request interface{}) (response interface{}, err error)

//空端点 -- 一个端点的实例,不做任何事情。测试用的。
func Nop(context.Context, interface{}) (interface{}, error) { return struct{}{}, nil }

//中间件 -- 其实就是装饰器、装饰者模式,用于装饰端点。
//go-kit所有对端点的操作都是由装饰器来完成的。
type Middleware func(Endpoint) Endpoint

//链 -- 中间件的辅助功能,按照传参顺序组合中间件。
//第一个中间件为最外层,最后一个为最内层
func Chain(outer Middleware, others ...Middleware) Middleware {
	return func(next Endpoint) Endpoint {
		for i := len(others) - 1; i >= 0; i-- { // reverse
			next = others[i](next)
		}
		return outer(next)
	}
}

//故障器 -- 没用过额。。
type Failer interface {
	Failed() error
}
以下是一个基于go-kit的简单例子: ``` package main import ( "context" "fmt" "net/http" "os" "os/signal" "syscall" "time" "github.com/go-kit/kit/log" "github.com/go-kit/kit/log/level" "github.com/go-kit/kit/transport/http" ) func main() { var logger log.Logger { logger = log.NewLogfmtLogger(os.Stderr) logger = log.With(logger, "timestamp", log.DefaultTimestampUTC) logger = log.With(logger, "caller", log.DefaultCaller) } var ( listenAddr = ":8080" ) var svc Service { svc = myService{} svc = loggingMiddleware(logger)(svc) } var uppercaseHandler http.Handler { uppercaseHandler = http.NewServer( makeUppercaseEndpoint(svc), decodeUppercaseRequest, encodeResponse, ) } http.Handle("/uppercase", uppercaseHandler) errs := make(chan error, 2) go func() { c := make(chan os.Signal, 1) signal.Notify(c, syscall.SIGINT, syscall.SIGTERM) errs <- fmt.Errorf("%s", <-c) }() go func() { level.Info(logger).Log("msg", "HTTP", "addr", listenAddr) errs <- http.ListenAndServe(listenAddr, nil) }() level.Error(logger).Log("exit", <-errs) } // Service provides a simple string manipulation service. type Service interface { Uppercase(context.Context, string) (string, error) } type myService struct{} func (myService) Uppercase(_ context.Context, s string) (string, error) { if s == "" { return "", ErrEmpty } return strings.ToUpper(s), nil } func makeUppercaseEndpoint(svc Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(uppercaseRequest) v, err := svc.Uppercase(ctx, req.S) if err != nil { return uppercaseResponse{v, err.Error()}, nil } return uppercaseResponse{v, ""}, nil } } type uppercaseRequest struct { S string `json:"s"` } type uppercaseResponse struct { V string `json:"v"` Err string `json:"err,omitempty"` } 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 encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error { return json.NewEncoder(w).Encode(response) } func loggingMiddleware(logger log.Logger) Middleware { return func(next Service) Service { return logmw{logger, next} } } type Middleware func(Service) Service type logmw struct { logger log.Logger next Service } func (mw logmw) Uppercase(ctx context.Context, s string) (output string, err error) { defer func(begin time.Time) { level.Info(mw.logger).Log( "method", "uppercase", "input", s, "output", output, "err", err, "took", time.Since(begin), ) }(time.Now()) output, err = mw.next.Uppercase(ctx, s) return } var ErrEmpty = errors.New("empty string") ``` 这个例子中定义了一个Service,提供了一个Uppercase方法,将输入字符串转换为大写。使用go-kit的httptransport将该方法封装成HTTP API。另外,还增加了一个loggingMiddleware,用于日志记录。 其中,Service、Endpoint和Middleware是go-kit的核心概念,用于实现微服务的组件化。Middleware用于对Service进行装饰,Endpoint用于将Service的方法封装成一个HTTP API,具有了统一的传输层约定。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值