Golang中gzip过滤器的源码分析与解释

Golang中gzip过滤器的源码分析与解释

与上次相同，这次gzip过滤器的源码，依旧是使用LiteIDE中自带的源码阅读功能来解读的。个人感觉在Go语言的学习中这款软件非常方便

这次我们对gzip包的源码做个整体分析。下面就一部分一部分来看。

引用的包

可看到gzip包引用了如下包：

package gzip

import (
    "compress/flate"
    "errors"
    "fmt"
    "hash/crc32"
    "io"
    "time"
)

结构体与常量的定义

在gzip包的源码中，定义了一个Writer结构体和一些常量：

type Writer struct {
    Header      
    w           io.Writer
    level       int
    wroteHeader bool
    compressor  *flate.Writer
    digest      uint32
    size        uint32
    closed      bool
    buf         [10]byte
    err         error
}

一个Writer是一个io.WriteCloser，写入到一个被压缩和被写入w的Writer。

const (
    NoCompression      = flate.NoCompression
    BestSpeed          = flate.BestSpeed
    BestCompression    = flate.BestCompression
    DefaultCompression = flate.DefaultCompression
    HuffmanOnly        = flate.HuffmanOnly
)

其中这些常量的定义是从compress/flate包中拷贝来的，所以在使用时，需要引用gzip包的时候就没必要再引用flate包了。

NewWriter函数

func NewWriter(w io.Writer) *Writer {
    z, _ := NewWriterLevel(w, DefaultCompression)
    return z
}

该函数返回一个新的Writer。要在Writer.Header中设置字段的调用者必须先执行此操作。
Writer可能会被缓冲，直到调用Close才会被刷新。而调用Close需要调用者自己完成。
这是对于Write，Flush或Close的第一次调用。

NewWriterLevel及init函数

NewWriterLevel：

func NewWriterLevel(w io.Writer, level int) (*Writer, error) {
    if level < HuffmanOnly || level > BestCompression {
        return nil, fmt.Errorf("gzip: invalid compression level: %d", level)
    }
    z := new(Writer)
    z.init(w, level)
    return z, nil
}

init：

func (z *Writer) init(w io.Writer, level int) {
    compressor := z.compressor
    if compressor != nil {
        compressor.Reset(w)
    }
    *z = Writer{
        Header: Header{
            OS: 255, // unknown
        },
        w:          w,
        level:      level,
        compressor: compressor,
    }
}

NewWriterLevel函数与NewWriter函数很相似，区别在于，NewWriterLevel函数指定了压缩级别，而不是和NewWriter一样设为DefaultCompression。
这里的压缩级别可以是DefaultCompression，NoCompression，HuffmanOnly
，或者BestSpeed和BestCompression中的任何整数值。
如果级别有效，则error会返回nil。
init就是一个初始化函数，没什么特别的地方，之后来看看其他的函数。

Reset函数

func (z *Writer) Reset(w io.Writer) {
    z.init(w, z.level)
}

Reset函数会舍弃掉Writer z的当前状态，并使其等于之前NewWriter或NewWriterLevel给它的原始状态，但是这些都会写入w。
这样做是为了可以重复利用一个Writer，而不是再新分配一个新的w。

writeBytes函数

func (z *Writer) writeBytes(b []byte) error {
    if len(b) > 0xffff {
        return errors.New("gzip.Write: Extra data is too large")
    }
    le.PutUint16(z.buf[:2], uint16(len(b)))
    _, err := z.w.Write(z.buf[:2])
    if err != nil {
        return err
    }
    _, err = z.w.Write(b)
    return err
}

writeBytes函数的作用是把一个长度为前缀的byte切片写入到z.w。

writeString函数

func (z *Writer) writeString(s string) (err error) {
    needconv := false
    for _, v := range s {
        if v == 0 || v > 0xff {
            return errors.New("gzip.Write: non-Latin-1 header string")
        }
        if v > 0x7f {
            needconv = true
        }
    }
    if needconv {
        b := make([]byte, 0, len(s))
        for _, v := range s {
            b = append(b, byte(v))
        }
        _, err = z.w.Write(b)
    } else {
        _, err = io.WriteString(z.w, s)
    }
    if err != nil {
        return err
    }
    // GZIP strings are NUL-terminated.
    z.buf[0] = 0
    _, err = z.w.Write(z.buf[:1])
    return err
}

writeString函数的作用是将一个UTF-8字符串以GZIP的格式写入z.w。
GZIP格式： GZIP（RFC 1952）指定字符串是以NUL结尾的ISO 8859-1（Latin-1）。
如果是非Latin-1格式则返回error；如果是非ASCII格式，则会发生转换。

Write函数

func (z *Writer) Write(p []byte) (int, error) {
    if z.err != nil {
        return 0, z.err
    }
    var n int
    if !z.wroteHeader {
        z.wroteHeader = true
        z.buf = [10]byte{0: gzipID1, 1: gzipID2, 2: gzipDeflate}
        if z.Extra != nil {
            z.buf[3] |= 0x04
        }
        if z.Name != "" {
            z.buf[3] |= 0x08
        }
        if z.Comment != "" {
            z.buf[3] |= 0x10
        }
        if z.ModTime.After(time.Unix(0, 0)) {
            le.PutUint32(z.buf[4:8], uint32(z.ModTime.Unix()))
        }
        if z.level == BestCompression {
            z.buf[8] = 2
        } else if z.level == BestSpeed {
            z.buf[8] = 4
        }
        z.buf[9] = z.OS
        n, z.err = z.w.Write(z.buf[:10])
        if z.err != nil {
            return n, z.err
        }
        if z.Extra != nil {
            z.err = z.writeBytes(z.Extra)
            if z.err != nil {
                return n, z.err
            }
        }
        if z.Name != "" {
            z.err = z.writeString(z.Name)
            if z.err != nil {
                return n, z.err
            }
        }
        if z.Comment != "" {
            z.err = z.writeString(z.Comment)
            if z.err != nil {
                return n, z.err
            }
        }
        if z.compressor == nil {
            z.compressor, _ = flate.NewWriter(z.w, z.level)
        }
    }
    z.size += uint32(len(p))
    z.digest = crc32.Update(z.digest, crc32.IEEETable, p)
    n, z.err = z.compressor.Write(p)
    return n, z.err
}

Write函数把一个压缩形式的p写入到到底层io.Writer。在Writer函数结束之前，压缩的字节不一定会被刷新。
函数中，关于ModTime，MTIME取0意味着没有设置修改的时间。

Flush函数

func (z *Writer) Flush() error {
    if z.err != nil {
        return z.err
    }
    if z.closed {
        return nil
    }
    if !z.wroteHeader {
        z.Write(nil)
        if z.err != nil {
            return z.err
        }
    }
    z.err = z.compressor.Flush()
    return z.err
}

Flush函数刷新所有正在挂起的被压缩的数据，去到底层writer。
Flush函数主要用于压缩网络协议，以确保远程读取器有足够的数据来重建数据包。 在数据写入之前，刷新不会返回。 如果底层写入程序返回错误，则Flush返回该错误。

Close函数

func (z *Writer) Close() error {
    if z.err != nil {
        return z.err
    }
    if z.closed {
        return nil
    }
    z.closed = true
    if !z.wroteHeader {
        z.Write(nil)
        if z.err != nil {
            return z.err
        }
    }
    z.err = z.compressor.Close()
    if z.err != nil {
        return z.err
    }
    le.PutUint32(z.buf[:4], z.digest)
    le.PutUint32(z.buf[4:8], z.size)
    _, z.err = z.w.Write(z.buf[:8])
    return z.err
}

Close函数通过将所有未写入的数据刷新到底层的io.Writer，并写入GZIP页脚来关闭Writer。
需要注意的是，Close函数不会关闭底层的io.Writer。

总结

以上就是gzip包的所有源码，可以看出gzip对于一个writer的操作有Write、Close、Flush三种，功能都很明确且很方便，同时也有writeBytes和writeString这样的函数，使得操作简化。使用gzip包进行压缩方面的操作可以很容易完成。要注意在使用writeString的时候明确字符串格式等问题。