使用Go实现伪静态URL重写功能

御影

目录

• 什么是伪静态URL？
  
• 实现原理
  
  
  
  • URL重写规则示例
    
  
  
• 代码实现
  
  
  
  • 路由解析
    
  • 正则表达式匹配
    
  • handler.go
    
  • service/rewrite.go
    
  
  

在Web开发中，伪静态URL已成为优化网站架构和提升SEO的常用技术手段。尤其是在内容管理系统（CMS）中，灵活的URL重写功能不仅能改善用户体验，还能帮助网站更好地与搜索引擎对接。URL的可读性和结构化直接影响搜索引擎的索引质量和排名。
在安企CMS的设计中，为了适应客户个性化的需求，伪静态URL重写功能应运而生。通过这一功能，客户可以根据业务需求自定义站点的URL格式，从而将动态URL重写为更易读的静态化URL。这种机制兼具灵活性和可扩展性，能够满足各种不同的应用场景。

什么是伪静态URL？

伪静态URL是一种介于动态URL和静态URL之间的解决方案。动态URL通常包含查询参数，如

1. ?id=123

复制代码

或

1. ?category=sports

复制代码

，而静态URL则是固定的文件路径，如

1. /article/123.html

复制代码

或

1. /sports/article-456.html

复制代码

。伪静态URL通过URL重写技术，将原本需要传递参数的动态页面转化为类似静态页面的URL格式，保留了动态页面的功能，却呈现出静态页面的URL形式。
这样做的好处包括：

• SEO优化：更简洁、关键词友好的URL格式有助于提高搜索引擎排名。
  
• 用户体验提升：更直观的URL结构让用户更容易记住和理解。
  
• 隐藏技术细节：可以避免泄露网站底层技术实现细节，提升安全性。
  

实现原理

伪静态URL重写的核心在于将客户端请求的URL路径与后端真实的资源路径进行映射。在不同的应用场景下，不同客户可能有不同的URL重写需求，安企CMS通过内置的变量和自定义规则的支持，能够灵活地满足这些需求。
例如：

• 客户A：希望文章的URL形式为
  1. /article/{id}.html

  复制代码
  ，即通过文章ID来访问内容。
  
• 客户B：希望URL形式为
  1. /article/{filename}.html

  复制代码
  ，即通过文章的文件名进行访问。
  
• 客户C：希望URL的格式更为复杂，如
  1. /{catname}/{filename}.html

  复制代码
  ，即通过分类名称和文章文件名组合。
  

为了实现这一功能，安企CMS提供了一系列内置的变量，这些变量可以用来动态生成伪静态URL。常用的变量包括：

• 1. {id}

  复制代码
  ：文章的唯一ID。
  
• 1. {filename}

  复制代码
  ：文章的文件名，通常是标题或自定义的唯一标识符。
  
• 1. {catid}

  复制代码
  ：分类的唯一ID。
  
• 1. {catname}

  复制代码
  ：文章所属的分类名称。
  
• 1. {multicatname}

  复制代码
  ：多级分类结构，适用于嵌套分类。
  
• 1. {module}

  复制代码
  ：文档模型名称，比如文章、产品、案例等。
  
• 1. {year}

  复制代码
  、
  1. {month}

  复制代码
  、
  1. {day}

  复制代码
  、
  1. {hour}

  复制代码
  、
  1. {minute}

  复制代码
  、
  1. {second}

  复制代码
  ：文章发布日期的时间戳信息。
  
• 1. {page}

  复制代码
  ：文章的分页信息，通常在栏目页中使用。
  

用户可以根据业务需求，利用这些变量轻松编写URL重写规则，实现对URL格式的完全控制。

URL重写规则示例

假设客户希望实现以下几种URL规则：

• 单文章ID访问：
  
  
  
  • 规则：
    1. /article/{id}.html

    复制代码
  • 实例URL：
    1. /article/123.html

    复制代码
  
  
• 文件名访问：
  
  
  
  • 规则：
    1. /article/{filename}.html

    复制代码
  • 实例URL：
    1. /article/how-to-code.html

    复制代码
  
  
• 分类+文件名访问：
  
  
  
  • 规则：
    1. /{catname}/{filename}.html

    复制代码
  • 实例URL：
    1. /technology/golang-introduction.html

    复制代码
  
  
• 多级分类+文件名访问：
  
  
  
  • 规则：
    1. /{multicatname}/{filename}.html

    复制代码
  • 实例URL：
    1. /programming/backend/golang-best-practices.html

    复制代码
  
  

通过以上规则，安企CMS能够自动将用户访问的URL映射到对应的后端资源，并执行动态渲染。

代码实现

在Go语言中，可以使用内置的HTTP路由机制和正则表达式进行URL重写。以下是一些核心步骤的概述：

• 路由解析：使用Go的iris框架，根据请求的URL进行匹配。
  
• 正则表达式匹配：通过正则表达式提取URL中的变量，例如从
  1. /article/{id}.html

  复制代码
  中提取
  1. id

  复制代码
  。
  
• 动态重写：根据提取到的变量和规则，将请求映射到真实的资源路径上。
  
• 重定向或处理：将请求传递给处理器函数，返回相应的HTML或JSON响应。
  

完整的代码实现通常包括定义路由规则、设置正则表达式模式，以及为每个URL模式创建对应的处理函数。这些处理函数会根据匹配到的URL参数进行数据库查询或业务逻辑处理，最后生成对应的内容输出。

路由解析

在路由解析中，我们使用

1. path

复制代码

变量来处理，因为 path 变量会匹配到任何路径。

1. func Register(app *iris.Application) {
   
2.   app.Get("/{path:path}", controller.ReRouteContext)
   
3. }

复制代码

正则表达式匹配

由于

1. path

复制代码

变量会匹配到任何路径，所以我们需要先验证文件是否存在，如果存在，则直接返回文件，而不再做正则匹配。

handler.go

函数

1. ReRouteContext

复制代码

功能是在Iris框架中处理路由验证和文件服务。首先，它解析路由参数并验证文件是否存在，如果存在则提供文件服务。如果文件不存在，则根据路由参数设置上下文参数和值，并根据匹配的路由参数执行不同的处理函数，如归档详情、分类页面或首页。如果没有匹配的路由，则返回404页面。

1. func ReRouteContext(ctx iris.Context) {
   
2.         params, _ := parseRoute(ctx)
   
3.         // 先验证文件是否真的存在，如果存在，则fileServe
   
4.         exists := FileServe(ctx)
   
5.         if exists {
   
6.                 return
   
7.         }
   
8.        
   
9.         for i, v := range params {
   
10.                 if len(i) == 0 {
    
11.                         continue
    
12.                 }
    
13.                 ctx.Params().Set(i, v)
    
14.                 if i == "page" && v > "0" {
    
15.                         ctx.Values().Set("page", v)
    
16.                 }
    
17.         }
    
18. 
    
19.         switch params["match"] {
    
20.         case "notfound":
    
21.                 // 走到 not Found
    
22.                 break
    
23.         case "archive":
    
24.                 ArchiveDetail(ctx)
    
25.                 return
    
26.                 return
    
27.         case "category":
    
28.                 CategoryPage(ctx)
    
29.                 return
    
30.         case "index":
    
31.                 IndexPage(ctx)
    
32.                 return
    
33.                 return
    
34.         }
    
35. 
    
36.         //如果没有合适的路由，则报错
    
37.         NotFound(ctx)
    
38. }

复制代码

该函数 FileServe 的作用如下：
获取请求路径。 检查路径是否指向公共目录下的文件。 如果文件存在，则直接提供该静态文件。 返回 true 如果文件被成功提供，否则返回 false。

1. // FileServe 静态文件处理，静态文件存放在public目录中，因此访问路径为/public/xxx
   
2. func FileServe(ctx iris.Context) bool {
   
3.         uri := ctx.RequestPath(false)
   
4.         if uri != "/" && !strings.HasSuffix(uri, "/") {
   
5.                 baseDir := fmt.Sprintf("%spublic", RootPath)
   
6.                 uriFile := baseDir + uri
   
7.                 _, err := os.Stat(uriFile)
   
8.                 if err == nil {
   
9.                         ctx.ServeFile(uriFile)
   
10.                         return true
    
11.                 }
    
12.         }
    
13.        
    
14.         return false
    
15. }

复制代码

函数 parseRoute 用于解析路由路径，并根据不同的路径模式填充映射matchMap。主要步骤如下：
获取请求中的path参数值。 如果path为空，则匹配“首页”。 如果path以uploads/或static/开头，则直接返回，表示静态资源。 使用正则表达式匹配path： 对于“分类”规则，提取相关信息并存储至matchMap。 验证提取的“模块”是否存在，以及是否与“分类”冲突。 若匹配成功，返回结果。 对于“文档”规则，执行类似的匹配逻辑。 如果所有规则都不匹配，则标记为“未找到”。 最终返回填充后的matchMap和一个布尔值true。

1. // parseRoute 正则表达式解析路由
   
2. func parseRoute(ctx iris.Context) (map[string]string, bool) {
   
3.         //这里总共有2条正则规则，需要逐一匹配
   
4.         // 由于用户可能会采用相同的配置，因此这里需要尝试多次读取
   
5.         matchMap := map[string]string{}
   
6.         paramValue := ctx.Params().Get("path")
   
7.         // index
   
8.         if paramValue == "" {
   
9.                 matchMap["match"] = "index"
   
10.                 return matchMap, true
    
11.         }
    
12.         // 静态资源直接返回
    
13.         if strings.HasPrefix(paramValue, "uploads/") ||
    
14.                 strings.HasPrefix(paramValue, "static/") {
    
15.                 return matchMap, true
    
16.         }
    
17.         rewritePattern := service.ParsePatten(false)
    
18.         //category
    
19.         reg = regexp.MustCompile(rewritePattern.CategoryRule)
    
20.         match = reg.FindStringSubmatch(paramValue)
    
21.         if len(match) > 1 {
    
22.                 matchMap["match"] = "category"
    
23.                 for i, v := range match {
    
24.                         key := rewritePattern.CategoryTags[i]
    
25.                         if i == 0 {
    
26.                                 key = "route"
    
27.                         }
    
28.                         matchMap[key] = v
    
29.                 }
    
30.                 if matchMap["catname"] != "" {
    
31.                         matchMap["filename"] = matchMap["catname"]
    
32.                 }
    
33.                 if matchMap["multicatname"] != "" {
    
34.                         chunkCatNames := strings.Split(matchMap["multicatname"], "/")
    
35.                         matchMap["filename"] = chunkCatNames[len(chunkCatNames)-1]
    
36.                 }
    
37.                 if matchMap["module"] != "" {
    
38.                         // 需要先验证是否是module
    
39.                         module := service.GetModuleFromCacheByToken(matchMap["module"])
    
40.                         if module != nil {
    
41.                                 if matchMap["filename"] != "" {
    
42.                                         // 这个规则可能与下面的冲突，因此检查一遍
    
43.                                         category := service.GetCategoryFromCacheByToken(matchMap["filename"])
    
44.                                         if category != nil {
    
45.                                                 return matchMap, true
    
46.                                         }
    
47.                                 } else {
    
48.                                         return matchMap, true
    
49.                                 }
    
50.                         }
    
51.                 } else {
    
52.                         if matchMap["filename"] != "" {
    
53.                                 // 这个规则可能与下面的冲突，因此检查一遍
    
54.                                 category := service.GetCategoryFromCacheByToken(matchMap["filename"])
    
55.                                 if category != nil {
    
56.                                         return matchMap, true
    
57.                                 }
    
58.                         } else {
    
59.                                 return matchMap, true
    
60.                         }
    
61.                 }
    
62.                 matchMap = map[string]string{}
    
63.         }
    
64.         //最后archive
    
65.         reg = regexp.MustCompile(rewritePattern.ArchiveRule)
    
66.         match = reg.FindStringSubmatch(paramValue)
    
67.         if len(match) > 1 {
    
68.                 matchMap["match"] = "archive"
    
69.                 for i, v := range match {
    
70.                         key := rewritePattern.ArchiveTags[i]
    
71.                         if i == 0 {
    
72.                                 key = "route"
    
73.                         }
    
74.                         matchMap[key] = v
    
75.                 }
    
76.                 if matchMap["module"] != "" {
    
77.                         // 需要先验证是否是module
    
78.                         module := service.GetModuleFromCacheByToken(matchMap["module"])
    
79.                         if module != nil {
    
80.                                 return matchMap, true
    
81.                         }
    
82.                 } else {
    
83.                         return matchMap, true
    
84.                 }
    
85.         }
    
86. 
    
87.         //不存在，定义到notfound
    
88.         matchMap["match"] = "notfound"
    
89.         return matchMap, true
    
90. }

复制代码

service/rewrite.go

代码主要功能是解析和应用URL重写规则。定义了结构体RewritePattern和相关操作，以解析配置中的URL模式，并生成正则表达式规则，用于匹配和重写URL。
结构体RewritePattern：
该结构体包含了一些字段，用于存储档案和分类的规则及其标签。 Archive和Category字段存储档案和分类的基本路径模式。 ArchiveRule和CategoryRule字段存储处理后的正则表达式规则。 ArchiveTags和CategoryTags字段分别存储档案和分类中可变部分（标签）的具体内容。 Parsed字段标记该模式是否已经被解析过。 结构体replaceChar和变量needReplace：
replaceChar结构体用于存储需要被转义的字符及其转义后的值。 needReplace变量定义了一组需要转义的字符，如/、*、+等。
变量replaceParams：
replaceParams是一个映射，用于存储URL模式中的变量及其对应的正则表达式。如{id}对应([\d]+)，即匹配一个或多个数字。
函数GetRewritePatten：
该函数用于获取或重用已解析的URL重写模式。如果parsedPatten不为空且不需要重新解析，则直接返回；否则，调用parseRewritePatten进行解析。
函数parseRewritePatten：
该函数解析原始的URL模式字符串，将其拆分为档案和分类的部分，并存储到RewritePattern实例中。
函数ParsePatten：
该函数执行具体的解析操作，包括替换特殊字符、应用变量对应的正则表达式，并将最终的规则应用到相应的字段中。

1. type RewritePatten struct {
   
2.         Archive      string `json:"archive"`
   
3.         Category     string `json:"category"`
   
4. 
   
5.         ArchiveRule      string
   
6.         CategoryRule     string
   
7. 
   
8.         ArchiveTags      map[int]string
   
9.         CategoryTags     map[int]string
   
10.         Parsed bool
    
11. }
    
12. 
    
13. 
    
14. type replaceChar struct {
    
15.         Key   string
    
16.         Value string
    
17. }
    
18. 
    
19. var needReplace = []replaceChar{
    
20.         {Key: "/", Value: "\\/"},
    
21.         {Key: "*", Value: "\\*"},
    
22.         {Key: "+", Value: "\\+"},
    
23.         {Key: "?", Value: "\\?"},
    
24.         {Key: ".", Value: "\\."},
    
25.         {Key: "-", Value: "\\-"},
    
26.         {Key: "[", Value: "\\["},
    
27.         {Key: "]", Value: "\\]"},
    
28.         {Key: ")", Value: ")?"}, //fix?  map无序，可能会出现?混乱
    
29. }
    
30. 
    
31. var replaceParams = map[string]string{
    
32.         "{id}":           "([\\d]+)",
    
33.         "{filename}":     "([^\\/]+?)",
    
34.         "{catname}":      "([^\\/]+?)",
    
35.         "{multicatname}": "(.+?)",
    
36.         "{module}":       "([^\\/]+?)",
    
37.         "{catid}":        "([\\d]+)",
    
38.         "{year}":         "([\\d]{4})",
    
39.         "{month}":        "([\\d]{2})",
    
40.         "{day}":          "([\\d]{2})",
    
41.         "{hour}":         "([\\d]{2})",
    
42.         "{minute}":       "([\\d]{2})",
    
43.         "{second}":       "([\\d]{2})",
    
44.         "{page}":         "([\\d]+)",
    
45. }
    
46. 
    
47. var parsedPatten *RewritePatten
    
48. 
    
49. func GetRewritePatten(focus bool) *RewritePatten {
    
50.         if parsedPatten != nil && !focus {
    
51.                 return parsedPatten
    
52.         }
    
53.        
    
54.   parsedPatten = parseRewritePatten(PluginRewrite.Patten)
    
55. 
    
56.         return parsedPatten
    
57. }
    
58. 
    
59. // parseRewritePatten 才需要解析
    
60. // 一共2行,分别是文章详情、分类,===和前面部分不可修改。
    
61. // 变量由花括号包裹{},如{id}。可用的变量有:数据ID {id}、数据自定义链接名 {filename}、分类自定义链接名 {catname}、分类ID {catid},分页ID {page}，分页需要使用()处理，用来首页忽略。如：(/{page})或(_{page})
    
62. func parseRewritePatten(patten string) *RewritePatten {
    
63.         parsedPatten := &RewritePatten{}
    
64.         // 再解开
    
65.         pattenSlice := strings.Split(patten, "\n")
    
66.         for _, v := range pattenSlice {
    
67.                 singlePatten := strings.Split(v, "===")
    
68.                 if len(singlePatten) == 2 {
    
69.                         val := strings.TrimSpace(singlePatten[1])
    
70. 
    
71.                         switch strings.TrimSpace(singlePatten[0]) {
    
72.                         case "archive":
    
73.                                 parsedPatten.Archive = val
    
74.                         case "category":
    
75.                                 parsedPatten.Category = val
    
76.                         }
    
77.                 }
    
78.         }
    
79.        
    
80.         return parsedPatten
    
81. }
    
82. 
    
83. var mu sync.Mutex
    
84. 
    
85. func ParsePatten(focus bool) *RewritePatten {
    
86.         mu.Lock()
    
87.         defer mu.Unlock()
    
88.         GetRewritePatten(focus)
    
89.         if parsedPatten.Parsed {
    
90.                 return parsedPatten
    
91.         }
    
92. 
    
93.         parsedPatten.ArchiveTags = map[int]string{}
    
94.         parsedPatten.CategoryTags = map[int]string{}
    
95. 
    
96.         pattens := map[string]string{
    
97.                 "archive":      parsedPatten.Archive,
    
98.                 "category":     parsedPatten.Category,
    
99.         }
    
100. 
     
101.         for key, item := range pattens {
     
102.                 n := 0
     
103.                 str := ""
     
104.                 for _, v := range item {
     
105.                         if v == '{' {
     
106.                                 n++
     
107.                                 str += string(v)
     
108.                         } else if v == '}' {
     
109.                                 str = strings.TrimLeft(str, "{")
     
110.                                 if str == "page" {
     
111.                                         //page+1
     
112.                                         n++
     
113.                                 }
     
114.                                 switch key {
     
115.                                 case "archive":
     
116.                                         parsedPatten.ArchiveTags[n] = str
     
117.                                 case "category":
     
118.                                         parsedPatten.CategoryTags[n] = str
     
119.                                 }
     
120.                                 //重置
     
121.                                 str = ""
     
122.                         } else if str != "" {
     
123.                                 str += string(v)
     
124.                         }
     
125.                 }
     
126.         }
     
127. 
     
128.         //移除首个 /
     
129.         parsedPatten.ArchiveRule = strings.TrimLeft(parsedPatten.Archive, "/")
     
130.         parsedPatten.CategoryRule = strings.TrimLeft(parsedPatten.Category, "/")
     
131. 
     
132.         for _, r := range needReplace {
     
133.                 if strings.Contains(parsedPatten.ArchiveRule, r.Key) {
     
134.                         parsedPatten.ArchiveRule = strings.ReplaceAll(parsedPatten.ArchiveRule, r.Key, r.Value)
     
135.                 }
     
136.                 if strings.Contains(parsedPatten.CategoryRule, r.Key) {
     
137.                         parsedPatten.CategoryRule = strings.ReplaceAll(parsedPatten.CategoryRule, r.Key, r.Value)
     
138.                 }
     
139.         }
     
140. 
     
141.         for s, r := range replaceParams {
     
142.                 if strings.Contains(parsedPatten.ArchiveRule, s) {
     
143.                         parsedPatten.ArchiveRule = strings.ReplaceAll(parsedPatten.ArchiveRule, s, r)
     
144.                 }
     
145.                 if strings.Contains(parsedPatten.CategoryRule, s) {
     
146.                         parsedPatten.CategoryRule = strings.ReplaceAll(parsedPatten.CategoryRule, s, r)
     
147.                 }
     
148.         }
     
149.         //修改为强制包裹
     
150.         parsedPatten.ArchiveRule = fmt.Sprintf("^%s$", parsedPatten.ArchiveRule)
     
151.         parsedPatten.CategoryRule = fmt.Sprintf("^%s$", parsedPatten.CategoryRule)
     
152.         parsedPatten.PageRule = fmt.Sprintf("^%s$", parsedPatten.PageRule)
     
153.         parsedPatten.ArchiveIndexRule = fmt.Sprintf("^%s$", parsedPatten.ArchiveIndexRule)
     
154.         parsedPatten.TagIndexRule = fmt.Sprintf("^%s$", parsedPatten.TagIndexRule)
     
155.         parsedPatten.TagRule = fmt.Sprintf("^%s$", parsedPatten.TagRule)
     
156. 
     
157.         //标记替换过
     
158.   parsedPatten.Parsed = true
     
159. 
     
160.         return parsedPatten
     
161. }

复制代码

通过这篇文章介绍伪静态URL重写的基本原理、应用场景以及在Go语言中的实现思路。对于开发者来说，了解并灵活应用这一技术将有助于创建更加优化和用户友好的Web系统。
以上就是使用Go实现伪静态URL重写功能的详细内容，更多关于Go URL重写的资料请关注晓枫资讯其它相关文章！

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

蓬杰秀

顶顶更健康！！！

胡寒

感谢楼主，顶。

申屠慧心

路过，支持一下