Kratos 大乱炖 —— 整合其他Web结构：Gin、FastHttp、Hertz

Kratos默认的RPC结构运用的是gRPC，支持REST和protobuf两种通讯协议。其API都是运用protobuf界说的，REST协议是通过grpc-gateway转译实现的。运用protobuf界说API是具有极大优点的，具有很强的可读性、可维护性，以及工程性。工程再大，人员再多，也不会乱。

一切看起来都是很夸姣的。那么，问题来了，咱们现在运用的是其他的Web结构，搬迁就会有成本，有风险，不可能一下子就把前史存在的代码一口气转换过来到Kratos结构。那我能够在Kratos中整合其他的Web结构做过渡吗？答案是：能够的。Kratos是根据的插件化规划，万物皆可插。

我整合了主流的Gin和FastHttp。顺便把字节跳动的Hertz也尝试着整合了一下。整合之后，运用起来毫无违和感。

Gin

Gin 是用 Go 编写的一个 Web 运用结构，对比其它主流的同类结构，他有更好的性能和更快的路由。因为其本身只是在官方 net/http 包的基础上做的完善，所以理解和上手很滑润。

封装的代码如下：

package gin
import (
	"context"
	"crypto/tls"
	"net/http"
	"net/url"
	"time"
	"github.com/gin-gonic/gin"
	"github.com/go-kratos/kratos/v2/errors"
	"github.com/go-kratos/kratos/v2/log"
	"github.com/go-kratos/kratos/v2/middleware"
	"github.com/go-kratos/kratos/v2/transport"
	kHttp "github.com/go-kratos/kratos/v2/transport/http"
)
var (
	_ transport.Server     = (*Server)(nil)
	_ transport.Endpointer = (*Server)(nil)
)
type Server struct {
	*gin.Engine
	server *http.Server
	tlsConf  *tls.Config
	endpoint *url.URL
	timeout  time.Duration
	addr     string
	err error
	filters []kHttp.FilterFunc
	ms      []middleware.Middleware
	dec     kHttp.DecodeRequestFunc
	enc     kHttp.EncodeResponseFunc
	ene     kHttp.EncodeErrorFunc
}
func NewServer(opts ...ServerOption) *Server {
	srv := &Server{
		timeout: 1 * time.Second,
		dec:     kHttp.DefaultRequestDecoder,
		enc:     kHttp.DefaultResponseEncoder,
		ene:     kHttp.DefaultErrorEncoder,
	}
	srv.init(opts...)
	return srv
}
func (s *Server) init(opts ...ServerOption) {
	s.Engine = gin.Default()
	for _, o := range opts {
		o(s)
	}
	s.server = &http.Server{
		Addr:      s.addr,
		Handler:   s.Engine,
		TLSConfig: s.tlsConf,
	}
	s.endpoint, _ = url.Parse(s.addr)
}
func (s *Server) Endpoint() (*url.URL, error) {
	return s.endpoint, nil
}
func (s *Server) Start(ctx context.Context) error {
	log.Infof("[GIN] server listening on: %s", s.addr)
	var err error
	if s.tlsConf != nil {
		err = s.server.ListenAndServeTLS("", "")
	} else {
		err = s.server.ListenAndServe()
	}
	if !errors.Is(err, http.ErrServerClosed) {
		return err
	}
	return nil
}
func (s *Server) Stop(ctx context.Context) error {
	log.Info("[GIN] server stopping")
	return s.server.Shutdown(ctx)
}
func (s *Server) ServeHTTP(res http.ResponseWriter, req *http.Request) {
	s.Engine.ServeHTTP(res, req)
}

运用的代码如下：

package gin
import (
    "context"
    "math/rand"
    "strconv"
    "github.com/gin-gonic/gin"
    transport "github.com/tx7do/kratos-transport/gin"
    api "github.com/tx7do/kratos-transport/_example/api/protobuf"
)
func main() {
    ctx := context.Background()
    srv := transport.NewServer(
        WithAddress(":8800"),
    )
    srv.Use(gin.Recovery())
    srv.Use(gin.Logger())
    srv.GET("/login/*param", func(c *gin.Context) {
        if len(c.Params.ByName("param")) > 1 {
            c.AbortWithStatus(404)
            return
        }
        c.String(200, "Hello World!")
    })
    srv.GET("/hygrothermograph", func(c *gin.Context) {
        var out api.Hygrothermograph
        out.Humidity = strconv.FormatInt(int64(rand.Intn(100)), 10)
        out.Temperature = strconv.FormatInt(int64(rand.Intn(100)), 10)
        c.JSON(200, &out)
    })
    if err := srv.Start(ctx); err != nil {
        panic(err)
    }
    defer func() {
        if err := srv.Stop(ctx); err != nil {
            t.Errorf("expected nil got %v", err)
        }
    }()
}

FastHttp

FastHTTP是golang下的一个http结构，望文生义，与原生的http实现相比，它的特色在于快，依照官网的说法，它的客户端和服务端性能比原生有了十倍的提升。

它的高性能主要源自于“复用”，通过服务协程和内存变量的复用，节省了许多资源分配的成本。

封装的代码如下：

package fasthttp
import (
	"context"
	"crypto/tls"
	"net/http"
	"net/url"
	"time"
	"github.com/fasthttp/router"
	"github.com/valyala/fasthttp"
	"github.com/go-kratos/kratos/v2/errors"
	"github.com/go-kratos/kratos/v2/log"
	"github.com/go-kratos/kratos/v2/middleware"
	"github.com/go-kratos/kratos/v2/transport"
	kHttp "github.com/go-kratos/kratos/v2/transport/http"
)
var (
	_ transport.Server     = (*Server)(nil)
	_ transport.Endpointer = (*Server)(nil)
)
type Server struct {
	*fasthttp.Server
	tlsConf  *tls.Config
	endpoint *url.URL
	timeout  time.Duration
	addr     string
	err error
	filters []FilterFunc
	ms      []middleware.Middleware
	dec     kHttp.DecodeRequestFunc
	enc     kHttp.EncodeResponseFunc
	ene     kHttp.EncodeErrorFunc
	strictSlash bool
	router      *router.Router
}
func NewServer(opts ...ServerOption) *Server {
	srv := &Server{
		timeout:     1 * time.Second,
		dec:         kHttp.DefaultRequestDecoder,
		enc:         kHttp.DefaultResponseEncoder,
		ene:         kHttp.DefaultErrorEncoder,
		strictSlash: true,
		router:      router.New(),
	}
	srv.init(opts...)
	return srv
}
func (s *Server) init(opts ...ServerOption) {
	for _, o := range opts {
		o(s)
	}
	s.Server = &fasthttp.Server{
		TLSConfig: s.tlsConf,
		Handler:   FilterChain(s.filters...)(s.router.Handler),
	}
	s.router.RedirectTrailingSlash = s.strictSlash
	s.endpoint, _ = url.Parse(s.addr)
}
func (s *Server) Endpoint() (*url.URL, error) {
	return s.endpoint, nil
}
func (s *Server) Start(ctx context.Context) error {
	log.Infof("[fasthttp] server listening on: %s", s.addr)
	var err error
	if s.tlsConf != nil {
		err = s.Server.ListenAndServeTLS(s.addr, "", "")
	} else {
		err = s.Server.ListenAndServe(s.addr)
	}
	if !errors.Is(err, http.ErrServerClosed) {
		return err
	}
	return nil
}
func (s *Server) Stop(_ context.Context) error {
	log.Info("[fasthttp] server stopping")
	return s.Server.Shutdown()
}
func (s *Server) Handle(method, path string, handler fasthttp.RequestHandler) {
	s.router.Handle(method, path, handler)
}
func (s *Server) GET(path string, handler fasthttp.RequestHandler) {
	s.Handle(fasthttp.MethodGet, path, handler)
}
func (s *Server) HEAD(path string, handler fasthttp.RequestHandler) {
	s.Handle(fasthttp.MethodHead, path, handler)
}
func (s *Server) POST(path string, handler fasthttp.RequestHandler) {
	s.Handle(fasthttp.MethodPost, path, handler)
}
func (s *Server) PUT(path string, handler fasthttp.RequestHandler) {
	s.Handle(fasthttp.MethodPut, path, handler)
}
func (s *Server) PATCH(path string, handler fasthttp.RequestHandler) {
	s.Handle(fasthttp.MethodPatch, path, handler)
}
func (s *Server) DELETE(path string, handler fasthttp.RequestHandler) {
	s.Handle(fasthttp.MethodDelete, path, handler)
}
func (s *Server) CONNECT(path string, handler fasthttp.RequestHandler) {
	s.Handle(fasthttp.MethodConnect, path, handler)
}
func (s *Server) OPTIONS(path string, handler fasthttp.RequestHandler) {
	s.Handle(fasthttp.MethodOptions, path, handler)
}
func (s *Server) TRACE(path string, handler fasthttp.RequestHandler) {
	s.Handle(fasthttp.MethodTrace, path, handler)
}

运用的代码如下：

package fasthttp
import (
    "context"
    "encoding/json"
    "math/rand"
    "strconv"
    "github.com/valyala/fasthttp"
    transport "github.com/tx7do/kratos-transport/fasthttp"
    api "github.com/tx7do/kratos-transport/_example/api/protobuf"
)
func main() {
    ctx := context.Background()
    srv := transport.NewServer(
        WithAddress(":8800"),
    )
    srv.GET("/login/*param", func(c *fasthttp.RequestCtx) {
        _, _ = c.WriteString("Hello World!")
    })
    srv.GET("/hygrothermograph", func(c *fasthttp.RequestCtx) {
        var out api.Hygrothermograph
        out.Humidity = strconv.FormatInt(int64(rand.Intn(100)), 10)
        out.Temperature = strconv.FormatInt(int64(rand.Intn(100)), 10)
        _ = json.NewEncoder(c.Response.BodyWriter()).Encode(&out)
    })
    if err := srv.Start(ctx); err != nil {
        panic(err)
    }
    defer func() {
        if err := srv.Stop(ctx); err != nil {
            t.Errorf("expected nil got %v", err)
        }
    }()
}

Hertz

Hertz[hts] 是一个 Golang 微服务 HTTP 结构，在规划之初参阅了其他开源结构 fasthttp、gin、echo 的优势，并结合字节跳动内部的需求，使其具有高易用性、高性能、高扩展性等特色，现在在字节跳动内部已广泛运用。如今越来越多的微服务选择运用 Golang，如果对微服务性能有要求，又期望结构能够充沛满足内部的可定制化需求，Hertz 会是一个不错的选择。

封装的代码如下：

package hertz
import (
	"context"
	"crypto/tls"
	"net/url"
	"time"
	hertz "github.com/cloudwego/hertz/pkg/app/server"
	"github.com/go-kratos/kratos/v2/log"
	"github.com/go-kratos/kratos/v2/middleware"
	"github.com/go-kratos/kratos/v2/transport"
	kHttp "github.com/go-kratos/kratos/v2/transport/http"
)
var (
	_ transport.Server     = (*Server)(nil)
	_ transport.Endpointer = (*Server)(nil)
)
type Server struct {
	*hertz.Hertz
	tlsConf  *tls.Config
	endpoint *url.URL
	timeout  time.Duration
	addr     string
	err error
	filters []kHttp.FilterFunc
	ms      []middleware.Middleware
	dec     kHttp.DecodeRequestFunc
	enc     kHttp.EncodeResponseFunc
	ene     kHttp.EncodeErrorFunc
}
func NewServer(opts ...ServerOption) *Server {
	srv := &Server{
		timeout: 1 * time.Second,
		dec:     kHttp.DefaultRequestDecoder,
		enc:     kHttp.DefaultResponseEncoder,
		ene:     kHttp.DefaultErrorEncoder,
	}
	srv.init(opts...)
	return srv
}
func (s *Server) init(opts ...ServerOption) {
	for _, o := range opts {
		o(s)
	}
	s.Hertz = hertz.Default(hertz.WithHostPorts(s.addr), hertz.WithTLS(s.tlsConf))
	s.endpoint, _ = url.Parse(s.addr)
}
func (s *Server) Endpoint() (*url.URL, error) {
	return s.endpoint, nil
}
func (s *Server) Start(ctx context.Context) error {
	log.Infof("[hertz] server listening on: %s", s.addr)
	return s.Hertz.Run()
}
func (s *Server) Stop(ctx context.Context) error {
	log.Info("[hertz] server stopping")
	return s.Hertz.Shutdown(ctx)
}

运用的代码如下：

package hertz
import (
    "context"
    "math/rand"
    "strconv"
    "github.com/cloudwego/hertz/pkg/app"
    transport "github.com/tx7do/kratos-transport/hertz"
    api "github.com/tx7do/kratos-transport/_example/api/protobuf"
)
func TestServer(t *testing.T) {
    ctx := context.Background()
    srv := transport.NewServer(
        WithAddress("127.0.0.1:8800"),
    )
    srv.GET("/login/*param", func(ctx context.Context, c *app.RequestContext) {
        if len(c.Params.ByName("param")) > 1 {
            c.AbortWithStatus(404)
            return
        }
        c.String(200, "Hello World!")
    })
    srv.GET("/hygrothermograph", func(ctx context.Context, c *app.RequestContext) {
        var out api.Hygrothermograph
        out.Humidity = strconv.FormatInt(int64(rand.Intn(100)), 10)
        out.Temperature = strconv.FormatInt(int64(rand.Intn(100)), 10)
        c.JSON(200, &out)
    })
    if err := srv.Start(ctx); err != nil {
        panic(err)
    }
    defer func() {
        if err := srv.Stop(ctx); err != nil {
            t.Errorf("expected nil got %v", err)
        }
    }()
}

参阅资料

GIN – Github
Gin – Website
FastHTTP Github
fasthttp：高性能背后的惨痛代价
fasthttp性能真的比规范库http包好许多吗？一文告诉你真相！
Hertz – Github
Hertz – Docs

Kratos 大乱炖 —— 整合其他Web框架：Gin、FastHttp、Hertz

Kratos 大乱炖 —— 整合其他Web结构：Gin、FastHttp、Hertz

Gin

FastHttp

Hertz

参阅资料

作者信息

Kratos 大乱炖 —— 整合其他Web框架：Gin、FastHttp、Hertz

Kratos 大乱炖 —— 整合其他Web结构：Gin、FastHttp、Hertz

Gin

FastHttp

Hertz

参阅资料

相关文章

10年技术进阶路，让我明白了这3件事

面试突击31：什么是守护线程？它和用户线程有什么区别？

GIT | 日常命令查阅表

进程间通信——Binder

作者信息