Golang 微服务化 (2) - GoKit 构建简单应用

软件基础组成部分

Service, Endpoint, Transport

service 核心逻辑: interface 定义 + struct 实现
定义 Protobuffer 后自动生成或者手动定义请求返回数据结构
将请求返回数据结构封装成 Endpoint, 其中数据处理使用定义好的 service 核心逻辑
将 Endpoint 封装一层 http, grpc… 协议定义 Transport, 可以供外部请求连接访问

定义 service

service.go

import (
  "context"
  "errors"
  "strings"
)

type StringService interface {
  Uppercase(string) (string, error)
  Count(string) int
}

var ErrEmpty = errors.New("Empty String")

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)
}

定义 Protobuf 请求返回数据结构

编写 Protobuf 文件 service.proto

syntax = "proto3";

package main;

service StringHandler {
  rpc Uppercase(UppercaseRequest) returns (UppercaseResponse) {}
  rpc Count(CountRequest) returns (CountResponse) {}
}

message UppercaseRequest { string s = 1; }

message UppercaseResponse {
  string v = 1;
  string err = 2;
}

message CountRequest { string s = 1; }

message CountResponse {
  int64 v = 1;
  string err = 2;
}

使用 Protobuf 生成对应的 pb.go 文件

1	protoc service.proto --go_out=.

将 service 和 proto 封装成 Endpoint, 将 Endpoint 封装 http 协议构建 Http Transport

编写 transport.go 文件

import (
  "context"

  "github.com/go-kit/kit/endpoint"
)

// 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: v, Err: err.Error()}, nil
    }
    return UppercaseResponse{V: v, Err: ""}, 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: v, Err: ""}, nil
  }
}

// Http Transport

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)
}

启动 Http 服务加载 Http Transport

import (
  "context"
  "encoding/json"
  "log"
  "net/http"

  httptransport "github.com/go-kit/kit/transport/http"
)

func main() {
  svc := GetStringService()

  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))
}