# go-kit-study

**Repository Path**: g_night/go-kit-study

## Basic Information

- **Project Name**: go-kit-study
- **Description**: 用于go-kit学习
- **Primary Language**: Unknown
- **License**: MIT
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2021-11-11
- **Last Updated**: 2022-05-25

## Categories & Tags

**Categories**: Uncategorized

**Tags**: demo

## README

# go-kit-study

#### 介绍
用于go-kit学习

#### 软件架构

Go kit 是一个微服务工具包集合。利用它提供的额API和规范可以创建健壮、可维护性高的微服务体系

## Go-kit的三层架构

```bash
1、Service 
具体业务逻辑，就写核心逻辑即可

2、EndPoint
定义Request、Response格式，中间件嵌套，调用服务，返回结果

3、Transport
主要负责与HTTP、gRPC、thrift等相关逻辑
```

这里展示一个demo入门：

**Service层：**

```go
package service

// 具体业务逻辑，就写核心逻辑即可

type IUserService interface {
	GetName(id int) string
}

type UserService struct{}

func (e *UserService) GetName(id int) string {
	if id == 0 {
		return "no.0"
	}
	return "no.other"
}
```

**Endpoint层：**

```go
package endpoint

import (
	"context"
	"github.com/go-kit/kit/endpoint"
	"go-kit-demo/service"
)

// 定义Request、Response格式，中间件嵌套，调用服务，返回结果

type UserRequest struct {
	Id int `json:"id"`
}

type UserResponse struct {
	Name string `json:"name"`
}

// 核心endpoint，调用service
// 初始化endpoint
func GenerateUserEndpoint(userService service.IUserService) endpoint.Endpoint {

	// 接收context、request处理，调用service，完成response响应
	return func(ctx context.Context, request interface{}) (response interface{}, err error) {
		// 转换 request -> UserRequest
		r := request.(UserRequest)

		// 调用 service
		name := userService.GetName(r.Id)

		// 返回 response
		return UserResponse{name}, nil
	}
}
```

**transport层：**

```go
package transport

import (
	"context"
	"encoding/json"
	"errors"
	"go-kit-demo/endpoint"
	"net/http"
	"strconv"
)

// 主要负责与HTTP、gRPC、thrift等相关逻辑

// 获取参数封装
// DecodeRequest 解码后封装至 EndPoint.Request
func DecodeUserRequest(c context.Context, r *http.Request) (interface{}, error) {
	if id := r.URL.Query().Get("id"); id != "" {
		uid, err := strconv.Atoi(id)
		if err != nil {
			return nil, errors.New("参数需要数字")
		}
		return endpoint.UserRequest{uid}, nil
	}

	return nil, errors.New("缺少参数")
}

// 返回参数
// EncodeResponse 响应封装成 EndPoint.Response 结构体即可
func EncodeUserResponse(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)
}
```

<hr/>

**main服务启动：**

1. 生成核心service
2. 注入service，初始化endpoint
3. 发布服务

```go
package main

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

// 服务发布
func main() {

	// 1. 生成核心service
	userService := service.UserService{}

	// 2. 注入service，初始化endpoint
	endpoint := endpoint.GenerateUserEndpoint(&userService)

	// 3. 发布服务
	serverHandle := kithttp.NewServer(endpoint, transport.DecodeUserRequest, transport.EncodeUserResponse)
	http.ListenAndServe(":8080", serverHandle)
}
```