關於go-zero單體服務使用泛型簡化註冊Handler路由的問題

2022-07-27 22:02:36

一、Golang環境安裝及設定Go Module

https://go-zero.dev/cn/docs/prepare/golang-install

mac OS安裝Go#

下載並安裝Go for Mac
驗證安裝結果

$ go version
go version go1.15.1 darwin/amd64

linux 安裝Go#

下載Go for Linux
解壓壓縮包至/usr/local

$ tar -C /usr/local -xzf go1.15.8.linux-amd64.tar.gz

新增/usr/local/go/bin到環境變數

$ $HOME/.profile
$ export PATH=$PATH:/usr/local/go/bin
$ source $HOME/.profile

驗證安裝結果

$ go version
go version go1.15.1 linux/amd64

Windows安裝Go#

下載並安裝Go for Windows驗證安裝結果

$ go version
go version go1.15.1 windows/amd64

MODULE設定

Go Module是Golang管理依賴性的方式，像Java中的Maven，Android中的Gradle類似。

檢視GO111MODULE開啟情況

$ go env GO111MODULE
on

開啟GO111MODULE，如果已開啟（即執行go env GO111MODULE結果為on）請跳過。

$ go env -w GO111MODULE="on"

設定GOPROXY

$ go env -w GOPROXY=https://goproxy.cn

設定GOMODCACHE

檢視GOMODCACHE

$ go env GOMODCACHE

如果目錄不為空或者/dev/null，請跳過。

go env -w GOMODCACHE=$GOPATH/pkg/mod

二、Goctl 安裝

Goctl在go-zero專案開發著有著很大的作用，其可以有效的幫助開發者大大提高開發效率，減少程式碼的出錯率，縮短業務開發的工作量，更多的Goctl的介紹請閱讀Goctl介紹

安裝(mac&linux)

### Go 1.15 及之前版本
GO111MODULE=on GOPROXY=https://goproxy.cn/,direct go get -u github.com/zeromicro/go-zero/tools/goctl@latest
### Go 1.16 及以後版本
GOPROXY=https://goproxy.cn/,direct go install github.com/zeromicro/go-zero/tools/goctl@latest

安裝(windows)

go install github.com/zeromicro/go-zero/tools/goctl@latest

環境變數檢測(mac&linux)
go get 下載編譯後的二進位制檔案位於 $GOPATH/bin 目錄下，要確保 $GOPATH/bin已經新增到環境變數。

sudo vim /etc/paths //新增環境變數

在最後一行新增如下內容 //$GOPATH 為你本機上的檔案地址

$GOPATH/bin

安裝結果驗證

$ goctl -v
goctl version 1.1.4 darwin/amd64

二、初始化go-zero

快速生成 api 服務

goctl api new greet
cd greet
go mod init
go mod tidy
go run greet.go -f etc/greet-api.yaml

預設偵聽在 8888 埠
偵聽埠可以在greet-api.yaml組態檔裡修改，此時，可以通過 curl 請求，或者直接在瀏覽器中開啟http://localhost:8888/from/you

$ curl -i http://localhost:8888/from/you
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Traceparent: 00-45fa9e7a7c505bad3a53a024e425ace9-eb5787234cf3e308-00
Date: Thu, 22 Oct 2020 14:03:18 GMT
Content-Length: 14
null

greet服務的目錄結構

$ tree greet
greet
├── etc
│   └── greet-api.yaml
├── greet.api
├── greet.go
└── internal
    ├── config
    │   └── config.go
    ├── handler
    │   ├── greethandler.go
    │   └── routes.go
    ├── logic
    │   └── greetlogic.go
    ├── svc
    │   └── servicecontext.go
    └── types
        └── types.go

三、檢視註冊Handler路由流程greet.go

var configFile = flag.String("f", "etc/greet-api.yaml", "the config file")
func main() {
	flag.Parse()
	var c config.Config
	conf.MustLoad(*configFile, &c)
	server := rest.MustNewServer(c.RestConf)
	defer server.Stop()
        //上面的都是載入設定什麼的
	ctx := svc.NewServiceContext(c)
	handler.RegisterHandlers(server, ctx) //此方法是註冊路由和路由對映Handler，重點在這裡
	fmt.Printf("Starting server at %s:%d...n", c.Host, c.Port)
	server.Start()
}

RegisterHandlers在internalhandlerroutes.go中

func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
   server.AddRoutes( //往rest.Server中新增路由
	[]rest.Route{ //路由陣列
	   {
	      Method:  http.MethodGet,
	      Path:    "/from/:name", //路由
	      Handler: GreetHandler(serverCtx),//當前路由的處理Handler
	   },
	},
   )
}

GreetHandler在internalhandlergreethandler.go中

func GreetHandler(ctx *svc.ServiceContext) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		var req types.Request
	if err := httpx.Parse(r, &req); err != nil { //請求的錯誤判斷，這個可以不用管
			httpx.Error(w, err)
			return
		}
 
		l := logic.NewGreetLogic(r.Context(), ctx) //GreetHandler處理常式將請求轉發到了GreetLogic中，呼叫NewGreetLogic進行結構體的初始化
		resp, err := l.Greet(req) //然後呼叫Greet來進行處理請求，所以我們在GreetLogic.Greet方法中可以看到一句話// todo: add your logic here and delete this line
		if err != nil {
			httpx.Error(w, err)
		} else {
			httpx.OkJson(w, resp)
		}
	}
}

四、對註冊Handler路由進行簡化

專案檔案的增加

在路由註冊時，我們如果服務越加越多，那麼相對應的func xxxxHandler(ctx *svc.ServiceContext) http.HandlerFunc就要進行多次的新增，並且這個方法體內部1到5行是屬於額外的重複新增
例如：我們新增一個customlogic.go
按照命名的正確和規範性，需要在internallogic目錄下新增customlogic.go檔案，然後在internalhandler目錄下新增customhandler.go檔案，並且兩個檔案都新增相對應的結構體和函數等，最後在routes.go中再新增一次

{
    Method:  http.MethodGet,
    Path:    "/custom/:name",
    Handler: CustomHandler(serverCtx),
},

此時，我們的檔案結構應該是這樣

greet
├── etc
│   └── greet-api.yaml
├── greet.api
├── greet.go
└── internal
    ├── config
    │   └── config.go
    ├── handler
    │   ├── greethandler.go
    │   ├── customhandler.go
    │   ├── ...
    │   └── routes.go
    ├── logic
    │   ├── greetlogic.go
    │   ├── ...
    │   └── customlogic.go
    ├── svc
    │   └── servicecontext.go
    └── types
        └── types.go

當單體應用達到一定的數量級，handler和logic資料夾下將會同步增加很多的檔案

引入泛型概念

自Go1.18開始，go開始使用泛型，泛型的廣泛定義：是一種把明確型別的工作推遲到建立物件或者呼叫方法的時候才去明確的特殊的型別。也就是說在泛型使用過程中，操作的資料型別被指定為一個引數，而這種引數型別可以用在類、方法和介面中，分別被稱為泛型類、泛型方法、泛型介面。
我們可以利用泛型，讓在新增路由時就要固定死的Handler: GreetHandler(serverCtx)推遲到後面，去根據實際的Logic結構體去判斷需要真正執行的logic.NewGreetLogic(r.Context(), ctx)初始化結構體和l.Greet(req)邏輯處理方法

如何去做在internallogic下新增一個baselogic.go檔案,參考Go泛型實戰 | 如何在結構體中使用泛型

package logic
import (
	"greet/internal/svc"
	"greet/internal/types"
	"net/http"
)
type BaseLogic interface {
	any
	Handler(req types.Request, w http.ResponseWriter, r *http.Request, svcCtx *svc.ServiceContext) //每一個結構體中必須要繼承一下Handler方法，例如customlogic.go和greetlogic.go中的Handler方法
}
type logic[T BaseLogic] struct {
	data T
}
func New[T BaseLogic]() logic[T] {
	c := logic[T]{}
	var ins T
	c.data = ins
	return c
}
func (a *logic[T]) LogicHandler(req types.Request, w http.ResponseWriter, r *http.Request, svcCtx *svc.ServiceContext) { //作為一箇中轉處理方法，最終執行結構體的Handler
	a.data.Handler(req, w, r, svcCtx)
}

將greethandler.go檔案修改成basehandler.go,註釋掉之前的GreetHandler方法

package handler
import (
	"net/http"
	"greet/internal/logic"
	"greet/internal/svc"
	"greet/internal/types"
	"github.com/zeromicro/go-zero/rest/httpx"
)
// func GreetHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
// 	return BaseHandlerFunc(svcCtx)
// 	// return func(w http.ResponseWriter, r *http.Request) {
// 	// 	var req types.Request
// 	// 	if err := httpx.Parse(r, &req); err != nil {
// 	// 		httpx.Error(w, err)
// 	// 		return
// 	// 	}
// 	// 	l := logic.NewGreetLogic(r.Context(), svcCtx)
// 	// 	resp, err := l.Greet(&req)
// 	// 	if err != nil {
// 	// 		httpx.Error(w, err)
// 	// 	} else {
// 	// 		httpx.OkJson(w, resp)
// 	// 	}
// 	// }
// }
func BaseHandlerFunc[T logic.BaseLogic](svcCtx *svc.ServiceContext, t T) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		var req types.Request
		if err := httpx.Parse(r, &req); err != nil {
			httpx.Error(w, err)
			return
		}
		//通過泛型動態呼叫不同結構體的Handler方法
		cc := logic.New[T]()
		cc.LogicHandler(req, w, r, svcCtx)
	}
}

在internallogicgreetlogic.go中增加一個Handler方法

package logic
import (
	"context"
	"net/http"
	"greet/internal/svc"
	"greet/internal/types"
	"github.com/zeromicro/go-zero/core/logx"
	"github.com/zeromicro/go-zero/rest/httpx"
)
type GreetLogic struct {
	logx.Logger
	ctx    context.Context
	svcCtx *svc.ServiceContext
}
func NewGreetLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GreetLogic {
	return &GreetLogic{
		Logger: logx.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}
func (a GreetLogic) Handler(req types.Request, w http.ResponseWriter, r *http.Request, svcCtx *svc.ServiceContext) { //新增方法
	l := NewGreetLogic(r.Context(), svcCtx)
	resp, err := l.Greet(&req)
	if err != nil {
		httpx.Error(w, err)
	} else {
		httpx.OkJson(w, resp)
	}
}
func (l *GreetLogic) Greet(req *types.Request) (resp *types.Response, err error) {
	// todo: add your logic here and delete this line
	response := new(types.Response)
	if (*req).Name == "me" {
		response.Message = "greetLogic: listen to me, thank you."
	} else {
		response.Message = "greetLogic: listen to you, thank me."
	}
	return response, nil
}

然後修改internalhandlerroutes.go下面的server.AddRoutes部分

func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
   server.AddRoutes( //往rest.Server中新增路由
	[]rest.Route{ //路由陣列
	   {
	      Method:  http.MethodGet,
	      Path:    "/from/:name", //路由
	      Handler: BaseHandlerFunc(serverCtx,logic.GreetLogic{}),
	   },
	},
   )
}

現在就大功告成了，我們啟動一下

go run greet.go -f etc/greet-api.yaml

然後在瀏覽器中請求一下http://localhost:8888/from/you

驗證一下新增api路由在`internallogic`下新增一個`customlogic.go`檔案

package logic
import (
	"context"
	"net/http"
	"greet/internal/svc"
	"greet/internal/types"
	"github.com/zeromicro/go-zero/core/logx"
	"github.com/zeromicro/go-zero/rest/httpx"
)
type CustomLogic struct {
	logx.Logger
	ctx    context.Context
	svcCtx *svc.ServiceContext
}
func NewCustomLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CustomLogic {
	return &CustomLogic{
		Logger: logx.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}
func (a CustomLogic) Handler(req types.Request, w http.ResponseWriter, r *http.Request, svcCtx *svc.ServiceContext) {
	l := NewCustomLogic(r.Context(), svcCtx)
	resp, err := l.Custom(&req)
	if err != nil {
		httpx.Error(w, err)
	} else {
		httpx.OkJson(w, resp)
	}
}
func (l *CustomLogic) Custom(req *types.Request) (resp *types.Response, err error) { //response.Message稍微修改了一下，便於區分
	// todo: add your logic here and delete this line
	response := new(types.Response)
	if (*req).Name == "me" {
		response.Message = "customLogic: listen to me, thank you."
	} else {
		response.Message = "customLogic: listen to you, thank me."
	}
	return response, nil
}

然後修改internalhandlerroutes.go

func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
   server.AddRoutes( //往rest.Server中新增路由
	[]rest.Route{ //路由陣列
	   {
	      Method:  http.MethodGet,
	      Path:    "/from/:name", //路由
	      Handler: BaseHandlerFunc(serverCtx,logic.GreetLogic{}),
	   },
           {
	      Method:  http.MethodGet,
	      Path:    "/to/:name", //路由
	      Handler: BaseHandlerFunc(serverCtx,logic.CustomLogic{}),
	   },
	},
   )
}

其他地方不需要修改
我們啟動一下