go-zero单体服务使用泛型简化注册Handler路由

渣渣兔  金牌会员 | 2022-9-2 14:15:39 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 754|帖子 754|积分 2262

一、Golang环境安装及配置Go Module

https://go-zero.dev/cn/docs/prepare/golang-install
mac OS安装Go#


  • 下载并安装Go for Mac
  • 验证安装结果
  1. $ go version
  2. go version go1.15.1 darwin/amd64
复制代码
linux 安装Go#


  • 下载Go for Linux
  • 解压压缩包至/usr/local
  1. $ tar -C /usr/local -xzf go1.15.8.linux-amd64.tar.gz
复制代码

  • 添加/usr/local/go/bin到环境变量
  1. $ $HOME/.profile
  2. $ export PATH=$PATH:/usr/local/go/bin
  3. $ source $HOME/.profile
复制代码

  • 验证安装结果
  1. $ go version
  2. go version go1.15.1 linux/amd64
复制代码
Windows安装Go#


  • 下载并安装Go for Windows
  • 验证安装结果
  1. $ go version
  2. go version go1.15.1 windows/amd64
复制代码
MODULE配置

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

  • 查看GO111MODULE开启情况
  1. $ go env GO111MODULE
  2. on
复制代码

  • 开启GO111MODULE，如果已开启（即执行go env GO111MODULE结果为on）请跳过。
  1. $ go env -w GO111MODULE="on"
复制代码

  • 设置GOPROXY
  1. $ go env -w GOPROXY=https://goproxy.cn
复制代码

  • 设置GOMODCACHE
  1. 查看GOMODCACHE
复制代码
$ go env GOMODCACHE

  • 如果目录不为空或者/dev/null，请跳过。
  1. go env -w GOMODCACHE=$GOPATH/pkg/mod
复制代码
二、Goctl 安装

Goctl在go-zero项目开发着有着很大的作用，其可以有效的帮助开发者大大提高开发效率，减少代码的出错率，缩短业务开发的工作量，更多的Goctl的介绍请阅读Goctl介绍

  • 安装(mac&linux)
  1. ### Go 1.15 及之前版本
  2. GO111MODULE=on GOPROXY=https://goproxy.cn/,direct go get -u github.com/zeromicro/go-zero/tools/goctl@latest
  4. ### Go 1.16 及以后版本
  5. GOPROXY=https://goproxy.cn/,direct go install github.com/zeromicro/go-zero/tools/goctl@latest
复制代码

  • 安装(windows)
  1. go install github.com/zeromicro/go-zero/tools/goctl@latest
复制代码

  • 环境变量检测(mac&linux)
    go get 下载编译后的二进制文件位于 \$GOPATH/bin 目录下，要确保 $GOPATH/bin已经添加到环境变量。
  1. sudo vim /etc/paths //添加环境变量
复制代码
在最后一行添加如下内容 //$GOPATH 为你本机上的文件地址
  1. $GOPATH/bin
复制代码

  • 安装结果验证
  1. $ goctl -v
  2. goctl version 1.1.4 darwin/amd64
复制代码
二、初始化go-zero

  1. goctl api new greet
  2. cd greet
  3. go mod init
  4. go mod tidy
  5. go run greet.go -f etc/greet-api.yaml
复制代码

  • 默认侦听在 8888 端口
    侦听端口可以在greet-api.yaml配置文件里修改，此时，可以通过 curl 请求，或者直接在浏览器中打开http://localhost:8888/from/you
  1. $ curl -i http://localhost:8888/from/you
  3. HTTP/1.1 200 OK
  4. Content-Type: application/json; charset=utf-8
  5. Traceparent: 00-45fa9e7a7c505bad3a53a024e425ace9-eb5787234cf3e308-00
  6. Date: Thu, 22 Oct 2020 14:03:18 GMT
  7. Content-Length: 14
  9. null
复制代码

  • greet服务的目录结构
  1. $ tree greet
  2. greet
  3. ├── etc
  4. │   └── greet-api.yaml
  5. ├── greet.api
  6. ├── greet.go
  7. └── internal
  8.     ├── config
  9.     │   └── config.go
  10.     ├── handler
  11.     │   ├── greethandler.go
  12.     │   └── routes.go
  13.     ├── logic
  14.     │   └── greetlogic.go
  15.     ├── svc
  16.     │   └── servicecontext.go
  17.     └── types
  18.         └── types.go
复制代码
三、查看注册Handler路由流程


  • greet.go
  1. var configFile = flag.String("f", "etc/greet-api.yaml", "the config file")
  3. func main() {
  4.         flag.Parse()
  6.         var c config.Config
  7.         conf.MustLoad(*configFile, &c)
  9.         server := rest.MustNewServer(c.RestConf)
  10.         defer server.Stop()
  11.         //上面的都是加载配置什么的
  12.         ctx := svc.NewServiceContext(c)
  13.         handler.RegisterHandlers(server, ctx) //此方法是注册路由和路由映射Handler，重点在这里
  15.         fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
  16.         server.Start()
  17. }
复制代码

  • RegisterHandlers在internal\handler\routes.go中
  1. func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
  2.    server.AddRoutes( //往rest.Server中添加路由
  3.         []rest.Route{ //路由数组
  4.            {
  5.               Method:  http.MethodGet,
  6.               Path:    "/from/:name", //路由
  7.               Handler: GreetHandler(serverCtx),//当前路由的处理Handler
  8.            },
  9.         },
  10.    )
  11. }
复制代码

  • GreetHandler在internal\handler\greethandler.go中
  1. func GreetHandler(ctx *svc.ServiceContext) http.HandlerFunc {
  2.         return func(w http.ResponseWriter, r *http.Request) {
  3. 1.                var req types.Request
  4. 2.                if err := httpx.Parse(r, &req); err != nil { //请求的错误判断，这个可以不用管
  5. 3.                        httpx.Error(w, err)
  6. 4.                        return
  7. 5.                }
  9.                 l := logic.NewGreetLogic(r.Context(), ctx) //GreetHandler处理函数将请求转发到了GreetLogic中，调用NewGreetLogic进行结构体的初始化
  10.                 resp, err := l.Greet(req) //然后调用Greet来进行处理请求，所以我们在GreetLogic.Greet方法中可以看到一句话// todo: add your logic here and delete this line
  11.                 if err != nil {
  12.                         httpx.Error(w, err)
  13.                 } else {
  14.                         httpx.OkJson(w, resp)
  15.                 }
  16.         }
  17. }
复制代码
四、对注册Handler路由进行简化

项目文件的增加

在路由注册时，我们如果服务越加越多，那么相对应的func xxxxHandler(ctx *svc.ServiceContext) http.HandlerFunc就要进行多次的添加，并且这个方法体内部1到5行是属于额外的重复添加
例如：我们添加一个customlogic.go
按照命名的正确和规范性，需要在internal\logic目录下添加customlogic.go文件，然后在internal\handler目录下添加customhandler.go文件，并且两个文件都添加相对应的结构体和函数等，最后在routes.go中再添加一次
  1. {
  2.     Method:  http.MethodGet,
  3.     Path:    "/custom/:name",
  4.     Handler: CustomHandler(serverCtx),
  5. },
复制代码
此时，我们的文件结构应该是这样
  1. greet
  2. ├── etc
  3. │   └── greet-api.yaml
  4. ├── greet.api
  5. ├── greet.go
  6. └── internal
  7.     ├── config
  8.     │   └── config.go
  9.     ├── handler
  10.     │   ├── greethandler.go
  11.     │   ├── customhandler.go
  12.     │   ├── ...
  13.     │   └── routes.go
  14.     ├── logic
  15.     │   ├── greetlogic.go
  16.     │   ├── ...
  17.     │   └── customlogic.go
  18.     ├── svc
  19.     │   └── servicecontext.go
  20.     └── types
  21.         └── types.go
复制代码
当单体应用达到一定的数量级，handler和logic文件夹下将会同步增加很多的文件
引入泛型概念

自Go1.18开始，go开始使用泛型，泛型的广泛定义 ：是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。 也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，而这种参数类型可以用在 类、方法和接口 中，分别被称为 泛型类 、 泛型方法 、 泛型接口 。
我们可以利用泛型，让在添加路由时就要固定死的Handler: GreetHandler(serverCtx)推迟到后面，去根据实际的Logic结构体去判断需要真正执行的logic.NewGreetLogic(r.Context(), ctx)初始化结构体和l.Greet(req)逻辑处理方法
如何去做

  1. package logic
  3. import (
  4.         "greet/internal/svc"
  5.         "greet/internal/types"
  6.         "net/http"
  7. )
  9. type BaseLogic interface {
  10.         any
  11.         Handler(req types.Request, w http.ResponseWriter, r *http.Request, svcCtx *svc.ServiceContext) //每一个结构体中必须要继承一下Handler方法，例如customlogic.go和greetlogic.go中的Handler方法
  12. }
  14. type logic[T BaseLogic] struct {
  15.         data T
  16. }
  18. func New[T BaseLogic]() logic[T] {
  19.         c := logic[T]{}
  20.         var ins T
  21.         c.data = ins
  22.         return c
  23. }
  24. func (a *logic[T]) LogicHandler(req types.Request, w http.ResponseWriter, r *http.Request, svcCtx *svc.ServiceContext) { //作为一个中转处理方法，最终执行结构体的Handler
  25.         a.data.Handler(req, w, r, svcCtx)
  26. }
复制代码

  • 将greethandler.go文件修改成basehandler.go,注释掉之前的GreetHandler方法
  1. package handler
  3. import (
  4.         "net/http"
  6.         "greet/internal/logic"
  7.         "greet/internal/svc"
  8.         "greet/internal/types"
  10.         "github.com/zeromicro/go-zero/rest/httpx"
  11. )
  13. // func GreetHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
  14. //         return BaseHandlerFunc(svcCtx)
  15. //         // return func(w http.ResponseWriter, r *http.Request) {
  16. //         //         var req types.Request
  17. //         //         if err := httpx.Parse(r, &req); err != nil {
  18. //         //                 httpx.Error(w, err)
  19. //         //                 return
  20. //         //         }
  21. //         //         l := logic.NewGreetLogic(r.Context(), svcCtx)
  22. //         //         resp, err := l.Greet(&req)
  23. //         //         if err != nil {
  24. //         //                 httpx.Error(w, err)
  25. //         //         } else {
  26. //         //                 httpx.OkJson(w, resp)
  27. //         //         }
  28. //         // }
  29. // }
  31. func BaseHandlerFunc[T logic.BaseLogic](svcCtx *svc.ServiceContext, t T) http.HandlerFunc {
  32.         return func(w http.ResponseWriter, r *http.Request) {
  33.                 var req types.Request
  34.                 if err := httpx.Parse(r, &req); err != nil {
  35.                         httpx.Error(w, err)
  36.                         return
  37.                 }
  38.                 //通过泛型动态调用不同结构体的Handler方法
  39.                 cc := logic.New[T]()
  40.                 cc.LogicHandler(req, w, r, svcCtx)
  41.         }
  42. }
复制代码

  • 在internal\logic\greetlogic.go中增加一个Handler方法
  1. package logic
  3. import (
  4.         "context"
  5.         "net/http"
  7.         "greet/internal/svc"
  8.         "greet/internal/types"
  10.         "github.com/zeromicro/go-zero/core/logx"
  11.         "github.com/zeromicro/go-zero/rest/httpx"
  12. )
  14. type GreetLogic struct {
  15.         logx.Logger
  16.         ctx    context.Context
  17.         svcCtx *svc.ServiceContext
  18. }
  20. func NewGreetLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GreetLogic {
  21.         return &GreetLogic{
  22.                 Logger: logx.WithContext(ctx),
  23.                 ctx:    ctx,
  24.                 svcCtx: svcCtx,
  25.         }
  26. }
  27. func (a GreetLogic) Handler(req types.Request, w http.ResponseWriter, r *http.Request, svcCtx *svc.ServiceContext) { //新增方法
  28.         l := NewGreetLogic(r.Context(), svcCtx)
  29.         resp, err := l.Greet(&req)
  30.         if err != nil {
  31.                 httpx.Error(w, err)
  32.         } else {
  33.                 httpx.OkJson(w, resp)
  34.         }
  35. }
  37. func (l *GreetLogic) Greet(req *types.Request) (resp *types.Response, err error) {
  38.         // todo: add your logic here and delete this line
  39.         response := new(types.Response)
  40.         if (*req).Name == "me" {
  41.                 response.Message = "greetLogic: listen to me, thank you."
  42.         } else {
  43.                 response.Message = "greetLogic: listen to you, thank me."
  44.         }
  46.         return response, nil
  47. }
复制代码

  • 然后修改internal\handler\routes.go下面的server.AddRoutes部分
  1. func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
  2.    server.AddRoutes( //往rest.Server中添加路由
  3.         []rest.Route{ //路由数组
  4.            {
  5.               Method:  http.MethodGet,
  6.               Path:    "/from/:name", //路由
  7.               Handler: BaseHandlerFunc(serverCtx,logic.GreetLogic{}),
  8.            },
  9.         },
  10.    )
  11. }
复制代码
现在就大功告成了，我们启动一下
  1. go run greet.go -f etc/greet-api.yaml
复制代码
然后在浏览器中请求一下http://localhost:8888/from/you

验证一下新增api路由


  • 在internal\logic下新增一个customlogic.go文件
  1. package logic
  3. import (
  4.         "context"
  5.         "net/http"
  7.         "greet/internal/svc"
  8.         "greet/internal/types"
  10.         "github.com/zeromicro/go-zero/core/logx"
  11.         "github.com/zeromicro/go-zero/rest/httpx"
  12. )
  14. type CustomLogic struct {
  15.         logx.Logger
  16.         ctx    context.Context
  17.         svcCtx *svc.ServiceContext
  18. }
  20. func NewCustomLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CustomLogic {
  21.         return &CustomLogic{
  22.                 Logger: logx.WithContext(ctx),
  23.                 ctx:    ctx,
  24.                 svcCtx: svcCtx,
  25.         }
  26. }
  28. func (a CustomLogic) Handler(req types.Request, w http.ResponseWriter, r *http.Request, svcCtx *svc.ServiceContext) {
  29.         l := NewCustomLogic(r.Context(), svcCtx)
  30.         resp, err := l.Custom(&req)
  31.         if err != nil {
  32.                 httpx.Error(w, err)
  33.         } else {
  34.                 httpx.OkJson(w, resp)
  35.         }
  36. }
  38. func (l *CustomLogic) Custom(req *types.Request) (resp *types.Response, err error) { //response.Message稍微修改了一下，便于区分
  39.         // todo: add your logic here and delete this line
  40.         response := new(types.Response)
  41.         if (*req).Name == "me" {
  42.                 response.Message = "customLogic: listen to me, thank you."
  43.         } else {
  44.                 response.Message = "customLogic: listen to you, thank me."
  45.         }
  47.         return response, nil
  48. }
复制代码

  • 然后修改internal\handler\routes.go
  1. func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
  2.    server.AddRoutes( //往rest.Server中添加路由
  3.         []rest.Route{ //路由数组
  4.            {
  5.               Method:  http.MethodGet,
  6.               Path:    "/from/:name", //路由
  7.               Handler: BaseHandlerFunc(serverCtx,logic.GreetLogic{}),
  8.            },
  9.            {
  10.               Method:  http.MethodGet,
  11.               Path:    "/to/:name", //路由
  12.               Handler: BaseHandlerFunc(serverCtx,logic.CustomLogic{}),
  13.            },
  14.         },
  15.    )
  16. }
复制代码
其他地方不需要修改
我们启动一下
  1. go run greet.go -f etc/greet-api.yaml
复制代码
然后在浏览器中请求一下http://localhost:8888/from/you、http://localhost:8888/to/you、http://localhost:8888/too/you

现在，在添加新的logic做路由映射时，就可以直接简化掉添加xxxxhandler.go文件了，实际上是将这个Handler移动到了xxxxlogic.go中。
新手，不喜轻喷
本文代码放在go-zero-monolithic-service-generics


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

渣渣兔

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表