如何在Go语言中对任意对象进行哈希：理解序列化与哈希的挑战

func Hash(obj interface{}) []byte {
    digest := md5.New()
    // 尝试直接写入，对于非固定大小或复杂类型会失败
    if err := binary.Write(digest, binary.LittleEndian, obj); err != nil {
        panic(err) // 例如，对int类型会报 "panic: binary.Write: invalid type int"
    }
    return digest.Sum(nil)
}

package main

import (
    "crypto/md5"
    "encoding/gob"
    "fmt"
    "io" // 导入io包
)

// gobEncoder 是一个结构体，用于封装 gob.NewEncoder 和 md5.New()
// 确保每次哈希时重置 digest
type gobHasher struct {
    digest io.Writer // md5.New() 返回一个 io.Writer
    encoder *gob.Encoder
}

// NewGobHasher 创建并返回一个 gobHasher 实例
func NewGobHasher() *gobHasher {
    digest := md5.New()
    return &gobHasher{
        digest:  digest,
        encoder: gob.NewEncoder(digest),
    }
}

// Hash 对任意对象进行哈希
func (gh *gobHasher) Hash(obj interface{}) []byte {
    // 每次哈希前重置MD5摘要器
    if resetter, ok := gh.digest.(interface{ Reset() }); ok {
        resetter.Reset()
    } else {
        // 如果gh.digest不支持Reset，则重新创建
        gh.digest = md5.New()
        gh.encoder = gob.NewEncoder(gh.digest)
    }

    if err := gh.encoder.Encode(obj); err != nil {
        panic(fmt.Errorf("gob encode failed: %w", err))
    }

    // 获取MD5哈希值
    if summer, ok := gh.digest.(interface{ Sum(b []byte) []byte }); ok {
        return summer.Sum(nil)
    }
    panic("digest does not support Sum method") // 理论上不会发生，因为md5.New()返回的类型支持Sum
}

func main() {
    hasher := NewGobHasher()

    // 示例1：哈希一个字符串
    s1 := "hello world"
    hash1 := hasher.Hash(s1)
    fmt.Printf("Hash of \"%s\": %x\n", s1, hash1)

    s2 := "hello world"
    hash2 := hasher.Hash(s2)
    fmt.Printf("Hash of \"%s\": %x (should be same as hash1)\n", s2, hash2)

    // 示例2：哈希一个结构体
    type Person struct {
        Name string
        Age  int
    }
    p1 := Person{Name: "Alice", Age: 30}
    hash3 := hasher.Hash(p1)
    fmt.Printf("Hash of Person{Name:\"%s\", Age:%d}: %x\n", p1.Name, p1.Age, hash3)

    p2 := Person{Name: "Alice", Age: 30}
    hash4 := hasher.Hash(p2)
    fmt.Printf("Hash of Person{Name:\"%s\", Age:%d}: %x (should be same as hash3)\n", p2.Name, p2.Age, hash4)

    // 示例3：哈希一个切片
    slice1 := []int{1, 2, 3}
    hash5 := hasher.Hash(slice1)
    fmt.Printf("Hash of %v: %x\n", slice1, hash5)

    slice2 := []int{1, 2, 3}
    hash6 := hasher.Hash(slice2)
    fmt.Printf("Hash of %v: %x (should be same as hash5)\n", slice2, hash6)
}

// 示例：手动对简单结构体进行规范化哈希
type SimpleData struct {
    ID   int64
    Name string
}

func HashSimpleData(data SimpleData) []byte {
    digest := md5.New()
    // 确保字段顺序固定且编码方式一致
    if err := binary.Write(digest, binary.LittleEndian, data.ID); err != nil {
        panic(err)
    }
    digest.Write([]byte(data.Name)) // string直接写入字节
    return digest.Sum(nil)
}

package main

import (
    "crypto/md5"
    "encoding/json"
    "fmt"
    "sort"
)

// HashByJSON 对任意对象进行JSON序列化后哈希
// 注意：对于包含无序map的对象，此方法可能不产生稳定哈希
func HashByJSON(obj interface{}) ([]byte, error) {
    // 尝试将对象转换为JSON字节
    jsonBytes, err := json.Marshal(obj)
    if err != nil {
        return nil, fmt.Errorf("json marshal failed: %w", err)
    }

    digest := md5.New()
    digest.Write(jsonBytes)
    return digest.Sum(nil), nil
}

// 如果对象包含map，为了稳定哈希，需要自定义序列化逻辑
// 例如，将map转换为有序的键值对切片再进行JSON序列化
type PersonWithMap struct {
    ID   int
    Tags map[string]string
}

// MarshalJSON 实现自定义JSON序列化，确保map的键有序
func (p PersonWithMap) MarshalJSON() ([]byte, error) {
    // 创建一个临时结构体，用于自定义序列化
    type Alias PersonWithMap
    aux := struct {
        Tags []struct {
            Key string
            Value string
        } `json:"tags"`
        *Alias
    }{
        Alias: (*Alias)(&p),
    }

    // 排序map的键
    keys := make([]string, 0, len(p.Tags))
    for k := range p.Tags {
        keys = append(keys, k)
    }
    sort.Strings(keys)

    // 填充有序的Tags
    aux.Tags = make([]struct{ Key string; Value string }, len(keys))
    for i, k := range keys {
        aux.Tags[i].Key = k
        aux.Tags[i].Value = p.Tags[k]
    }

    return json.Marshal(aux)
}

func main() {
    // JSON哈希示例
    type User struct {
        Name string `json:"name"`
        Age  int    `json:"age"`
    }
    u1 := User{Name: "Bob", Age: 25}
    hashJ1, _ := HashByJSON(u1)
    fmt.Printf("JSON Hash of User{Name:\"%s\", Age:%d}: %x\n", u1.Name, u1.Age, hashJ1)

    u2 := User{Name: "Bob", Age: 25}
    hashJ2, _ := HashByJSON(u2)
    fmt.Printf("JSON Hash of User{Name:\"%s\", Age:%d}: %x (should be same)\n", u2.Name, u2.Age, hashJ2)

    // 包含map的结构体哈希示例 (使用自定义MarshalJSON)
    pm1 := PersonWithMap{
        ID: 1,
        Tags: map[string]string{"a": "1", "b": "2"},
    }
    hashPM1, _ := HashByJSON(pm1)
    fmt.Printf("JSON Hash of PersonWithMap (1): %x\n", hashPM1)

    pm2 := PersonWithMap{
        ID: 1,
        Tags: map[string]string{"b": "2", "a": "1"}, // map顺序不同，但哈希应相同
    }
    hashPM2, _ := HashByJSON(pm2)
    fmt.Printf("JSON Hash of PersonWithMap (2): %x (should be same)\n", hashPM2)
}