【go实现tcp升级到http之持久连接】

写在前面

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。
在这里插入图片描述
然后看抓包的结果,返回给浏览器的内容也确实是压缩过的。
在这里插入图片描述

封装

接下来模拟go官方包简单封装一下获取的请求。就是把请求和header头封装一下,这里用了官方的bufio和net/textproto包。

请求头

package main

import (
	"bufio"
	"errors"
	"fmt"
	"io"
	"net"
	"net/textproto"
	"strconv"
	"strings"
)

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()

	r := bufio.NewReader(conn)
	tp := textproto.NewReader(r)
	var (
		err error
		req *request
	)

	for {
		req, err = getRequest(tp)
		fmt.Printf("handleConn req:%+v\n", req)

		// 说明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))
	}
}

func getRequest(tx *textproto.Reader) (*request, error) {
	var (
		s   string
		err error
	)
	req := &request{
		header: make(map[string]string, 0),
	}

	link := make([]string, 0)
	for {
		if s, err = tx.ReadLine(); err != nil {
			fmt.Printf("read s:%v err:%v\n", s, err)
			return req, err
		}

		if s == "" {
			break
		}
		link = append(link, s)
	}

	if len(link) == 0 {
		return req, nil
	}

	url := strings.Split(link[0], " ")
	if len(url) != 3 {
		return req, errors.New("不是标准的http协议")
	}

	req.method = url[0]
	req.url = url[1]
	req.version = url[2]

	for _, v := range link[2:] {
		h := strings.Split(v, ":")
		req.header[h[0]] = h[1]
	}
	return req, nil
}

type request struct {
	method  string
	url     string
	version string
	header  map[string]string
}

func (req *request) getHeader(s string) string {
	return req.header[s]
}

tx.ReadLine() 这个是每行每行的把请求读取出来,然后放到了link。然后因为第一行是请求方式,url和版本,因此针对第一行做了特殊处理,并且放到request中。
然后接下来的就是请求头了,每个服务出来,然后放到map中。
这样我们的封装请求request就完成了。

响应头

package main

import (
	"bufio"
	"bytes"
	"errors"
	"fmt"
	"io"
	"net"
	"net/textproto"
	"strings"
)

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()

	r := bufio.NewReader(conn)
	tp := textproto.NewReader(r)
	var (
		err error
		req *request
	)

	for {
		req, err = getRequest(tp)
		fmt.Printf("handleConn req:%+v\n", req)

		// 说明tcp链接断了
		if err == io.EOF {
			return
		}
		addr := conn.RemoteAddr()
		fmt.Println(addr)

		w := &httpWrite{
			header: make(header, 0),
		}
		// 获取响应
		ServeHTTP(w, req)

		// 写入响应
		res := getResponse(w)
		conn.Write([]byte(res))
	}
}

func getResponse(write *httpWrite) string {
	// 设置Content-Typ
	header, ok := write.header["Content-Type"]
	if !ok {
		header = append(header, "application/json; charset=utf-8")
	}

	resp := fmt.Sprintf("HTTP/1.1 %v OK\r\n", write.statusCode)

	for _, h := range write.header {
		for k, v := range h {
			resp += fmt.Sprintf("%v: %v\r\n", k, v)
		}
	}
	// 最后加上Content-Length
	resp += fmt.Sprintf("Content-Length: %d\n\r\n", write.bytes.Len())

	// 写响应
	resp += write.bytes.String()
	return resp
}

func getRequest(tx *textproto.Reader) (*request, error) {
	var (
		s   string
		err error
	)
	req := &request{
		header: make(header, 0),
	}

	link := make([]string, 0)
	for {
		if s, err = tx.ReadLine(); err != nil {
			fmt.Printf("read s:%v err:%v\n", s, err)
			return req, err
		}

		if s == "" {
			break
		}
		link = append(link, s)
	}

	if len(link) == 0 {
		return req, nil
	}

	url := strings.Split(link[0], " ")
	if len(url) != 3 {
		return req, errors.New("不是标准的http协议")
	}

	req.method = url[0]
	req.url = url[1]
	req.version = url[2]

	for _, v := range link[2:] {
		h := strings.Split(v, ":")
		req.header[h[0]] = []string{h[1]}
	}
	return req, nil
}

type request struct {
	method  string
	url     string
	version string
	header  header
}

type header map[string][]string

func (h header) setHeader(k string, value []string) {
	h[k] = value
}

func (req *request) getHeader(s string) []string {
	return req.header[s]
}

type ResponseWriter interface {
	Header() header
	Write([]byte) (int, error)
	WriteHeader(statusCode int)
}

var _ ResponseWriter = (*httpWrite)(nil)

type httpWrite struct {
	statusCode int
	header     header
	bytes      bytes.Buffer
}

func (w *httpWrite) Write(bytes []byte) (int, error) {
	return w.bytes.Write(bytes)
}

func (w *httpWrite) WriteHeader(statusCode int) {
	w.statusCode = statusCode
}

func (w *httpWrite) Header() header {
	return w.header
}

func ServeHTTP(write ResponseWriter, req *request) {
	header := write.Header()
	header.setHeader("name", []string{"test"})

	write.Write([]byte("hello world"))
	write.WriteHeader(200)
}

这里模拟官方包写了一个ServeHTTP方法,然后可以写入响应。只是官方是 interface,我们这个简单起见,只是用func,其实本质一样。
然后ResponseWriter 和官方一样,这里我们增加了实现,具体实现的方法是httpWrite。
最后是getResponse得到响应,最后写到了response中。

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值