【Golang学习笔记】从零开始搭建一个Web框架（四）

不洛

已于 2024-04-13 20:42:24 修改

阅读量2.2k

点赞数 74

文章标签： golang 学习笔记

于 2024-04-12 09:02:29 首次发布

本文链接：https://blog.csdn.net/qq_46449962/article/details/137650849

版权

文章目录

前情提示：
【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

不洛

关注

74
点赞
踩
32

收藏

觉得还不错? 一键收藏
0
评论
【Golang学习笔记】从零开始搭建一个Web框架（四）

用Go语言从零开始搭建一个Web框架，本篇笔记主要涉及模板渲染与错误恢复（完结篇）
复制链接

扫一扫