golang 上基于标头的版本控制

golang上的基于标头的版本控制是一种在开发过程中管理代码版本的有效方法。通过在代码文件的开头添加版本信息，开发人员可以方便地跟踪代码的变更和版本历史。这种版本控制方法不仅简单易用，而且适用于各种规模的项目。PHP小编西瓜将在本文中详细介绍Golang上基于标头的版本控制的使用方法和注意事项，帮助开发人员更好地管理和维护代码。无论你是初学者还是有经验的开发者，本文都将为你提供有价值的参考和指导。让我们一起来探索这个有趣而实用的版本控制技术吧！

问题内容

我想使用 gin 在 go 上实现基于标头的版本控制。我正在考虑使用中间件功能在路由器上执行此操作。

客户端将调用相同的 api url，并且版本将位于自定义 Http 标头中，如下所示：

调用版本1 获取/用户/12345678 接受版本：v1

调用版本 2： 获取/用户/12345678 接受版本：v2

因此，路由器可以识别标头并调用特定版本。像这样的事情：

router := gin.Default()

            v1 := router.Group("/v1")
            v1.Use(VersionMiddleware())
            v1.GET("/user/:id", func(c *gin.Context) {
                c.String(http.StatusOK, "This is the v1 API")
            })

            v2 := router.Group("/v2")
            v2.Use(VersionMiddleware())
            v2.GET("/user/:id", func(c *gin.Context) {
                c.String(http.StatusOK, "This is the v2 API")
            })

func VersionMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        version := c.Request.Header.Get(configuration.GetConfigValue("VersionHeader"))

        // Construct the new URL path based on the version number
        path := fmt.Sprintf("/%s%s", version, c.Request.URL.Path)

        // Modify the request URL path to point to the new version-specific endpoint
        c.Request.URL.Path = path
        c.Next()
    }
}

解决方法

请检查下面的代码片段。我使用 reverseproxy 重定向到给定的版本。您需要仔细验证给定的版本。否则会导致递归调用。

注意：我使用了两个版本的 /user get（/v1/user 和 /v2/user）。

示例代码

package main

import (
 "net/http"
 "net/http/httputil"
 "regexp"

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



func main() {
 router := gin.default()
 router.use(versionmiddleware())


 v1 := router.group("/v1")
 v1.get("/user", func(c *gin.context) {
  c.string(http.statusok, "this is the v1 api")
 })

 v2 := router.group("/v2")
 v2.get("/user", func(c *gin.context) {
  c.string(http.statusok, "this is the v2 api")
 })

 router.run(":8082")
}



func versionmiddleware() gin.handlerfunc {
    return func(c *gin.context) {
  
  // you need to check c.request.url.path whether 
  // already have a version or not, if it has a valid
  // version, return.
  regex, _ := regexp.compile("/v[0-9]+")
  ver := regex.matchstring(c.request.url.path)
  if ver {
   return
  }

  version := c.request.header.get("accept-version")
  
  // you need to validate  given version by the user here.
  // if version is not a valid version, return error 
  // mentioning that given version is invalid.

  director := func(req *http.request) {
    r := c.request
    req.url.scheme = "http"
    req.url.host = r.host
    req.url.path =  "/"+ version + r.url.path
    }
  proxy := &httputil.reverseproxy{director: director}
  proxy.servehttp(c.writer, c.request)
 }
}

或

您可以使用下面的杜松子酒包装实现。

• 示例

package main

import (
 "net/http"

 "github.com/gin-gonic/gin"
 "github.com/udayangaac/stackoverflow/golang/75860989/ginwrapper"
)



func main() {
  engine := gin.default()
 router := ginwrapper.newrouter(engine)

 defaultrouter := router.default()
 defaultrouter.get("/profile",func(ctx *gin.context) {

 })

 v1 := router.withversion("/v1")
 v1.get("/user",func(ctx *gin.context) {
  ctx.string(http.statusok, "this is the profile v1 api")
 })

 v2 := router.withversion("/v2")
 v2.get("/user",func(ctx *gin.context) {
  ctx.string(http.statusok, "this is the profile v2 api")
 })

 
 engine.run(":8082")
}

• 包装

package ginwrapper

import (
 "fmt"
 "net/http"

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

type router struct {
 router *gin.engine
 versiongroups map[string]*gin.routergroup
}

type versionedrouter struct {
 version string
 router
}

func newrouter(router *gin.engine) *router {
 return &router{
  router: router,
  versiongroups: make(map[string]*gin.routergroup),
 }
}

func (a *router) default() versionedrouter {
 return versionedrouter{router: *a }
}

func  (a *router) withversion(version string) versionedrouter {
 if _,ok := a.versiongroups[version]; ok {
  panic("cannot initialize same version multiple times")
 }
 a.versiongroups[version] = a.router.group(version)
 return versionedrouter{router: *a,version:version }
}




func (vr versionedrouter) get(relativepath string, handlers ...gin.handlerfunc)  {
 vr.handle(http.methodget,relativepath,handlers...)
}

// note: you need to follow the same for other http methods.
// as an example, we can write a method for post http method as below,
// 
//  func (vr versionedrouter) post(relativepath string, handlers ...gin.handlerfunc)  {
//   vr.handle(http.methodpost,relativepath,handlers...)
//  }





func (vr versionedrouter)handle(method,relativepath string, handlers ...gin.handlerfunc)  {
 if !vr.isrouteexist(method,relativepath) {
  vr.router.handle(method,relativepath,func(ctx *gin.context) {
   version := ctx.request.header.get("accept-version")
   if len(version) == 0 {
    ctx.string(http.statusbadrequest,"accept-version header is empty")
   }
   ctx.request.url.path = fmt.sprintf("/%s%s", version, ctx.request.url.path)
   vr.router.handlecontext(ctx)
  })
 }

 versionedrelativepath := vr.version + relativepath
 if !vr.isrouteexist(method,versionedrelativepath) {
  vr.router.handle(method,versionedrelativepath,handlers... )
 }
}


func (a versionedrouter) isrouteexist(method,relativepath string) bool {
 for _,route := range a.router.routes() {
  if route.method == method && relativepath == route.path {
   return true
  } 
 }
 return false
}

示例请求

• /v1/user

curl --location 'localhost:8082/user' \
--header 'accept-version: v1'

• /v2/user

curl --location 'localhost:8082/user' \
--header 'Accept-version: v2'

以上就是golang 上基于标头的版本控制的详细内容，更多请关注编程网其它相关文章！