文章目录
- 模板渲染
- 静态文件支持
- HTML 模板渲染
- 错误恢复
- 完结撒花~~
前情提示：
【Golang学习笔记】从零开始搭建一个Web框架（一）-CSDN博客
【Golang学习笔记】从零开始搭建一个Web框架（二）-CSDN博客
【Golang学习笔记】从零开始搭建一个Web框架（三）-CSDN博客
模板渲染
在网页开发中，模板是指一种包含了静态文本和特定标记或占位符的文件。模板渲染是指在服务器端在模板中插入动态数据并生成最终的 HTML 页面的过程，而不是像传统的前后端耦合模式那样在客户端进行渲染。服务器会将最终生成完整的 HTML 页面发送给客户端。由于搜索引擎爬虫能够直接获取服务端渲染的 HTML 页面，因此这种方式对搜索引擎优化（SEO）更加友好，有利于网站的收录和排名。
静态文件支持
要实现模板渲染，服务器需要能够读取并返回像css、js这样的静态文件。接下来需要实现文件目录的路由注册方法，当请求路径中的文件在绑定的文件目录中时，将文件返回。
先来看一下使用net/http包如何实现文件服务器。
新建static/template/welcome.html文件，并写入下面内容：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>welcome</title>
</head>
<body>
<h1>Welcome! {{.name}}</h1>
<p id="counter">0</p>
<button id="incrementBtn">Increment</button>
<!--加载js文件,src可以简写为"/static/script.js" -->
<script src="http://127.0.0.1:8080/static/script.js"></script>
</body>
</html>
新建static/template/script.js文件,并写入：
// 获取计数器元素和按钮元素
var counterElement = document.getElementById("counter");
var incrementButton = document.getElementById("incrementBtn");
// 初始化计数器值
var count = 0;
// 点击按钮时增加计数器的值
incrementButton.addEventListener("click", function() {
count++; // 增加计数器的值
counterElement.innerText = count; // 更新计数器元素的文本内容
});
当前目录结构为：
myframe/
├── kilon/
│ ├── context.go
│ ├── go.mod [1]
│ ├── kilon.go
│ ├── klogger.go
│ ├── router.go
│ ├── tire.go
├── static/
│ ├── template/
│ │ ├── script.js
│ │ ├── welcome.html
├── go.mod [2]
├── main.go
在main.go中写入：
package main
import (
"net/http"
)
func main() {
prefix := "/static" // 设定的路由前缀
filesystem := http.Dir("static/template") // 将文件路径转换为http.Dir类型
fileserve := http.StripPrefix(prefix, http.FileServer(filesystem))
http.Handle("/static/", fileserve)
http.ListenAndServe(":8080", nil)
}
http.Dir("static/template")：将文件地址转换为http.Dir类型
http.FileServer(filesystem)：返回一个文件处理器，里面实现了ServeHTTP接口，调用他的ServeHTTP方法会将请求路径指向的文件返回。
http.StripPrefix(prefix, http.FileServer(filesystem)) ：对文件处理器做进一步处理，将路由请求中的路由前缀去掉再传给文件处理器，这是因为文件处理器需要接受一个相对地址，而不是路由地址
http.Handle("/static/", fileserve)：将创建的文件处理器注册到DefaultServeMux中，路由"/static/"上的请求都会调用fileserve中的ServeHTTP方法进行处理。(注：路由不能是"/static"因为这样只有"/static"会调用注册的处理器而/static/*不会。)
运行后访问http://localhost:8080/static/welcome.html就可以看到页面。
这样就很明晰了，只要创建一个文件处理器，然后在接受请求的时候调用这个处理器的ServeHTTP方法就行了
打开kilon.go，先添加一个闭包，用于返回一个处理文件请求的处理函数：
// 创建一个处理文件请求的handler。comp是用户定义的部分路由，最后的路由地址需要加上所属分组路由前缀
func (group *RouterGroup) creatStaticHandler(comp string, fs http.FileSystem) HandlerFunc {
// 将分组路由前缀与用户定义的部分路由合并成路由地址
pattern := path.Join(group.prefix, comp)
// 创建会提取文件路径的文件处理器
fileServer := http.StripPrefix(pattern, http.FileServer(fs))
// 将处理文件请求的handler返回
return func(ctx *Context) {
file := ctx.Param("filepath")
if _, err := fs.Open(file); err != nil {
ctx.Status(http.StatusNotFound)
return // 如果找不到文件返回404状态码
}
// 调用文件处理器的ServeHTTP方法，里面已经实现文件返回逻辑
fileServer.ServeHTTP(ctx.Writer, ctx.Req)
}
}
再编写提供给用户挂载静态资源的方法：
// 挂载静态资源，root是需要挂载的静态资源目录
func (group *RouterGroup) Static(comp string, root string) {
handler := group.creatStaticHandler(comp, http.Dir(root)) // 创建处理文件请求的处理函数
urlPattern := path.Join(comp, "/*filepath") // 构造动态路由地址
group.GET(urlPattern, handler) // 路由注册
}
至此实现了静态文件支持功能。在main.go中测试：
package main
import (
"kilon"
)
func main() {
r := kilon.New()
r.Static("/static", "static/template")
r.Run(":8080")
}
访问http://localhost:8080/static/welcome.html，可以看到返回的html页面。
HTML 模板渲染
Go语言内置了text/template和html/template2个模板标准库，其中html/template为 HTML 提供了较为完整的支持。包括普通变量渲染、列表渲染、对象渲染等。这里直接使用html/template提供的能力。
现在需要在引擎中添加template.Template 和 template.FuncMap对象，前者可以将html加载进内存，后者可以对内存中的html进行渲染。
type Origin struct {
*RouterGroup
router *router
groups []*RouterGroup
htmlTemplates *template.Template // 添加
funcMap template.FuncMap // 添加
}
然后添加两个方法：
// 用于注册模板函数到模板引擎中
func (origin *Origin) SetFuncMap(funcMap template.FuncMap){
origin.funcMap = funcMap
}
// 用于加载指定路径的内容，并将其解析为模板对象。
func (origin *Origin) LoadHTMLGlob(pattern string){
origin.htmlTemplates = template.Must(template.New("").Funcs(origin.funcMap).ParseGlob(pattern))
}
当返回HTML内容时需要调用Context的HTML方法，因为模板对象在引擎中，为了让上下文对象可以便捷地获取到模板对象，将引擎也放入上下文对象中：
type Context struct {
Writer http.ResponseWriter
Req *http.Request
Path string
Method string
Params map[string]string
StatusCode int
index int
handlers []HandlerFunc
origin *Origin // 添加
}
在创建上下文对象时设置引擎：
func (origin *Origin) ServeHTTP(w http.ResponseWriter, req *http.Request) {
// ...
ctx := newContext(w, req)
ctx.handlers = middlewares
ctx.origin = origin // 设置引擎对象
origin.router.handle(ctx)
}
接下来增强Context的HTML方法，让它可以渲染HTML：
func (c *Context) HTML(code int, name string, data interface{}) {
c.SetHeader("Content-Type", "text/html")
c.Status(code)
if err := c.origin.htmlTemplates.ExecuteTemplate(c.Writer, name, data); err != nil {
c.Fail(500, err.Error())
}
}
在main.go中测试一下
package main
import (
"kilon"
"net/http"
)
func main() {
r := kilon.New()
r.LoadHTMLGlob("static/template/*")
r.Static("/static", "static/template")
r.GET("/:name", func(c *kilon.Context) {
c.HTML(http.StatusOK, "welcome.html", kilon.H{
"name": c.Param("name"),
})
})
r.Run(":8080")
}
访问http://127.0.0.1:8080/zhangsan 可以看到：
错误恢复
对一个Web框架而言，错误恢复是非常重要的，因为如果用户注册的函数出现了数组越界等错误，整个Web服务就会宕机。下面将在中间件中使用defer+recover组合为框架添加错误恢复的功能，并简单打印错误信息。
新建文件recover.go，当前目录结构为：
myframe/
├── kilon/
│ ├── context.go
│ ├── go.mod [1]
│ ├── kilon.go
│ ├── klogger.go
│ ├── recover.go
│ ├── router.go
│ ├── tire.go
├── static/
│ ├── template/
│ │ ├── script.js
│ │ ├── welcome.html
├── go.mod [2]
├── main.go
在revober.go 中写入：
package kilon
import (
"fmt"
"log"
"net/http"
"runtime"
)
func Recovery() HandlerFunc {
return func(c *Context) {
defer func() {
if err := recover(); err != nil {
message := fmt.Sprintf("%s", err) // 获取错误信息
buf := make([]byte, 1024)
n := runtime.Stack(buf, false) // 获取堆栈信息
log.Printf("%s\n", message) // 打印错误信息
log.Printf("%s\n", buf[:n]) // 打印堆栈信息
c.Fail(http.StatusInternalServerError, "Internal Server Error") // 返回服务器错误给客户端
}
}()
c.Next()
}
}
最后给引擎的获取与默认中间件的注册再包装一层方法，在kilon.go中添加Default方法：
func Default() *Origin {
origin := New()
origin.Use(Logger(), Recovery()) // 注册中间件
return origin
}
在main.go中测试：
package main
import (
"net/http"
"kilon"
)
func main() {
r := kilon.Default()
r.GET("/", func(c *kilon.Context) {
c.String(http.StatusOK, "Hello World\n")
})
r.GET("/panic", func(c *kilon.Context) {
names := []string{"Hello_World"}
c.String(http.StatusOK, names[100])
})
r.Run(":8080")
}
访问127.0.0.1:8080/panic可以看到响应信息：
{
"message": "Internal Server Error"
}
并在控制台看到错误信息与堆栈信息：
2024/04/11 19:50:19 Route GET - /
2024/04/11 19:50:19 Route GET - /panic
2024/04/11 19:50:28 runtime error: index out of range [100] with length 1
2024/04/11 19:50:28 goroutine 19 [running]:
kilon.Default.Recovery.func2.1()
E:/workplace/GoProject/src/myframe/kilon/recovery.go:16 +0x8e
panic({0x5e6dc0?, 0xc000280048?})
E:/compiler/Go/go1.22.1/src/runtime/panic.go:770 +0x132
main.main.func2(0x34e73b?)
e:/workplace/GoProject/src/myframe/main.go:17 +0x17
kilon.(*Context).Next(0xc0002bc000)
E:/workplace/GoProject/src/myframe/kilon/context.go:36 +0x26
kilon.Default.Recovery.func2(0xc0000299d0?)
E:/workplace/GoProject/src/myframe/kilon/recovery.go:23 +0x45
kilon.(*Context).Next(0xc0002bc000)
E:/workplace/GoProject/src/myframe/kilon/context.go:36 +0x26
kilon.Default.Logger.func1(0xc0002bc000)
E:/workplace/GoProject/src/myframe/kilon/klogger.go:13 +0x3b
kilon.(*Context).Next(...)
E:/workplace/GoProject/src/myframe/kilon/context.go:36
kilon.(*router).handle(0xc00008a100, 0xc0002bc000)
E:/workplace/GoProject/src/myframe/kilon/router.go:45 +0x1df
kilon.(*Origin).ServeHTTP(0xc00009e280, {0x67f270, 0xc0002aa000}, 0xc000180000)
E:/workplace/GoProject/src/myframe/kilon/kilon.go:
2024/04/11 19:50:28 [500] /panic in 1.3465ms
并且服务器没有宕机，可以继续访问127.0.0.1:8080看到hello world回应。
完结撒花~~
代码已上传到github：github.com/beropero/myframe
go get github.com/beropero/myframe/kilon
