什么是 Go kit?
Go是一種很棒的通用語言，但是微服務需要一定量的專業支持， RPC安全性，系統可觀察性，基礎結構集成甚至程式設計，Go kit 填補了標準庫留下的空白，并使 Go 成為在任何組織中撰寫微服務的一流語言
下面基于go-kit實作用戶微服務，用戶的登陸，注冊和獲取用戶資訊，使用jwt方式來加密和解碼，本文事例比較簡單，主要是實作微服務和理解微服務開發，通信使用grpc服務來編碼和解碼
涉及到技術的如下：
1.grpc
2.consul 服務注冊與發現
3.golang/rate 服務限流
4.中間價
5.身份驗證jwt
6.ctx context.Context 背景關系傳遞全域引數
代碼結構如下：
1.首先定義proto檔案
我們需要實作三個方法分別是 RegistAccount，LoginAccount，GetUserInfoByToken 分別是注冊，登陸和通過token獲取用戶，和其他請求體，相信代碼如下：
syntax = "proto3";
package pb;
service UserServiceExt {
// 注冊用戶
rpc RegistAccount(RegistAccountReq) returns(RegistAccountRsp) {}
// 用戶登錄
rpc LoginAccount(LoginAccountReq) returns(LoginAccountRsp) {}
// 通過token 獲取用戶資訊
rpc GetUserInfoByToken(GetUserInfoByTokenRequest) returns(GetUserInfoByTokenResponse) {}
}
message RegistAccountReq {
string email = 1 ;
string userName = 2 ;
string password = 3 ;
}
message RegistAccountRsp {
int64 code = 1;
}
message LoginAccountReq {
string email = 1 ;
string password = 2 ;
}
message UserInfo {
int64 user_id=1;
string userName=2;
string email=3;
string phone=4;
}
message LoginAccountRsp {
int64 code = 1;
string token = 2;
string uid = 3;
}
message GetUserInfoByTokenRequest {
string token=1;
}
message GetUserInfoByTokenResponse {
int64 code=1;
UserInfo userInfo=3;
}定義好ptoto 檔案后 使用ptotoc工具生產服務端和客服端代碼 我是放在/common/pb檔案下，你可以定義你自己的生成路徑：protoc --proto_path=./pb --go_out=plugins=grpc:./common/pb ./pb/*.proto
2.接下來我們來實作介面
在 service 檔案下定義 并實作介面，詳細代碼如下
package service
import (
"context"
"fmt"
"go.uber.org/zap"
"mSystem/src/common/db"
"mSystem/src/common/errors"
"mSystem/src/common/pb"
"mSystem/src/utils"
)
type UserService interface {
RegistAccount(ctx context.Context, req *pb.RegistAccountReq) (*pb.RegistAccountRsp, error)
LoginAccount(ctx context.Context, req *pb.LoginAccountReq) (*pb.LoginAccountRsp, error)
GetUserInfoByToken(ctx context.Context, req *pb.GetUserInfoByTokenRequest) (*pb.GetUserInfoByTokenResponse, error)
}
type baseServer struct {
logger *zap.Logger
}
func NewUserService(log *zap.Logger) UserService {
var server UserService
server = &baseServer{
logger: log,
}
//server = NewLogMiddlewareServer(log)(server)
return server
}
// 賬戶注冊
func (u baseServer) RegistAccount(ctx context.Context, req *pb.RegistAccountReq) (*pb.RegistAccountRsp, error) {
userName := req.UserName
password := req.Password
email := req.Email
user, err := db.SelectUserByEmail(email)
if err != nil {
u.logger.Error("error", zap.Error(err))
return &pb.RegistAccountRsp{
Code: -1,
}, errors.ErrorUserFailed
}
if user != nil {
return &pb.RegistAccountRsp{
Code: -1,
}, errors.ErrorUserAlready
}
err = db.InsertUser(userName, password, email)
if err != nil {
u.logger.Error("error", zap.Error(err))
return &pb.RegistAccountRsp{
Code: -1,
}, errors.ErrorUserFailed
}
return &pb.RegistAccountRsp{
Code: 0,
}, nil
}
func (u baseServer) LoginAccount(ctx context.Context, req *pb.LoginAccountReq) (*pb.LoginAccountRsp, error) {
email := req.Email
password := req.Password
user, err := db.SelectUserByPasswordName(email, password)
if err != nil {
u.logger.Error("error", zap.Error(err))
return &pb.LoginAccountRsp{
}, errors.ErrorUserFailed
}
if user == nil {
return &pb.LoginAccountRsp{}, errors.ErrorUserLoginFailed
}
// jwt 加密
Token, err := utils.CreateJwtToken(user.UserName, int(user.UserId))
return &pb.LoginAccountRsp{
Token: Token,
Code: 0,
Uid: fmt.Sprint(ctx.Value(ContextReqUUid)),
}, err
}
func (u baseServer) GetUserInfoByToken(ctx context.Context, req *pb.GetUserInfoByTokenRequest) (*pb.GetUserInfoByTokenResponse, error) {
token := req.Token
if token == "" {
return &pb.GetUserInfoByTokenResponse{
Code: -1,
}, errors.ErrorTokenEmpty
}
MapClaims, err := utils.ParseToken(token)
fmt.Println("MapClaims", MapClaims, MapClaims["DcId"], MapClaims["Name"],err)
if err != nil {
return &pb.GetUserInfoByTokenResponse{
Code: -2,
}, errors.FormatError("user",err.Error())
}
user_id := MapClaims["DcId"].(float64)
username := MapClaims["Name"].(string)
fmt.Println("user-info", user_id, username)
user_info, e := db.SelectUserById(user_id, username)
if e != nil {
return &pb.GetUserInfoByTokenResponse{
Code: -2,
}, errors.ErrorUserLoginFailed
}
return &pb.GetUserInfoByTokenResponse{
Code: 0,
UserInfo: &pb.UserInfo{
UserId: user_info.UserId,
UserName: user_info.UserName,
Email: user_info.Email,
Phone: user_info.Phone,
},
}, nil
}
3，接下來實作endpoint ，它是微服務內部的橋梁，它把用戶的請求的引數，組裝成grpc需要的資料型別，再轉發到我們具體的服務實作，在endpoint 可以限流，添加中間價等操作,代碼如下
package endpoint
import (
"context"
"github.com/go-kit/kit/endpoint"
"go.uber.org/zap"
"golang.org/x/time/rate"
pb "mSystem/src/common/pb"
"mSystem/src/user/encode"
"mSystem/src/user/service"
)
type RegistRequest struct {
Email string `json:"email"`
UserName string `json:"userName"`
Password string `json:"password"`
}
type RegistResponse struct {
Email string `json:"email"`
UserName string `json:"userName"`
Password string `json:"password"`
}
type LoginRequest struct {
Email string `json:"email"`
Password string `json:"password"`
}
type GetTokenRequest struct {
Token string `json:"token"`
}
// y有幾個函式就定義幾個 endpoint
type Endpoints struct {
RegistAccount endpoint.Endpoint
LoginAccount endpoint.Endpoint
GetUserInfoByToken endpoint.Endpoint
}
func NewEndpoint(s service.UserService, log *zap.Logger, limit *rate.Limiter) Endpoints {
var RegistEndPoint endpoint.Endpoint
RegistEndPoint = MakeRegistEndPoint(s)
var LoginEndPoint endpoint.Endpoint
LoginEndPoint = MakeLoginEndPoint(s)
LoginEndPoint = LoggingMiddleware(log)(LoginEndPoint) // 登陸中間價
LoginEndPoint = NewGolangRateAllowMiddleware(limit)(LoginEndPoint) //限流
var GetUserInfoByToken endpoint.Endpoint
GetUserInfoByToken = MakeTokenEndPoint(s)
return Endpoints{RegistAccount: RegistEndPoint, LoginAccount: LoginEndPoint, GetUserInfoByToken: GetUserInfoByToken}
}
// 實作請求轉發
func MakeRegistEndPoint(s service.UserService) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (response interface{}, err error) {
req := request.(*RegistRequest) / 獲取請求引數
val, err := s.RegistAccount(ctx, &pb.RegistAccountReq{ // 組裝請求引數到servce
Email: req.Email,
Password: req.Password,
UserName: req.UserName,
})
return encode.Response{
Error: err,
Data: val,
}, err
}
}
// 實作請求轉發
func MakeLoginEndPoint(s service.UserService) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (response interface{}, err error) {
req := request.(*LoginRequest) /// 獲取請求引數
val, err := s.LoginAccount(ctx, &pb.LoginAccountReq{ //組裝請求引數到servce
Email: req.Email,
Password: req.Password,
})
return encode.Response{
Error: err,
Data: val,
}, err
}
}
func MakeTokenEndPoint(s service.UserService) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (response interface{}, err error) {
req := request.(*GetTokenRequest) /// 獲取請求引數
val, err := s.GetUserInfoByToken(ctx, &pb.GetUserInfoByTokenRequest{
Token: req.Token,
})
return encode.Response{
Error: err,
Data: val,
}, err
}
}
4.完成了具體服務實作和endpoint，接下來就可以把我們的服務暴露給外呼叫了，transport的任務就是暴露介面給外部使用，詳細代碼如下：
package transport
import (
"context"
"encoding/json"
"errors"
"fmt"
"github.com/go-kit/kit/log"
kithttp "github.com/go-kit/kit/transport/http"
"github.com/gorilla/mux"
uuid "github.com/satori/go.uuid"
"go.uber.org/zap"
"io/ioutil"
"mSystem/src/user/encode"
"mSystem/src/user/endpoint"
"net/http"
)
var (
ErrorBadRequest = errors.New("invalid request parameter")
)
const ContextReqUUid = "req_uuid"
// MakeHttpHandler make http handler use mux
func MakeHttpHandler(ctx context.Context, endpoints endpoint.Endpoints, logger log.Logger) http.Handler {
r := mux.NewRouter()
options := []kithttp.ServerOption{
kithttp.ServerErrorLogger(logger),
kithttp.ServerErrorEncoder(kithttp.DefaultErrorEncoder),
kithttp.ServerErrorEncoder(func(ctx context.Context, err error, w http.ResponseWriter) {
logger.Log(fmt.Sprint(ctx.Value(ContextReqUUid)))
w.WriteHeader(http.StatusOK)
json.NewEncoder(w).Encode(err)
}),
kithttp.ServerBefore(func(ctx context.Context, request *http.Request) context.Context {
UUID := uuid.NewV5(uuid.Must(uuid.NewV4(),nil), "req_uuid").String()
logger.Log("給請求添加uuid", zap.Any("UUID", UUID))
ctx = context.WithValue(ctx, ContextReqUUid, UUID)
return ctx
}),
}
// 暴露具體的 endpoint
r.Methods("POST").Path("/register").Handler(kithttp.NewServer(
endpoints.RegistAccount,
decodeRegisterRequest, // 請求引數
encode.JsonResponse,
options...,
))
r.Methods("POST").Path("/login").Handler(kithttp.NewServer(
endpoints.LoginAccount,
decodeLoginRequest, // 請求引數
encode.JsonResponse,
options...,
))
r.Methods("POST").Path("/userInfo").Handler(kithttp.NewServer(
endpoints.GetUserInfoByToken,
decodeGetTokenRequest, // 請求引數
encode.JsonResponse,
options...,
))
return r
}
// decodeStringRequest decode request params to struct
func decodeRegisterRequest(ctx context.Context, r *http.Request) (interface{}, error) {
body, err := ioutil.ReadAll(r.Body)
if err != nil {
fmt.Printf("read body err, %v\n", err)
return nil, err
}
println("json:", string(body))
var rhe endpoint.RegistRequest
if err = json.Unmarshal(body, &rhe); err != nil {
fmt.Printf("Unmarshal err, %v\n", err)
return nil, err
}
return &endpoint.RegistRequest{
Email: rhe.Email,
UserName: rhe.UserName,
Password: rhe.Password,
}, nil
}
// 注冊 decodeStringRequest decode request params to struct
func decodeLoginRequest(ctx context.Context, r *http.Request) (interface{}, error) {
body, err := ioutil.ReadAll(r.Body)
if err != nil {
fmt.Printf("read body err, %v\n", err)
return nil, err
}
println("json:", string(body))
var rhe endpoint.LoginRequest
if err = json.Unmarshal(body, &rhe); err != nil {
fmt.Printf("Unmarshal err, %v\n", err)
return nil, err
}
return &endpoint.LoginRequest{
Email: rhe.Email,
Password: rhe.Password,
}, nil
}
func decodeGetTokenRequest(ctx context.Context, r *http.Request) (interface{}, error) {
body, err := ioutil.ReadAll(r.Body)
if err != nil {
fmt.Printf("read body err, %v\n", err)
return nil, err
}
println("json:", string(body))
var rhe endpoint.GetTokenRequest
if err = json.Unmarshal(body, &rhe); err != nil {
fmt.Printf("Unmarshal err, %v\n", err)
return nil, err
}
return &endpoint.GetTokenRequest{
Token: rhe.Token,
}, nil
}可以看到 我們暴露了3個地址分別是 /register ，/login，/userInfo 也就是我們之前實作的3個介面，大功告成了 接下來實作main函式，啟動http和grpc服務，就可以訪問到我們的服務了
main 函式如下：
package main
import (
"context"
"flag"
"fmt"
"github.com/go-kit/kit/log"
"golang.org/x/time/rate"
"google.golang.org/grpc"
dbconfig "mSystem/src/common/db"
"mSystem/src/common/pb"
register "mSystem/src/user/compone"
edpts "mSystem/src/user/endpoint"
"mSystem/src/user/service"
transport "mSystem/src/user/transport"
"mSystem/src/utils"
"net"
"net/http"
"os"
"os/signal"
"syscall"
)
func main() {
var (
consulHost = flag.String("consul.host", "127.0.0.1", "consul ip address")
consulPort = flag.String("consul.port", "8500", "consul port")
serviceHost = flag.String("service.host", "localhost", "service ip address")
servicePort = flag.String("service.port", "9001", "service port")
grpcAddr = flag.String("grpc", ":8001", "gRPC listen address.")
)
flag.Parse()
ctx := context.Background()
errChan := make(chan error)
var logger log.Logger
{
logger = log.NewLogfmtLogger(os.Stderr)
logger = log.With(logger, "ts", log.DefaultTimestampUTC)
logger = log.With(logger, "caller", log.DefaultCaller)
}
// 介面定義
// 具體服務實作了
svc := service.NewUserService(utils.GetLogger())
//創建Endpoint
utils.NewLoggerServer()
golangLimit := rate.NewLimiter(10, 1)
endpoint := edpts.NewEndpoint(svc,utils.GetLogger(),golangLimit)
//創建http.Handler
r := transport.MakeHttpHandler(ctx, endpoint, logger)
//創建注冊物件
registar := register.Register(*consulHost, *consulPort, *serviceHost, *servicePort, logger)
// http 服務
go func() {
fmt.Println("Http Server start at port:" + *servicePort)
//啟動前執行注冊
registar.Register()
errChan <- http.ListenAndServe(":"+*servicePort, r)
}()
// 資料庫連接初始化，，，，，，
dbconfig.InitDB()
//grpc server
go func() {
fmt.Println("grpc Server start at port" + *grpcAddr)
listener, err := net.Listen("tcp", *grpcAddr)
if err != nil {
errChan <- err
return
}
baseServer := grpc.NewServer()
pb.RegisterUserServiceExtServer(baseServer, svc)
errChan <- baseServer.Serve(listener)
}()
go func() {
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)
errChan <- fmt.Errorf("%s", <-c)
}()
error := <-errChan
//服務退出取消注冊
registar.Deregister()
fmt.Println(error)
}需要主要的是 服務發現我們使用了默認的8085埠，在本地訪問8085埠 就可以看到注冊的服務事例，9091埠提供http服務，也是服務的入口，8001埠開啟grpc服務，使用golang.org/x/time/rate 來實作簡單的限流功能，通過
Register方法把微服務注冊到consul上，
dbconfig.InitDB() 初始化資料庫連接，使用mysql來存盤資料
最后是啟動服務即可
啟動成功如下：
代碼：https://github.com/xulei1931/mSystem
轉載請註明出處，本文鏈接：https://www.uj5u.com/qukuanlian/230352.html
標籤：區塊鏈
上一篇：區塊鏈技術應用落地下的保險行業