golang常用包

sync 包

常用的有3个功能

锁

锁分为普通互斥锁和读写锁

线程监听 WaitGroup

使用场景：用于监听一组子线程是否执行完毕

池 Pool

用于存放每次请求都需要实例化，且生命周期较长的对象，以减轻垃圾回收压力。

encoding/binary包

主要用来把数字转换为字节类型

单数值转换

//序列化
    var dataA uint64=6010
    var buffer bytes.Buffer
    err1 := binary.Write(&buffer, binary.BigEndian, &dataA)
    if err1!=nil{
        log.Panic(err1)
    }
    byteA:=buffer.Bytes()
    fmt.Println("序列化后：",byteA)

    //反序列化
    var dataB uint64
    var byteB []byte=byteA
    err2:=binary.Read(bytes.NewReader(byteB),binary.BigEndian,&dataB)
    if err2!=nil{
        log.Panic(err2)
    }
    fmt.Println("反序列化后：",dataB)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

其中的BigEndian和LittleEndian 指定了转换的方式是 大端字节序，还是小端字节序。
所谓大端和小端节序，是指不同cpu再把数据流转换为字节时，排位位置的不同，如下

若不同计算机程序之间使用了不同节序处理同一组数据，就会造成无法解析的情况

多数值转换

指把多个数字转换到一个byte切片中

首先定义一个定长切片 s := make([]byte,10)
首先要确定转换的节序，也可以跳过该步骤

binary.LittleEndian.PutUint16(s, uint16(0))
1

确定完之后，就可以向s中插入数字了

start := 0
start += binary.PutUvarint(b[2:], 1198)
1
2

插入数字到切片后，会返回该数字在切片中占用的长度
若切片空间不够，则返报错
所以我们最好确定往切片中插入数字的个数，并估算每个数字占用最大占用长度

解析切片中的某个数字，要知道该数字在切片中占用的起始位置，若位置不对则无法解析出正确的数字，返回0

i,err := binary.ReadUvarint(bytes.NewReader(b[2:]))
if err==nil{
   fmt.Println(i)
}else{
   fmt.Println(err.Error())
} 		
1
2
3
4
5
6

切片中可以插入字符串，转换为数字时，只要能够从正确的位置开始解析，就会解析出正确的数字

encoding/gob包

是一个golang专属的数据序列化工具，用于序列化和反序列化数据，作用类似于json
不同的是，在反序列化时，需要有一个指定格式的变量接收值。该变量类型需要与序列化时数据类型兼容，否则反序列化失败

	type S struct{
		Field1 string
		Field2 int
    }

	func main() {
		s1 := &S{
			Field1: "Hello Gob",
			Field2: 999,
		}
		log.Println("Original value:", s1)
		buf := new(bytes.Buffer)
		err := gob.NewEncoder(buf).Encode(s1)
		if err != nil {
			log.Println("Encode:", err)
			return
		}

		s2 := &S{}
		err = gob.NewDecoder(buf).Decode(s2)
		if err != nil {
			log.Println("Decode:", err)
			return
		}
		log.Println("Decoded value:", s2)

	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

简单的数据可以使用上面代码直接加密和解密
但是当需要解密的数据是接口类型时，由于接口的特殊性，实现了接口中方法的变量可以作为值代替该方法，这导致gob不知道接口中数据的具体类型，会解密失败，如下

type Getter interface {
    Get() string
}

type Foo struct {
    Bar string
}

func (f Foo)Get() string {
    return f.Bar
}

buf := bytes.NewBuffer(nil)
// 创建一个接口变量
//接口中原值是一个get方法，因为Foo实现了get方法，所以可以最为值代替Get
g := Getter(Foo{"wazzup"})

// gob解密g时，认为g中的值是Get() 类型，但其实是Foo类型，就会报错
enc := gob.NewEncoder(buf)
enc.Encode(&g)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

解决这个问题的方法就是在代码初始化时，使用 gob.Register()方法注册Foo变量
当gob解码是发现类型不对应，会从已注册的类型中查找

hash/crc32包

常用方法：

func ChecksumIEEE(data []byte) uint32
返回数据data使用IEEE多项式计算出的CRC-32校验和

可通过对比数据发送和接收时的校验和，验证数据是否被篡改