gokit HTTP client/server 实例示例教程详解原创

gokit HTTP client/server 实例示例教程详解原创

服务端

package main

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

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

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

type xiaoquServiceInter interface {
	fangke(string) string
	query(string) int
}

type xiaoquService struct{}

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

type fangkeRsp struct {
	Result string `json:"result"`
}

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

type queryRsp struct {
	Num int `json:"num"`
}

func (xiaoquService) fangke(fangke string) string {
	fmt.Println("fangke:", fangke)
	return "come in"
}

func (xiaoquService) query(author string) int {
	fmt.Println("author ", author, " query.")
	return 100
}

//---------endpoint--------------------
func makeFangkeEndpoint(svr xiaoquServiceInter) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(fangkeReq)
		fmt.Println("req:", req)
		s := svr.fangke(req.Name)
		return fangkeRsp{s}, nil
	}
}

func makeQueryEndpoint(svr xiaoquServiceInter) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(queryReq)
		rsp := svr.query(req.Name)
		return queryRsp{rsp}, nil
	}
}

//---------transport------------------
func decodeFangkeRequest(ctx context.Context, r *http.Request) (interface{}, error) {
	var request fangkeReq
	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
		fmt.Println("decodeFangkeRequest decode err:", err)
		return nil, err
	}
	return request, nil
}

func decodeQueryRequest(ctx context.Context, r *http.Request) (interface{}, error) {
	request := queryReq{}
	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
		fmt.Println("decodeFangkeRequest decode err:", err)
		return nil, err
	}
	return request, nil
}

func encodeRsp(ctx context.Context, w http.ResponseWriter, response interface{}) error {
	return json.NewEncoder(w).Encode(&response)
}

// -------------------------------------------------------

func main() {
	svr := xiaoquService{}
	fangkeHandle := httptransport.NewServer(makeFangkeEndpoint(svr),
		decodeFangkeRequest,
		encodeRsp)
	queryHandle := httptransport.NewServer(makeQueryEndpoint(svr),
		decodeQueryRequest,
		encodeRsp)

	http.Handle("/fangke", fangkeHandle)
	http.Handle("/query", queryHandle)
	fmt.Println(http.ListenAndServe(":8000", nil))
	return
}

客户端

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"net/http"
	"net/url"

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

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

type fangkeRsp struct {
	Result string `json:"result"`
}

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

type queryRsp struct {
	Num int `json:"num"`
}

func encodeFangke(_ context.Context, request *http.Request, req interface{}) error {
	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(req); err != nil {
		fmt.Println("request json fail..", err.Error())
		return err
	}
	request.Body = ioutil.NopCloser(&buf)

	return nil
}

func decodeFangke(_ context.Context, rsp *http.Response) (response interface{}, err error) {
	if rsp.StatusCode != http.StatusOK {
		fmt.Println("rsp json fail.", err.Error())
		return nil, errors.New(rsp.Status)
	}

	var resp fangkeRsp
	err = json.NewDecoder(rsp.Body).Decode(&resp)

	return resp, err
}

func encodeQuery(_ context.Context, request *http.Request, req interface{}) error {
	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(req); err != nil {
		fmt.Println("request json fail..", err.Error())
		return err
	}
	request.Body = ioutil.NopCloser(&buf)

	return nil
}

func decodeQuery(_ context.Context, rsp *http.Response) (response interface{}, err error) {
	if rsp.StatusCode != http.StatusOK {
		fmt.Println("rsp json fail.", err.Error())
		return nil, errors.New(rsp.Status)
	}

	var resp queryRsp
	err = json.NewDecoder(rsp.Body).Decode(&resp)

	return resp, err
}

func fangkeClient() {
	target, err := url.Parse("http://127.0.0.1:8000/fangke")
	if err != nil {
		fmt.Println("err:", err.Error())
		return
	}

	cli := httptransport.NewClient(http.MethodGet, target, encodeFangke, decodeFangke)
	if cli == nil {
		fmt.Println("create http cli fail.")
		return
	}

	request := fangkeReq{"fathor"}
	rsp, err := cli.Endpoint()(context.TODO(), request)
	if err != nil {
		fmt.Println("rsp err, err:", err.Error())
		return
	}

	fmt.Println(rsp)

	return
}

func queryClient() {
	target, err := url.Parse("http://127.0.0.1:8000/query")
	if err != nil {
		fmt.Println("err:", err.Error())
		return
	}

	cli := httptransport.NewClient(http.MethodGet, target, encodeQuery, decodeQuery)
	if cli == nil {
		fmt.Println("create http cli fail.")
		return
	}

	request := queryReq{"xiaoming"}
	rsp, err := cli.Endpoint()(context.TODO(), request)
	if err != nil {
		fmt.Println("rsp err, err:", err.Error())
		return
	}

	fmt.Println(rsp)
}

func main() {
	fangkeClient()
	queryClient()

	return
}