go-kit 构建微服务(1)

// service interface
type Service interface {
	Multiply(ctx context.Context, in MultiplyRequest) MultiplyResponse
}

// request struct
type MultiplyRequest struct {
	A int `json:"a"`
	B int `json:"b"`
}

// response struct
type MultiplyResponse struct {
	Res int `json:"res"`
}

// Service struct, has an implementation of Service interface
type baseService struct {
}

func NewService() Service {
	return &baseService{}
}

func (bs baseService) Multiply(ctx context.Context, in MultiplyRequest) MultiplyResponse {
	return MultiplyResponse{
		Res: in.A * in.B,
	}
} 

package endpoint

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

type EndPoints struct {
	MultiplyEndPoint endpoint.Endpoint
}

func NewEndpoints(svc service.Service) EndPoints {
	var multiplyEndpoint endpoint.Endpoint
	{
		multiplyEndpoint = makeMultiplyMultiplyEndPoint(svc)
	}
	return EndPoints{MultiplyEndPoint: multiplyEndpoint}
}

func makeMultiplyMultiplyEndPoint(s service.Service) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (response interface{}, err error) {
		req := request.(service.MultiplyRequest)
		resp := s.Multiply(ctx, req)
		return resp, nil
	}
}

package transport

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/go-kit/kit/endpoint"
	httptransport "github.com/go-kit/kit/transport/http"
	endpoints "go-kit-microservice/internal/endpoint"
	"go-kit-microservice/internal/service"
	"net/http"
	"strconv"
)

func MewHttpHandler(endpoints endpoints.EndPoints) http.Handler {
	options := []httptransport.ServerOption{
		httptransport.ServerErrorEncoder(errorEncoder),
	}

	m := http.NewServeMux()
	m.Handle("/multiply", httptransport.NewServer(
		endpoints.MultiplyEndPoint,
		decodeMultiplyRequest,
		encodeMultiplyResponse,
		options...,
	))

	return m
}

// decode the request to service layer request params
func decodeMultiplyRequest(_ context.Context, r *http.Request) (interface{}, error) {
	var (
		in  service.MultiplyRequest
		err error
	)

	if in.A, err = strconv.Atoi(r.FormValue("a")); err != nil {
		return in, err
	}

	if in.B, err = strconv.Atoi(r.FormValue("b")); err != nil {
		return in, err
	}

	return in, nil
}

// encode the response data to user
func encodeMultiplyResponse(ctx context.Context, w http.ResponseWriter, response interface{}) error {
	if f, ok := response.(endpoint.Failer); ok && f.Failed() != nil {
		errorEncoder(ctx, f.Failed(), w)
		return nil
	}

	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	return json.NewEncoder(w).Encode(response)
}

// error EncodeHandler
func errorEncoder(ctx context.Context, err error, w http.ResponseWriter) {
	w.WriteHeader(http.StatusOK)
	fmt.Println("response failed: ", err.Error())
	e := json.NewEncoder(w).Encode(errorWrapper{Error: err.Error()})
	if e != nil {
		fmt.Println("json encode failed: ", e.Error())
	}

}

type errorWrapper struct {
	Error string `json:"error"`
}

package main

import (
	"fmt"
	"github.com/oklog/oklog/pkg/group"
	"go-kit-microservice/internal/endpoint"
	"go-kit-microservice/internal/service"
	"go-kit-microservice/internal/transport"
	"net"
	"net/http"
)

func main() {

	svc := service.NewService()

	endpoints := endpoint.NewEndpoints(svc)

	httpHandler := transport.MewHttpHandler(endpoints)

	var g group.Group
	{
		httpListener, err := net.Listen("tcp", ":8082")
		if err != nil {
			fmt.Println("http server start failed:" + err.Error())
		}

		g.Add(func() error {
			return http.Serve(httpListener, httpHandler)
		}, func(e error) {
			err = httpListener.Close()
			if err != nil {
				fmt.Println("http server close failed", err.Error())
			}
		})
	}
	_ = g.Run()
}

package client

import (
	"fmt"
	"io/ioutil"
	"net/http"
)

const baseUrl = "http://localhost:8081/"

func main() {
	multiplyUrl := baseUrl + "multiply?a=4&b=9"
	resp, err := http.Get(multiplyUrl)
	if err != nil {
		fmt.Println(err.Error())
	} else {
		resp := getHttpResponse(resp)
		fmt.Println("get multiply result:" + resp)
	}

}

func getHttpResponse(resp *http.Response) string {
	data, err := ioutil.ReadAll(resp.Body)
	defer resp.Body.Close()
	if err != nil {
		fmt.Println(err.Error())
	}
	return string(data)
}

$ go build http_client.go 
$ ls
http_client     http_client.go
$ ./http_client 
get multiply result:{"res":36}