动手实现一个简易的 Http server

在学完 go 语言基础后，想做一个较为综合的实践项目巩固知识。在搜寻相关资料后，发现动手实现一个 http server 比较合适。涉及到结构体，闭包，字符串处理，map，IO流，异常处理，socket，和 http 的相关知识。有助于将这些基础知识整合运用.

前言

一些现成的Http框架，如 net/http, Gin，可以做到开箱即用，但作为开发者我们也要大致了解一个框架背后的原理。
今天分享一个基于原生的 TCP socket 库封装一个简易的 Http 框架的小项目。同时简易地实现一个 Http 框架的基本功能，包括：

• 配置端口和静态资源路径
• 设置处理函数的路由映射
• 通过请求响应对象获取参数和设置响应
• 基本的错误响应

整体设计

整个实现基于 Http 1.1 明文协议，据此设计几个功能模块：

• 配置解析，暂定只有配置端口和静态资源路径
• 对 TCP socket 的封装，控制请求的生命周期
• 解析报文，读取参数并封装成 httpRequest 对象
• 处理请求，调用处理器函数、返回静态文件、返回错误等

首先定义以下结构

// server 配置  
type config struct {  
Resource string `yaml:"resource"`  
Port int `yaml:"port"`  
}  
  
// server  
type HttpServer struct {  
config  
handlers map[string]func (*Request, *Response)  
}  
  
// 套接字 client  
type client struct {  
conn net.Conn  
}  
  
// 请求报文第一行的元数据，包括请求参数，请求方法，请求路径  
type metadata struct {  
params map[string]string  
version string  
method string  
uri string  
}  
  
// 请求对象，包括元数据，请求头，请求体  
type Request struct {  
metadata  
headers map[string]string  
body []byte  
}  
  

接着定义函数，主要包括 server启动和对报文的处理流程, 以大写字母开头的是对外暴露的函数。

省略 Request, Response 结构的 setter 和 getter

  
// 处理请求报文元数据  
func loadMetadata(first string) metadata {}  
  
// 解析请求头和请求体  
func (r *Request) Load(meg string) {}  
  
// 解析请求  
func (c *client) decode() *Request {}  
  
// 处理路由  
func (c *client) router(request *Request) (string, *Response, bool) {}  
  
// 封装响应  
func (c *client) encode(response *Response) error {}  
  
// client 套接字生命周期  
func do(c *client, s *HttpServer) {}  
  
// 增加处理器映射  
func (s *HttpServer) AddRouterFunc(path string, fun func(*Request, *Response)) error {}  
  
// 调用处理器方法  
func (s *HttpServer) handle(path string, req *Request, resp *Response) {}  
  
// server 持续监听连接  
func (s *HttpServer) serve() error {  
// ...  
for {  
conn, err := listener.Accept()  
var c = client{conn: conn}  
go do(&c, s)  
}  
}  
  
// 解析配置  
func (s *HttpServer) loadConfig() error {}  
  
// 初始化 server 对象  
func Init(server *HttpServer) error {}  
  
// Server Main 函数  
func (s *HttpServer) Run() {}  

因为篇幅原因不便展示所有的代码，仅讲解关键部分。

解析报文

参考 RFC 的协议文档

Http 1.1 报文结构如下:

[METHOD] [URI] [VERSION]  
[HEADER]: [VALUE]  
[HEADER]: [VALUE]  
[HEADER]: [VALUE]  
  
[PAYLOAD]  

• 在报文的第一行是请求方法 [GET/POST/PUT]、请求URI [/path/to?param1=123&param2=xxx]、协议版本号 [HTTP/1.1].

• 之后连续的几行是请求头,格式为 [HEADER]: [VALUE]，如 Connection: keep-alive. 其值可以有多个

• 一个空行之后是请求体，可以是 json等文本或编码后的二进制数据。

以解析报文第一行为例：

可以使用正则表达式 (标准库的regexp包) 匹配字符串模板，并使用捕获组提取字符。这里简单起见使用空格分割

// 传入首行字符串，返回请求参数，请求方法，请求uri  
func loadMetadata(first string) metadata {  
    var parts = strings.Split(first, " ")  
    var method = parts[0]  
    var version string  
    var uri string  
    var params = make(map[string]string)  
    query := strings.Split(parts[1], "?")  
    uri = query[0]  
    if len(query) > 1 {  
        tmp := strings.Split(query[1], "&")  
        for _, param := range tmp {  
            peer := strings.Split(param, "=")  
            params[peer[0]] = peer[1]  
        }  
    }  
    version = parts[2]  
    return metadata{  
        params: params,  
        version: version,  
        method: method,  
        uri: uri,  
    }  
}  

完成请求处理

解析完报文后，实现对报文的处理和响应.

框架的实现过程中在处理请求时，需要经历下面的阶段:

• 解析报文生成 HttpRequest对象
• 解析路径uri，判断 1.返回静态资源 2.调用处理器函数 3.返回错误
• 将静态资源/处理器结果/错误信息 转为字节，封装响应报文
• 请求处理结束

以下是一个处理请求的生命周期示例

// c *client 是accept()套接字的封装对象  
func do(c *client, s *HttpServer) {  
    defer func() {  
    if r := recover(); r != nil {  
    var resp Response  
    resp.SetError(500, "[500] Server error")  
}  
}()  
    defer c.conn.Close()  
for {  
    req := c.decode()  
    path, resp, sendFile := c.router(req)  
    if req == nil {  
        resp.SetError(400, "[400] Bad request")  
        break  
    }  
    if !sendFile {  
        s.handle(path, req, resp)  
    } else {  
        // 拼接文件路径，读取文件  
        resp.sendFile(s.Resource + path)  
    }  
    err := c.encode(resp)  
    if err != nil {  
        println(err.Error())  
        break  
    }  
}  
}  

测试

• 配置 config.yml

resource: /practice/static/  
port: 8080  

• 启动服务器并设置路由映射

func main() {  
var server myserver.HttpServer  
err := myserver.Init(&server)  
if err == nil {  
server.AddRouterFunc("/", router.Index)  
server.AddRouterFunc("/test", router.TestRouter)  
server.Run()  
}  
}  

• 处理器函数示例
• 根路径返回 index.html文件
• 测试获取请求数据

func Index(request *myserver.Request, resp *myserver.Response) {  
base, _ := os.Getwd()  
file, err := os.Open(base + "\\practice\\static\\index.html")  
if err != nil {  
resp.SetError(404, "[404]: no index.html found")  
}  
defer file.Close()  
scanner := bufio.NewScanner(file)  
for scanner.Scan() {  
resp.Write(scanner.Bytes())  
}  
}  
  
func TestRouter(request *myserver.Request, resp *myserver.Response) {  
println(request.GetURI())  
println(request.GetMethod())  
println(request.GetHeader("User-Agent"))  
println(request.GetHeader("Connection"))  
println(request.GetQueryParam("test"))  
println(string(request.GetRequestBody()))  
resp.Write([]byte("<h1>This is a test handler</h1>"))  
}  

本地测试

不足

• 仅仅是对明文协议进行了解析。无法支持 https 等加密协议
• 没有针对安全方面进行设计，如同源检查，请求参数注入等问题进行防范
• 没有结合传输层与应用层之间解复用的功能进行设计等等