写在前面
go实现tcp升级到http这个可以见前面的文章 go实现tcp升级到http
因为http是应用层,是在tcp协议之上,而之前写的是基于一次http请求创建一个tcp链接,也就是所谓的短连接,这个弊端就是在高并发的场景下面,linux可能存在着tcp链接回收不及时的情况,因为tcp创建是有上限的,可能导致就是tcp链接创建不出来。
代码
我们在原来的基础上更改一下,代码详见
package main
import (
"fmt"
"net"
"strconv"
)
func main() {
//监听这个端口
listen, err := net.Listen("tcp", "127.0.0.1:8888")
if err != nil {
fmt.Printf("listen err:%v\n", err)
return
}
for {
//接收连接
conn, err := listen.Accept()
if err != nil {
fmt.Printf("accept err:%v\n", err)
return
}
fmt.Printf("创建链接\n")
go handleConn(conn)
}
}
func handleConn(conn net.Conn) {
defer conn.Close()
buf := make([]byte, 1024)
for {
// 读取内容。阻塞
_, err := conn.Read(buf)
// 说明tcp链接断了
if err == io.EOF {
return
}
addr := conn.RemoteAddr()
fmt.Println(addr)
//响应体
var respBody = "<h1>Hello World</h1>"
length := len(respBody)
//响应头
var respHeader = "HTTP/1.1 200 OK\n" +
"Content-Type: text/html;charset=ISO-8859-1\n" +
"Content-Length: " + strconv.FormatInt(int64(length), 10)
resp := respHeader + "\n\r\n" + respBody
_, _ = conn.Write([]byte(resp))
}
}
这里可以看到我们和之前多了一个for循环,这样就不会在每次tcp链接创建了以后,就关闭,而是会去读连接里面的内容,也就是把内容从内核的协议栈读取到用户空间。同时在conn.Read,我们是阻塞的模式,所以这里会阻塞,并且等待内容。
效果
来看一下效果,首先是页面的
然后是控制台输出的:
可以看到后面的请求都是同一个客户端端口,也就是浏览器发起的,因此说明了我们的长连接是成功了。
升级
使用Transfer-Encoding
在上面可以看到可以看到每次需要计算body的总长度,并且写到Content-Length。但是在一些场景下,总长度不是那么好计算的,尤其是在大的响应中需要分段传输。这个时候就需要Transfer-Encoding这个响应头。
分块编码相当简单,在头部加入 Transfer-Encoding: chunked 之后,就代表这个报文采用了分块编码。这时,报文中的实体需要改为用一系列分块来传输。每个分块包含十六进制的长度值和数据,长度值独占一行,长度不包括它结尾的 CRLF(\r\n),也不包括分块数据结尾的 CRLF。最后一个分块长度值必须为 0,对应的分块数据没有内容,表示实体结束。按照这个格式改造下之前的代码:
package main
import (
"fmt"
"io"
"net"
)
func main() {
//监听这个端口
listen, err := net.Listen("tcp", "127.0.0.1:8888")
if err != nil {
fmt.Printf("listen err:%v\n", err)
return
}
for {
//接收连接
conn, err := listen.Accept()
if err != nil {
fmt.Printf("accept err:%v\n", err)
return
}
fmt.Printf("创建链接\n")
go handleConnChunk(conn)
}
}
func handleConnChunk(conn net.Conn) {
defer conn.Close()
buf := make([]byte, 1024)
for {
_, err := conn.Read(buf)
if err == io.EOF {
fmt.Printf("handleConn err:%v\n", err)
return
}
addr := conn.RemoteAddr()
fmt.Println(addr)
//响应体
var respBody = "5\r\nHello\r\n6\r\n World\r\n0\r\n\r\n"
//响应头
var respHeader = "HTTP/1.1 200 OK\r\n" +
"Content-Type: text/html;charset=ISO-8859-1\r\n" +
"Transfer-Encoding: chunked\r\n"
resp := respHeader + "\r\n" + respBody
_, _ = conn.Write([]byte(resp))
}
}
来看效果
可以看到我们响应头是Transfer-Encoding: chunked.输出内容也是我们期望的。核心的就是一个响应头中增加Transfer-Encoding: chunked。然后在增加一个\r\n后,就开始增加响应头内容,也就是 var respBody = “5\r\nHello\r\n6\r\n World\r\n0\r\n\r\n”。
其实这个内容是
5
Hello
6
World
0
注意是 World前面有一个空格,所以是6,也就是6个字节。然后跟上内容。
最后跟上0,告诉浏览器当前body结束。
从抓取的包体来看,也能看出来
gzip
通常为了节约带宽,也会去进行压缩,这个时候需要带上Content-Encoding: gzip这样的响应头。这样一般请求头会带支持的压缩方式,也就是Accept-Encoding: gzip, deflate。这样,说明是支持gzip压缩,因此可以对resp进行压缩。见代码
package main
import (
"bytes"
"compress/gzip"
"fmt"
"io"
"net"
"strconv"
)
func main() {
//监听这个端口
listen, err := net.Listen("tcp", "127.0.0.1:8888")
if err != nil {
fmt.Printf("listen err:%v\n", err)
return
}
for {
//接收连接
conn, err := listen.Accept()
if err != nil {
fmt.Printf("accept err:%v\n", err)
return
}
fmt.Printf("创建链接\n")
go handleConnChunk(conn)
}
}
func handleConnChunk(conn net.Conn) {
defer conn.Close()
buf := make([]byte, 1024)
for {
_, err := conn.Read(buf)
if err == io.EOF {
fmt.Printf("handleConn err:%v\n", err)
return
}
addr := conn.RemoteAddr()
fmt.Println(addr)
//响应体
// 增加gzip功能
var buffer bytes.Buffer
gz := gzip.NewWriter(&buffer)
_, err = gz.Write([]byte("Hello World"))
if err != nil {
return
}
gz.Close()
//响应头
var respHeader = "HTTP/1.1 200 OK\r\n" +
"Content-Type: text/html;charset=ISO-8859-1\r\n" +
"Content-Encoding: gzip\r\n" +
"Content-Length: " + strconv.FormatInt(int64(buffer.Len()), 10) + "\r\n"
resp := respHeader + "\r\n" + buffer.String()
_, _ = conn.Write([]byte(resp))
}
}
这里因为默认浏览器支持gzip压缩,因此没有判断,在压缩完了以后,计算长度,记录进Content-Length。看一下浏览器效果。可以看到响应头带了Content-Encoding: gzip。
然后看抓包的结果,返回给浏览器的内容也确实是压缩过的。
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。