Go语言实现基于TCP的内存缓存服务
接上文: https://www.cnblogs.com/N3ptune/p/16623738.html
HTTP/REST的解析导致基于HTTP的内存缓存服务性能不佳,本次实现一个基于TCP的缓存服务
TCP缓存协议规范
对于TCP来说,客户端和服务端之间传输的是网络字节流,要自定义一套序列化规范,使用ABFN表达,ABNF是扩展巴科斯范式:
command = op key | key-value
op = 'S' | 'G' | 'D'
key = bytes-array
bytes-array = length SP content
length = 1*DIGIT
content = *OBJECT
key-value = length SP length SP content content
response = error | bytes-array
error = '-' bytes-array
第1行是一条command的规则,command是客户端发送给服务端的命令,由一个op和一个key或一个key-value组成
第2行是op的规则,op可以为下列3个字符的一个: "S"表示这是一个SET操作,"G"表示这是一个GET操作,而"D"表示这是一个DEL操作
第3行的key规则用来表示一个单独的键,它由一个字节数组bytes-array组成
第4行描述了bytes-array的规则,说明是由一个length、一个SP(空格字符)个一个content组成
length规则用来表示字节长度,是由一个或更多DIGIT组成(1*表示一个或多个)
content规则用来表示字节内容,由任意个OBJECT组成(*记法表示有0个或多个)
key-value规则用来表示一个键值对,由一个length、一个SP,然后又是一个length、一个SP以及content组成,分别表示key的字节长度、value的字节长度、key的字节内容和value的字节内容
response规则用来表示客户端发送给客户端的响应,由一个error或者一个bytes-array组成
error由一个"-"(负号)和一个bytes-array组成,表示错误
缓存流程
对于Set流程,客户端发送的command一个大写的"S"开始,后面接一个数字klen表示key的长度,然后是一个空格SP作为分割符,然后是一个数字vlen表示value的长度,然后又是一个空格,最后是key的内容和value的内容。服务端解析command并取出key和value,然后调用inMemoryCache.Set将键值对保存在内存的map中,如果cache.Cache.Set方法返回错误,tcp.Server会向客户端链接写入一个error: 以"-"开头,后面跟一个数字表示错误的长度,然后是一个空格作为分割符,最后是错误的内容。如果cache.Cache.Set方法成功返回,则tcp.Server向客户端写入一个"0",该字符会被解读为一个长度为0的bytes-array,用来表示成功
对于Get流程,客户端发送的command以一个大写的"G"开始,后面跟了一个数字klen表示key的长度,然后是一个空格作为分隔符,最后是key的内容。服务端解析command并取出key,然后调用inMemoryCache.Get方法在map中查询key对应的value,并将其作为byte-array写入客户端连接。如果cache.Cache.Get方法返回错误,tcp.Server会向客户端链接写入一个error
对于Del流程,客户端发送command以一个大写的"D"开始,后面跟了一个数字klen表示key的长度,然后是一个空格作为分割符,最后是key的内容。服务端解析这个command并取出key,然后调用inMemoryCache.Del方法删除该key,如果cache.Cache.Get方法返回错误,tcp.Server会向客户端连接写入一个error
下面编写代码
main函数如下:
package main
import (
"tcp-cache/cache"
"tcp-cache/http"
"tcp-cache/tcp"
)
func main() {
c := cache.New("inmemory")
go tcp.New(c).Listen()
http.New(c).Listen()
}
cache包和上篇文章一样,封装了对map的操作
服务端实现
创建一个tcp包,编写代码:
package tcp
import (
"bufio"
"fmt"
"io"
"log"
"net"
"strconv"
"strings"
"tcp-cache/cache"
)
type Server struct {
cache.Cache
}
func New(c cache.Cache) *Server {
return &Server{c}
}
func (s *Server) Listen() {
listen, err := net.Listen("tcp", ":9090")
if err != nil {
panic(err)
}
for {
cli, err := listen.Accept()
if err != nil {
panic(err)
}
go s.process(cli)
}
}
func (s *Server) readKey(r *bufio.Reader) (string, error) {
klen, err := readLen(r)
if err != nil {
return "", err
}
k := make([]byte, klen)
_, err = io.ReadFull(r, k)
if err != nil {
return "", err
}
return string(k), nil
}
func (s *Server) readKeyAndValue(r *bufio.Reader) (string, []byte, error) {
klen, err := readLen(r)
if err != nil {
return "", nil, err
}
vlen, err := readLen(r)
if err != nil {
return "", nil, err
}
k := make([]byte, klen)
_, err = io.ReadFull(r, k)
if err != nil {
return "", nil, err
}
v := make([]byte, vlen)
_, err = io.ReadFull(r, v)
if err != nil {
return "", nil, err
}
return string(k), v, nil
}
func readLen(r *bufio.Reader) (int, error) {
t, err := r.ReadString(' ')
if err != nil {
return 0, err
}
n, err := strconv.Atoi(strings.TrimSpace(t))
if err != nil {
return 0, err
}
return n, nil
}
func sendResponse(value []byte, err error, conn net.Conn) error {
if err != nil {
errString := err.Error()
t := fmt.Sprintf("%-%d ", len(errString)) + errString
_, e := conn.Write([]byte(t))
return e
}
vlen := fmt.Sprintf("%d ", len(value))
_, e := conn.Write(append([]byte(vlen), value...))
return e
}
func (s *Server) get(conn net.Conn, r *bufio.Reader) error {
k, err := s.readKey(r)
if err != nil {
return err
}
v, err := s.Get(k)
return sendResponse(v, err, conn)
}
func (s *Server) set(conn net.Conn, r *bufio.Reader) error {
k, v, err := s.readKeyAndValue(r)
if err != nil {
return err
}
return sendResponse(nil, s.Set(k, v), conn)
}
func (s *Server) del(conn net.Conn, r *bufio.Reader) error {
k, err := s.readKey(r)
if err != nil {
return err
}
return sendResponse(nil, s.Del(k), conn)
}
func (s *Server) process(conn net.Conn) {
defer conn.Close()
r := bufio.NewReader(conn)
for {
op, err := r.ReadByte()
if err != nil {
if err != io.EOF {
log.Println("close connection due to error:", err)
return
}
}
if op == 'S' {
err = s.set(conn, r)
} else if op == 'G' {
err = s.get(conn, r)
} else if op == 'D' {
err = s.del(conn, r)
} else {
log.Println("close connection due to invalid operation:", op)
return
}
if err != nil {
log.Println("close connection due to error:", err)
return
}
}
}
首先定义了一个Server结构体,内嵌一个cache.Cache接口,其Listen方法调用Go语言的net包的Listen函数监听本机TCP的9090端口,并在一个循环中接收客户端的连接并调用Server.process处理这个连接。处理连接的Server.process方法运行在一个新的goroutine上,原来的goroutine可以继续执行,监听新的请求
func (s *Server) Listen() {
listen, err := net.Listen("tcp", ":9090")
if err != nil {
panic(err)
}
for {
cli, err := listen.Accept()
if err != nil {
panic(err)
}
go s.process(cli)
}
}
如下是process方法的实现:
func (s *Server) process(conn net.Conn) {
defer conn.Close()
r := bufio.NewReader(conn)
for {
op, err := r.ReadByte()
if err != nil {
if err != io.EOF {
log.Println("close connection due to error:", err)
return
}
}
if op == 'S' {
err = s.set(conn, r)
} else if op == 'G' {
err = s.get(conn, r)
} else if op == 'D' {
err = s.del(conn, r)
} else {
log.Println("close connection due to invalid operation:", op)
return
}
if err != nil {
log.Println("close connection due to error:", err)
return
}
}
}
利用bufio.Reader结构体可以对客户端连接进行一个缓冲读取,可以在数据传输不稳定时进行阻塞等待,先读取请求内容的第一个字符,根据这个字符来判断来调用何种方法(set,get,del)
如下是3个方法的实现:
func (s *Server) get(conn net.Conn, r *bufio.Reader) error {
k, err := s.readKey(r)
if err != nil {
return err
}
v, err := s.Get(k)
return sendResponse(v, err, conn)
}
func (s *Server) set(conn net.Conn, r *bufio.Reader) error {
k, v, err := s.readKeyAndValue(r)
if err != nil {
return err
}
return sendResponse(nil, s.Set(k, v), conn)
}
func (s *Server) del(conn net.Conn, r *bufio.Reader) error {
k, err := s.readKey(r)
if err != nil {
return err
}
return sendResponse(nil, s.Del(k), conn)
}
get方法首先调用readKey函数,从command中读取key,readKey实现如下:
func (s *Server) readKey(r *bufio.Reader) (string, error) {
klen, err := readLen(r)
if err != nil {
return "", err
}
k := make([]byte, klen)
_, err = io.ReadFull(r, k)
if err != nil {
return "", err
}
return string(k), nil
}
该函数的作用就是从缓冲区字节数据中取出key,先调用readLen取出长度,在读取这个长度的字节,就得到了key,然后将其返回,readLen的实现如下:
func readLen(r *bufio.Reader) (int, error) {
t, err := r.ReadString(' ')
if err != nil {
return 0, err
}
n, err := strconv.Atoi(strings.TrimSpace(t))
if err != nil {
return 0, err
}
return n, nil
}
缓冲区中字节数据是按空格分割的,第一段字符串就是长度,这在协议规范中已经表明(length SP content),之后将这个长度返回,之后在get中得到key后就可以调用cache的Get方法获得数据,调用sendReponse发送响应数据给客户端
Set方法与其相似,先调用readKeyAndValue方法获得键值,调用cache的Set方法添加数据,然后调用sendResponse发送给客户端,readKeyAndValue实现如下:
func (s *Server) readKeyAndValue(r *bufio.Reader) (string, []byte, error) {
klen, err := readLen(r)
if err != nil {
return "", nil, err
}
vlen, err := readLen(r)
if err != nil {
return "", nil, err
}
k := make([]byte, klen)
_, err = io.ReadFull(r, k)
if err != nil {
return "", nil, err
}
v := make([]byte, vlen)
_, err = io.ReadFull(r, v)
if err != nil {
return "", nil, err
}
return string(k), v, nil
}
按照最初定义的协议规范,key-value的定义是length SP length SP content content
这里依然用空格分割,前两段数据是key和value的长度
del与get一样,只要获取key,然后调用cache的Del方法进行删除就行了
最后是sendResponce的实现:
func sendResponse(value []byte, err error, conn net.Conn) error {
if err != nil {
errString := err.Error()
t := fmt.Sprintf("-%d ", len(errString)) + errString
_, e := conn.Write([]byte(t))
return e
}
vlen := fmt.Sprintf("%d ", len(value))
_, e := conn.Write(append([]byte(vlen), value...))
return e
}
作用就是向客户端发送数据,发送取出的数据和错误信息,调用Write方法写回字节流