Go 装饰器模式在 API 服务程序中的使用

简介: Golang 开发 API server  Go 语言是由谷歌主导并开源的编程语言,和 C 语言有不少相似之处,都强调执行效率,语言结构尽量简单,也都主要用来解决相对偏底层的问题。
img_b2351bb8e203f6f078c8e6183dac8833.png
Golang 开发 API server

  Go 语言是由谷歌主导并开源的编程语言,和 C 语言有不少相似之处,都强调执行效率,语言结构尽量简单,也都主要用来解决相对偏底层的问题。因为 Go 简洁的语法、较高的开发效率和 goroutine,有一段时间也在 Web 开发上颇为流行。由于工作的关系,我最近也在用 Go 开发 API 服务。但对于 Golang 这种奉行极简主义的语言,如何提高代码复用率就会成为一个很大的挑战,API server 中的大量接口很可能有完全一致的逻辑,如果不解决这个问题,代码会变得非常冗余和难看。

Python 中的装饰器

  在 Python 中,装饰器功能非常好的解决了这个问题,下面的伪代码中展示了一个例子,检查 token 的逻辑放在了装饰器函数 check_token 里,在接口函数上加一个 @check_token 就可以在进入接口函数逻辑前,先检查 token 是否有效。虽然说不用装饰器一样可以将公共逻辑抽取出来,但是调用还是要写在每个接口函数的函数体里,侵入性明显大于使用装饰器的方式。

# 装饰器函数,用来检查客户端的 token 是否有效。
def check_token(): 
    ...

@check_token
# 接口函数,用来让用户登陆。
def login():
    ...

@check_token
# 接口函数,查询用户信息。
def get_user():
    ...

Go 中装饰器的应用

  Go 语言也是可以使用相同的思路来解决这个问题的,但因为 Go 没有提供象 Python 一样便利的语法支持,所以很难做到像 Python 那样漂亮,不过我觉得解决问题才是更重要的,让我们一起来看看是如何做到的吧。

  以下的 API 服务代码示例是基于 Gin-Gonic 框架,对 Gin 不太熟悉的朋友,可以参考我之前翻译的一篇文章:如何使用 Gin 和 Gorm 搭建一个简单的 API 服务器 (一)
  本文中的代码为了方便展示,我做了些简化,完整版见于 https://github.com/blackpiglet/go-api-example

简单示例

  Go 语言实现装饰器的道理并不复杂,CheckParamAndHeader 实现了一个高阶函数,入参 h 是 gin 的基本函数类型 gin.HandlerFunc。返回值是一个匿名函数,类型也是 gin.HandlerFunc。CheckParamAndHeader 中除了运行自己的代码,也调用了作为入参传递进来的 h 函数。

package main

import (
        "fmt"

        "github.com/gin-gonic/gin"
)

func CheckParamAndHeader(h gin.HandlerFunc) gin.HandlerFunc {
        return func(c *gin.Context) {
                header := c.Request.Header.Get("token")
                if header == "" {
                        c.JSON(200, gin.H{
                                "code":   3,  
                                "result": "failed",
                                "msg":    ". Missing token",
                        })  
                        return
                }   
        }   
}

func Login(c *gin.Context) {
        c.JSON(200, gin.H{
                "code":   0,  
                "result": "success",
                "msg":    "验证成功",
        })  
}

func main() {
        r := gin.Default()
        r.POST("/v1/login", CheckParamAndHeader(Login))
        r.Run(":8080")
}

装饰器的 pipeline

  装饰器的功能已经实现了,但如果接口函数需要调用多个装饰,那么函数套函数,还是比较乱,可以写一个装饰器处理函数来简化代码,将装饰器及联起来,这样代码变得简洁了不少。

package main

import (
    "fmt"

    "github.com/gin-gonic/gin"
)

func Decorator(h gin.HandlerFunc, decors ...HandlerDecoratored) gin.HandlerFunc {
    for i := range decors {
        d := decors[len(decors)-1-i] // iterate in reverse
        h = d(h)
    }
    return h
}

func CheckParamAndHeader(h gin.HandlerFunc) gin.HandlerFunc {
    return func(c *gin.Context) {
        header := c.Request.Header.Get("token")
        if header == "" {
            c.JSON(200, gin.H{
                "code":   3,
                "result": "failed",
                "msg":    ". Missing token",
            })
            return
        }
    }
}

func CheckParamAndHeader_1(h gin.HandlerFunc) gin.HandlerFunc {
    return func(c *gin.Context) {
        header := c.Request.Header.Get("auth")
        if header == "" {
            c.JSON(200, gin.H{
                "code":   3,
                "result": "failed",
                "msg":    ". Missing auth",
            })
            return
        }
    }
}

func Login(c *gin.Context) {
    c.JSON(200, gin.H{
        "code":   0,
        "result": "success",
        "msg":    "验证成功",
    })
}

func main() {
    r := gin.Default()
    r.POST("/v1/login", Decorator(CheckParamAndHeader, CheckParamAndHeader_1, Login))
    r.Run(":8080")
}

根据接口名称判断用户是否有权限访问

  API 服务程序可能会需要判断用户是否有权限访问接口,如果使用了 MVC 模式,就需要根据接口所在的 module 和接口自己的名称来判断用户能否访问,这就要求在装饰器函数中知道被调用的接口函数名称是什么,这点可以通过 Go 自带的 runtime 库来实现。

package main

import (
    "fmt"
    "runtime"
    "strings"

    "github.com/gin-gonic/gin"
)

func Decorator(h gin.HandlerFunc, decors ...HandlerDecoratored) gin.HandlerFunc {
    for i := range decors {
        d := decors[len(decors)-1-i] // iterate in reverse
        h = d(h)
    }
    return h
}

func CheckParamAndHeader(h gin.HandlerFunc) gin.HandlerFunc {
    return func(c *gin.Context) {
        header := c.Request.Header.Get("token")
        if header == "" {
            c.JSON(200, gin.H{
                "code":   3,
                "result": "failed",
                "msg":    "Missing token",
            })
            return
        }
    }
}

func CheckPermission(h gin.HandlerFunc) gin.HandlerFunc {
    return func(c *gin.Context) {
        function_name_str := runtime.FuncForPC(reflect.ValueOf(input).Pointer()).Name()

        function_name_array := strings.Split(function_name_str, "/")
        module_method := strings.Split(function_name_array[len(function_name_array)-1], ".")
        module := module_method[0]
        method := module_method[1]

        if module != "Login" {
            c.JSON(200, gin.H{
                "code":   2,
                "result": "failed",
                "msg":    "No permission",
            })
            return
        }
    }
}

func Login(c *gin.Context) {
    c.JSON(200, gin.H{
        "code":   0,
        "result": "success",
        "msg":    "验证成功",
    })
}

func main() {
    r := gin.Default()
    r.POST("/v1/login", Decorator(CheckParamAndHeader, CheckPermission, Login))
    r.Run(":8080")
}

向装饰器函数传参

  接口可能会有要求客户端必须传某些特定的参数或者消息头,而且很可能每个接口的必传参数都不一样,这就要求装饰器函数可以接收参数,不过我目前还没有找到在 pipeline 的方式下传参的方法,只能使用最基本的方式。

package main

import (
    "fmt"
    "runtime"
    "strconv"
    "strings"

    "github.com/gin-gonic/gin"
)

func CheckParamAndHeader(input gin.HandlerFunc, http_params ...string) gin.HandlerFunc {
    return func(c *gin.Context) {
        http_params_local := append([]string{"param:user_id", "header:token"}, http_params...)
        required_params_str := strings.Join(http_params_local, ", ")
        required_params_str = "Required parameters include: " + required_params_str
        fmt.Println(http_params_local, required_params_str, len(http_params_local))

        for _, v := range http_params_local {
            ret := strings.Split(v, ":")

            switch ret[0] {
            case "header":
                header := c.Request.Header.Get(ret[1])

                if header == "" {
                    c.JSON(200, gin.H{
                        "code":   3,
                        "result": "failed",
                        "msg":    required_params_str + ". Missing " + v,
                    })
                    return
                }
            case "param":
                _, err := c.GetQuery(ret[1])
                if err == false {
                    c.JSON(200, gin.H{
                        "code":   3,
                        "result": "failed",
                        "msg":    required_params_str + ". Missing " + v,
                    })
                    return

                }
            case "body":
                body_param := c.PostForm(ret[1])

                if body_param == "" {
                    c.JSON(200, gin.H{
                        "code":   3,
                        "result": "failed",
                        "msg":    required_params_str + ". Missing " + v,
                    })
                    return
                }
            default:
                fmt.Println("Unsupported checking type: %s", ret[0])
            }
        }
        input(c)
    }
}

func CheckPermission(h gin.HandlerFunc) gin.HandlerFunc {
    return func(c *gin.Context) {
        function_name_str := runtime.FuncForPC(reflect.ValueOf(input).Pointer()).Name()

        function_name_array := strings.Split(function_name_str, "/")
        module_method := strings.Split(function_name_array[len(function_name_array)-1], ".")
        module := module_method[0]
        method := module_method[1]

        if module != "Login" {
            c.JSON(200, gin.H{
                "code":   2,
                "result": "failed",
                "msg":    "No permission",
            })
            return
        }
    }
}

func Login(c *gin.Context) {
    c.JSON(200, gin.H{
        "code":   0,
        "result": "success",
        "msg":    "验证成功",
    })
}

func main() {
    r := gin.Default()
    r.POST("/v1/login", CheckParamAndHeader(CheckPermission(Login), "body:password", "body:name"))
    r.Run(":8080")
}

  到目前为止,已经实现了我对 API 服务器的基本需求,如果大家有更好的实现方式,烦请赐教,有什么我没想到的需求,也欢迎留言讨论。

  本文主要参考以下两篇文章:
  GO语言的修饰器编程
  Decorated functions in Go
  尤其推荐左耳朵耗子的 GO语言的修饰器编程,里面还谈到了装饰器的范型,让装饰器更加通用。

目录
相关文章
|
1月前
|
人工智能 Serverless API
一键服务化:从魔搭开源模型到OpenAI API服务
在多样化大模型的背后,OpenAI得益于在领域的先发优势,其API接口今天也成为了业界的一个事实标准。
一键服务化:从魔搭开源模型到OpenAI API服务
|
14天前
|
JSON Go API
使用Go语言和Gin框架构建RESTful API:GET与POST请求示例
使用Go语言和Gin框架构建RESTful API:GET与POST请求示例
|
14天前
|
Kubernetes Go 持续交付
一个基于Go程序的持续集成/持续部署(CI/CD)
本教程通过一个简单的Go程序示例,展示了如何使用GitHub Actions实现从代码提交到Kubernetes部署的CI/CD流程。首先创建并版本控制Go项目,接着编写Dockerfile构建镜像,再配置CI/CD流程自动化构建、推送Docker镜像及部署应用。此流程基于GitHub仓库,适用于快速迭代开发。
32 3
|
14天前
|
Kubernetes 持续交付 Go
创建一个基于Go程序的持续集成/持续部署(CI/CD)流水线
创建一个基于Go程序的持续集成/持续部署(CI/CD)流水线
|
1月前
|
Go API 开发者
深入探讨:使用Go语言构建高性能RESTful API服务
在本文中,我们将探索Go语言在构建高效、可靠的RESTful API服务中的独特优势。通过实际案例分析,我们将展示Go如何通过其并发模型、简洁的语法和内置的http包,成为现代后端服务开发的有力工具。
|
13天前
|
IDE Go 数据处理
Go to Learn Go之第一个Go程序
Go to Learn Go之第一个Go程序
18 0
|
2月前
|
API Java Python
API的神秘面纱:从零开始构建你的RESTful服务
【8月更文挑战第31天】在现代网络应用开发中,RESTful API已成为数据交互的标准。本文通过比较流行的技术栈(如Node.js、Python的Django和Flask、Java的Spring Boot)及其框架,帮助你理解构建RESTful API的关键差异,涵盖性能、可扩展性、开发效率、社区支持、安全性和维护性等方面,并提供示例代码和最佳实践,指导你选择最适合项目需求的工具,构建高效、安全且易维护的API服务。
40 0
|
2月前
|
Java 缓存 数据库连接
揭秘!Struts 2性能翻倍的秘诀:不可思议的优化技巧大公开
【8月更文挑战第31天】《Struts 2性能优化技巧》介绍了提升Struts 2 Web应用响应速度的关键策略,包括减少配置开销、优化Action处理、合理使用拦截器、精简标签库使用、改进数据访问方式、利用缓存机制以及浏览器与网络层面的优化。通过实施这些技巧,如懒加载配置、异步请求处理、高效数据库连接管理和启用GZIP压缩等,可显著提高应用性能,为用户提供更快的体验。性能优化需根据实际场景持续调整。
54 0
|
2月前
|
存储 缓存 安全
|
3天前
|
存储 Go 容器
深入探究Go语言中的数据结构
深入探究Go语言中的数据结构
14 3