在Golang的RPC服务开发中，当传输的数据量较大时，网络带宽会成为性能瓶颈，对传输数据进行压缩是降低传输量、提升传输效率的有效方式。gzip和Snappy是两种常用的压缩算法，前者压缩率高但速度稍慢，后者压缩速度快但压缩率略低，开发者可以根据业务场景灵活选择。
gzip压缩实现方案
gzip是Golang标准库自带的压缩算法，无需额外安装依赖，适合对压缩率要求较高的场景。实现RPC数据压缩的核心是自定义RPC的编解码器，在编码阶段对数据进行压缩，解码阶段对数据进行解压。
自定义gzip编解码器
我们可以通过实现rpc.ClientCodec和rpc.ServerCodec接口，封装默认的Gob编解码器，加入gzip压缩逻辑。
package main
import (
"bytes"
"compress/gzip"
"encoding/gob"
"io"
"net/rpc"
)
// GzipGobClientCodec 客户端gzip压缩编解码器
type GzipGobClientCodec struct {
conn io.ReadWriteCloser
enc *gob.Encoder
dec *gob.Decoder
gzipBuf bytes.Buffer
}
// NewGzipGobClientCodec 创建客户端编解码器
func NewGzipGobClientCodec(conn io.ReadWriteCloser) *GzipGobClientCodec {
return &GzipGobClientCodec{
conn: conn,
enc: gob.NewEncoder(&bytes.Buffer{}),
dec: gob.NewDecoder(conn),
}
}
// WriteRequest 编码并压缩请求数据
func (c *GzipGobClientCodec) WriteRequest(req *rpc.Request, body interface{}) error {
// 先使用gob编码数据
var buf bytes.Buffer
enc := gob.NewEncoder(&buf)
if err := enc.Encode(body); err != nil {
return err
}
// 对编码后的数据进行gzip压缩
c.gzipBuf.Reset()
gz := gzip.NewWriter(&c.gzipBuf)
if _, err := gz.Write(buf.Bytes()); err != nil {
return err
}
if err := gz.Close(); err != nil {
return err
}
// 发送压缩后的数据
return c.conn.Write(c.gzipBuf.Bytes())
}
// ReadResponseHeader 读取响应头
func (c *GzipGobClientCodec) ReadResponseHeader(resp *rpc.Response) error {
return c.dec.Decode(resp)
}
// ReadResponseBody 解压并解码响应体
func (c *GzipGobClientCodec) ReadResponseBody(body interface{}) error {
// 读取压缩数据
var compressed bytes.Buffer
if _, err := io.Copy(&compressed, c.conn); err != nil {
return err
}
// 解压数据
gz, err := gzip.NewReader(&compressed)
if err != nil {
return err
}
defer gz.Close()
// 解码gob数据
return gob.NewDecoder(gz).Decode(body)
}
// Close 关闭连接
func (c *GzipGobClientCodec) Close() error {
return c.conn.Close()
}
服务端对应编解码器实现
服务端需要对应实现rpc.ServerCodec接口，逻辑和客户端相反，先解压再解码请求，编码响应后再压缩。
package main
import (
"bytes"
"compress/gzip"
"encoding/gob"
"io"
"net/rpc"
)
// GzipGobServerCodec 服务端gzip压缩编解码器
type GzipGobServerCodec struct {
conn io.ReadWriteCloser
enc *gob.Encoder
dec *gob.Decoder
gzipBuf bytes.Buffer
}
// NewGzipGobServerCodec 创建服务端编解码器
func NewGzipGobServerCodec(conn io.ReadWriteCloser) *GzipGobServerCodec {
return &GzipGobServerCodec{
conn: conn,
enc: gob.NewEncoder(&bytes.Buffer{}),
dec: gob.NewDecoder(conn),
}
}
// ReadRequestHeader 读取请求头
func (c *GzipGobServerCodec) ReadRequestHeader(req *rpc.Request) error {
return c.dec.Decode(req)
}
// ReadRequestBody 解压并解码请求体
func (c *GzipGobServerCodec) ReadRequestBody(body interface{}) error {
// 读取压缩数据
var compressed bytes.Buffer
if _, err := io.Copy(&compressed, c.conn); err != nil {
return err
}
// 解压数据
gz, err := gzip.NewReader(&compressed)
if err != nil {
return err
}
defer gz.Close()
// 解码gob数据
return gob.NewDecoder(gz).Decode(body)
}
// WriteResponse 编码并压缩响应数据
func (c *GzipGobServerCodec) WriteResponse(resp *rpc.Response, body interface{}) error {
// 先使用gob编码数据
var buf bytes.Buffer
enc := gob.NewEncoder(&buf)
if err := enc.Encode(body); err != nil {
return err
}
// 对编码后的数据进行gzip压缩
c.gzipBuf.Reset()
gz := gzip.NewWriter(&c.gzipBuf)
if _, err := gz.Write(buf.Bytes()); err != nil {
return err
}
if err := gz.Close(); err != nil {
return err
}
// 发送压缩后的数据
return c.conn.Write(c.gzipBuf.Bytes())
}
// Close 关闭连接
func (c *GzipGobServerCodec) Close() error {
return c.conn.Close()
}
Snappy压缩实现方案
Snappy是Google开发的压缩算法，特点是压缩和解压速度极快，适合对延迟敏感、数据量大的场景。Golang中可以使用github.com/golang/snappy第三方库实现，需要先安装依赖：go get github.com/golang/snappy。
自定义Snappy编解码器
Snappy的使用方式和gzip类似，同样是封装默认编解码器，在编码后压缩，解码前解压。
package main
import (
"bytes"
"encoding/gob"
"github.com/golang/snappy"
"io"
"net/rpc"
)
// SnappyGobClientCodec 客户端Snappy压缩编解码器
type SnappyGobClientCodec struct {
conn io.ReadWriteCloser
enc *gob.Encoder
dec *gob.Decoder
}
// NewSnappyGobClientCodec 创建客户端编解码器
func NewSnappyGobClientCodec(conn io.ReadWriteCloser) *SnappyGobClientCodec {
return &SnappyGobClientCodec{
conn: conn,
enc: gob.NewEncoder(&bytes.Buffer{}),
dec: gob.NewDecoder(conn),
}
}
// WriteRequest 编码并压缩请求数据
func (c *SnappyGobClientCodec) WriteRequest(req *rpc.Request, body interface{}) error {
// 先使用gob编码数据
var buf bytes.Buffer
enc := gob.NewEncoder(&buf)
if err := enc.Encode(body); err != nil {
return err
}
// 对编码后的数据进行Snappy压缩
compressed := snappy.Encode(nil, buf.Bytes())
// 发送压缩后的数据
return c.conn.Write(compressed)
}
// ReadResponseHeader 读取响应头
func (c *SnappyGobClientCodec) ReadResponseHeader(resp *rpc.Response) error {
return c.dec.Decode(resp)
}
// ReadResponseBody 解压并解码响应体
func (c *SnappyGobClientCodec) ReadResponseBody(body interface{}) error {
// 读取压缩数据
var compressed bytes.Buffer
if _, err := io.Copy(&compressed, c.conn); err != nil {
return err
}
// 解压数据
decompressed, err := snappy.Decode(nil, compressed.Bytes())
if err != nil {
return err
}
// 解码gob数据
return gob.NewDecoder(bytes.NewReader(decompressed)).Decode(body)
}
// Close 关闭连接
func (c *SnappyGobClientCodec) Close() error {
return c.conn.Close()
}
两种压缩方式对比
我们可以通过以下维度对比gzip和Snappy的差异，帮助选择适合的压缩方案：
| 对比维度 | gzip | Snappy |
|---|---|---|
| 压缩率 | 较高，适合文本类数据 | 较低，适合二进制类数据 |
| 压缩速度 | 较慢 | 极快，是gzip的数倍 |
| 解压速度 | 中等 | 极快 |
| CPU消耗 | 较高 | 较低 |
| 依赖情况 | 标准库自带，无额外依赖 | 需要第三方库 |
使用注意事项
- 压缩小数据量时，压缩后的数据可能比原始数据更大，建议设置数据量阈值，超过阈值再开启压缩。
- 如果RPC服务已经运行在内网低延迟环境，且数据量较小，不需要额外开启压缩，避免增加CPU开销。
- 生产环境中建议对压缩算法进行压测，根据实际业务的带宽、延迟、CPU资源情况选择最优方案。
通过以上方式，我们可以在Golang的RPC服务中灵活集成gzip或Snappy压缩，有效减少传输数据量，提升服务整体性能。