go kit (3)

我们进今天开始,构建项目

一:我们先将项目的初始架构,搞起来
在这里插入图片描述
如上图所示,先创建一些空的go文件,文件名可以随便起,但是文件夹的名字最好先用这么写,因为一开始自己对kit的不是完全理解,包名在此还有一定的提示作用

二: 我们先从最基本的service开始构建

codeService.go

import "fmt"

type User struct {
}

func (u *User) GetUserName(uid int) string {

	fmt.Println("接收到前端传来的参数:",uid)

	return "hello git"

}

先来一个最简单的

三:在完善endpoint层

import (
	"context"
	"errors"
	"github.com/go-kit/kit/endpoint"
	myMux "github.com/gorilla/mux"
	"goKit/service"
	"net/http"
)

func GenVcEndpoint() endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (response interface{}, err error){
		r := request.(*http.Request)
		vars := myMux.Vars(r)
		if uid, ok := vars["uid"]; ok {
			user := service.User{}
			return user.GetUserName(uid),nil
		}
		return nil,errors.New("出错了")

	}
}

注意:我们在此使用的是gorilla/mux 作为路由

四:我们继续,完善transport层

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

func DecodeVcRequest(_ context.Context, r *http.Request) (interface{}, error) {
	return r, nil
}

func EncodeVcResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
	return json.NewEncoder(w).Encode(response)
}

注:在此,我们是用最简单明了的方式,定义入参解析以及出参定义 - 就是什么也不操作,但是kit框架需要

五:那现在,我们在main函数中,将服务启动起来

import (
	goKitHttp "github.com/go-kit/kit/transport/http"
	"github.com/gorilla/mux"
	. "goKit/endpoint"
	. "goKit/transport"
	"net/http"
	"os"
)

func main() {

	r := mux.NewRouter()

	getCode := goKitHttp.NewServer(GenVcEndpoint(),
		DecodeVcRequest, EncodeVcResponse,)
	r.Methods("Get").Path(`/getName/{uid:\d+}`).Handler(getCode)

	 err :=http.ListenAndServe(":9090", r)
	 if err != nil{
	 	os.Exit(-1)
	 }

}
注:最简单直接的配置,将服务启动

六: 测试
浏览器请求,以及返回值

在这里插入图片描述

后台输出:
在这里插入图片描述
七:到此,我们kit的基础架构就完成了,剩下的就是一点点的去继续完善了

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是一个基于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、付费专栏及课程。

余额充值