2、go-kit三层结构

go-kit和MVC一样也有三层结构endpoint，service, transport，通过这三层结构来实现，接收一个请求，然后返回一个结果。

1.Transport

Transport处于该微服务的最上层，主要负责于HTTP, gRPC，thrift等相关的逻辑，负责解析请求，并且调用endpoint来处理请求

2.Endpoint

endpoint属于客户端和服务端的转接器，他定义了request和response的格式，上层给Transport调用来处理请求，下层链接Service将Service所返回的结果转换成request需要的格式

3.Service

这里就是我们的业务类、接口等相关信息存放

3、go-kit实例

// 项目结构

-| Server

----| server.go

-| EndPoint

----| endpoint.go

-| Transport

----| Transport.go

• main.go

3.1、Service

首先我们先写Server层业务类

package service

import "fmt"

//用于定义业务方法的接口
type IHelloService interface {
	Hello(name string) string
}

//用于实现上面定义的接口
type HelloService struct {
	//根据业务需求填充结构体
}

//实现上方定义的业务方法
func (h HelloService) Hello(name string) string {
	return fmt.Sprintf("Hello:%s", name)
}

3.2、EndPoint

endpoint的作用最简单的，对于一个从上层Transport传入的request，我们返回一个response，签名如下：

type EndPoint func(request) response

具体代码实现

package endpoint

import (
	"context"
	"github.com/go-kit/kit/endpoint"
	"github.com/mwqnice/go-kit-demo/service"
)
// Hello 业务使用的请求和响应格式
//HelloRequest 请求格式
type HelloRequest struct {
	Name string `json:"name"`
}

//HelloResponse响应格式
type HelloResponse struct {
	Reply string `json:"reply"`
}

//创建构造函数hello方法的业务处理
// MakeHelloServiceEndPorint 创建关于业务的构造函数
// 传入 Service/HelloService.go 定义的相关业务接口
// 返回 go-kit/endpoint.Endpoint (实际上就是一个函数签名)
func MakeHelloServiceEndPorint(s service.IHelloService) endpoint.Endpoint {
	// 这里使用闭包,可以在这里做一些中间件业务的处理
	return func(ctx context.Context, request interface{}) (response interface{}, err error){
		// request 是在对应请求来时传入的参数(这里的request 实际上是等下我们要将的Transport中一个decode函数中处理获得的参数)
		// 这里进行以下断言
		r, ok := request.(HelloRequest)
		if !ok {
			return HelloResponse{}, nil
		}
		// 这里实际上就是调用我们在Service/HelloService.go中定义的业务逻辑
		// 我们拿到了 Request.Name 那么我们就可以调用我们的业务 service.IHelloService 中的方法来处理这个数据并返回
		// 具体的业务逻辑具体定义....
		return HelloResponse{Reply: s.Hello(r.Name)}, nil
		// response 这里返回的response 可以返回任意的 不过根据规范是要返回我们刚才定义好的返回对象
	}
}

3.3、Transport

package transport

import (
	"context"
	"encoding/json"
	"errors"
	"github.com/mwqnice/go-kit-demo/endpoint"
	"net/http"
)
// Transport/transport.go 主要负责HTTP、gRpc、thrift等相关的逻辑

// 这里有两个关键函数
// DecodeRequest & EncodeResponse 函数签名是固定的哟
// func DecodeRequest(c context.Context, request *http.Request) (interface{}, error)
// func EncodeResponse(c context.Context, w http.ResponseWriter, response interface{}) error

// HelloDecodeRequest 解码 后封装至 EndPoint中定义的 Request格式中
func HelloDecodeRequest(c context.Context, request *http.Request) (interface{}, error) {
	// 这里主要就是通过 request 拿到对应的参数构造成在 EndPoint中定义的 Request结构体即可

	name := request.URL.Query().Get("name")
	if name == "" {
		return nil, errors.New("参数name不能为空")
	}
	return endpoint.HelloRequest{Name: name}, nil
}

//HelloEncodeResponse通过响应封装成Endpoint中定义的Response结构体
func HelloEncodeResponse(c context.Context, w http.ResponseWriter, response interface{}) error {
	//这里将Response返回成有效的json格式给http

	//设置请求头信息
	w.Header().Set("Content-Type", "application/json;charset=utf-8")

	//使用内置json包转换
	return json.NewEncoder(w).Encode(response)
}

3.4、服务启动

package main

import (
	httpTransport "github.com/go-kit/kit/transport/http"
	"github.com/mwqnice/go-kit-demo/endpoint"
	"github.com/mwqnice/go-kit-demo/service"
	"github.com/mwqnice/go-kit-demo/transport"
	"net/http"
)

// 服务发布
func main()  {
	//1.创建我们最开始定义的service/HelloService.go
	s := service.HelloService{}

	//2.在用endpoint/HelloEndpoint创建业务服务
	hello := endpoint.MakeHelloServiceEndPorint(s)

	//3.使用kit创建handler
	//传入业务服务 以及 定义的加密解密方法
	helloServer := httpTransport.NewServer(hello, transport.HelloDecodeRequest,transport.HelloEncodeResponse)

	// 4.使用http包启动服务
	go http.ListenAndServe("0.0.0.0:8000", helloServer)
	select {}
}

最重要的其实就在组装这个handler的地方serverHandler := httpTransport.NewServer(endPoint, transport.HelloDecodeRequest, transport.HelloEncodeResponse)这里我们将HelloDecodeRequest和endPoint一起传入进去，在NewServer内部会有自动将结果传入request的方法，然后打开ListenAndServer函数就可以开始监听8000窗口了默认是127.0.0.1:8000