解组字符串 json 时，在输入字节 0 处获取非法的 base64 数据

在使用 Redis 数据库存储 JSON 数据时，若将十六进制编码的字段（如哈希值和前哈希值）视为 base64 编码数据进行解组，会引发“输入字节 0 处的非法 base64 数据”错误。为了解决此问题，需要将十六进制编码的字段解组为字符串，然后使用 hex.DecodeString() 函数进行十六进制解码。或者，可以使用自定义解组器来自动执行此解码过程。

我将数据存储在 redis 数据库中，当我请求它时，我会得到一个有效的 json。 json 看起来像这样：

{"data":"hi","hash":"000f7dcfca98450a0f405384db3878c1956cb98309e63cf2d0a963cff9f17260","prevhash":"000daf177434acd55a3284787b793a3453c3d70eacdb9a84f5faed43adb2ff58","nonce":8504,"timestamp":1611498968}

这是一个有效的 json 字符串（go 省略了前导和尾随引号），但在解组时出现此错误。输入字节 0 处的 illegal base64 数据

err = json.unmarshal([]byte(item), &block)

type Block struct {
    Data      []byte
    Hash      []byte
    PrevHash  []byte
    Nonce     int
    TimeStamp int64
}

func (chain *BlockChain) AddBlock(data string) {
    var lastHash []byte

    item, err := chain.Database.Get(ctx, "lastHash").Result()
    Handle(err)
    lastHash = []byte(item)
    newBlock := createBlock(data, lastHash)

    _, err = chain.Database.Set(ctx, StrHash(newBlock.Hash), newBlock, 0).Result()
    Handle(err)
    _, err = chain.Database.Set(ctx, "lastHash", newBlock.Hash, 0).Result()
}

func (chain *BlockChain) Iterator() *BlockChainIterator {
    return &BlockChainIterator{
        CurrentHash: chain.LastHash,
        Database:    chain.Database,
    }
}

func (iterator *BlockChainIterator) Next() *Block {
    var block *Block

    item, err := iterator.Database.Get(ctx, StrHash(iterator.CurrentHash)).Result()
    
    Handle(err)
    err = json.Unmarshal([]byte(item), &block)

    Handle(err)
    iterator.CurrentHash = block.PrevHash

    return block

}

// -----------------
// Utility Functions
// -----------------

// TODO: Think about this. Wouldn't it be better to store everything as strings rather than converting it?
type jsonBlock struct {
    Data      string
    Hash      string
    PrevHash  string
    Nonce     int
    TimeStamp int64
}

// This function gets called automatically by go-redis
func (b *Block) MarshalBinary() ([]byte, error) {
    jb := jsonBlock{
        Data:      string(b.Data),
        Hash:      StrHash(b.Hash),
        PrevHash:  StrHash(b.PrevHash),
        Nonce:     b.Nonce,
        TimeStamp: b.TimeStamp,
    }
    return json.Marshal(jb)
}

解决方案

json 中的 hash 值（以及 prevhash）不是数据的 base64 编码形式，而是十六进制表示形式。如果您尝试将其解组为 []byte 类型的 go 值，则 encoding/json 包会假定并尝试将其解释为 base64 编码数据。

data字段也是如此：它应该是go类型string，因为它不是base64编码形式，所以将其更改为string。

尝试将 hash 和 prevhash 解组为 string 类型的字段，并使用 hex.DecodeString() 进行十六进制解码。

您可以实现自定义解组器来自动执行此操作。

一种方便的方法是创建一个 hexdata 类型，它是 []byte 但从十六进制字符串解码：

type hexdata []byte

func (h *hexdata) unmarshaljson(data []byte) error {
    var s string
    if err := json.unmarshal(data, &s); err != nil {
        return err
    }
    decoded, err := hex.decodestring(s)
    if err != nil {
        return err
    }
    *h = hexdata(decoded)
    return nil
}

使用它：

type block struct {
    data      string
    hash      hexdata
    prevhash  hexdata
    nonce     int
    timestamp int64
}

func main() {
    var b block
    if err := json.unmarshal([]byte(src), &b); err != nil {
        panic(err)
    }
    fmt.printf("%+v\n", b)
}

输出（在 Go Playground 上尝试）：

{Data:hi Hash:[0 15 125 207 202 152 69 10 15 64 83 132 219 56 120 193 149 108 185 131 9 230 60 242 208 169 99 207 249 241 114 96] PrevHash:[0 13 175 23 116 52 172 213 90 50 132 120 123 121 58 52 83 195 215 14 172 219 154 132 245 250 237 67 173 178 255 88] Nonce:8504 TimeStamp:1611498968}

今天关于《解组字符串 json 时，在输入字节 0 处获取非法的 base64 数据》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！