Go语言如何将JSON字符串反序列化为自定义常量类型

Go语言开发中，我们经常会定义自定义常量类型来约束变量的取值范围，比如定义状态类型、类型标识等，当这些类型对应的字段需要接收JSON字符串的反序列化结果时，直接使用标准库的json.Unmarshal方法往往无法得到预期结果，需要额外的处理逻辑。

自定义常量类型的定义方式

自定义常量类型通常是基于Go语言的基础类型（如int、string等）创建的，通过const关键字定义一组固定的取值，示例代码如下：

package main

import "fmt"

// 定义自定义常量类型 Status，基于 string 类型
type Status string

// 定义该类型的固定常量值
const (
	StatusPending Status = "pending"
	StatusRunning Status = "running"
	StatusDone    Status = "done"
)

func main() {
	var s Status
	s = StatusPending
	fmt.Println(s) // 输出 pending
}

直接反序列化的常见问题

如果我们尝试直接将JSON字符串反序列化到Status类型的变量，标准库的json包无法识别自定义常量类型的取值约束，会直接返回类型不匹配的错误，示例代码如下：

package main

import (
	"encoding/json"
	"fmt"
)

type Status string

const (
	StatusPending Status = "pending"
	StatusRunning Status = "running"
	StatusDone    Status = "done"
)

type Task struct {
	ID     int    `json:"id"`
	Status Status `json:"status"`
}

func main() {
	jsonStr := `{"id":1,"status":"pending"}`
	var task Task
	err := json.Unmarshal([]byte(jsonStr), &task)
	if err != nil {
		fmt.Println("反序列化失败:", err)
		return
	}
	fmt.Println("反序列化结果:", task)
}

上述代码运行后会输出反序列化失败的错误，原因是json包在解析Status类型时，不知道如何将字符串映射到我们定义的Status常量上。

解决方案一：实现json.Unmarshaler接口

我们可以为自定义常量类型实现json.Unmarshaler接口，在自定义的UnmarshalJSON方法中校验输入值是否为合法的常量值，示例代码如下：

package main

import (
	"encoding/json"
	"fmt"
)

type Status string

const (
	StatusPending Status = "pending"
	StatusRunning Status = "running"
	StatusDone    Status = "done"
)

// 合法状态值集合
var validStatuses = map[Status]bool{
	StatusPending: true,
	StatusRunning: true,
	StatusDone:    true,
}

// 实现 json.Unmarshaler 接口
func (s *Status) UnmarshalJSON(data []byte) error {
	// 先解析出原始字符串，去掉JSON字符串的引号
	var raw string
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	// 校验是否为合法的状态值
	if !validStatuses[Status(raw)] {
		return fmt.Errorf("非法的状态值: %s", raw)
	}
	*s = Status(raw)
	return nil
}

type Task struct {
	ID     int    `json:"id"`
	Status Status `json:"status"`
}

func main() {
	jsonStr := `{"id":1,"status":"pending"}`
	var task Task
	err := json.Unmarshal([]byte(jsonStr), &task)
	if err != nil {
		fmt.Println("反序列化失败:", err)
		return
	}
	fmt.Printf("反序列化结果: ID=%d, Status=%sn", task.ID, task.Status) // 输出 反序列化结果: ID=1, Status=pending

	// 测试非法值场景
	invalidJson := `{"id":2,"status":"invalid"}`
	var invalidTask Task
	err = json.Unmarshal([]byte(invalidJson), &invalidTask)
	if err != nil {
		fmt.Println("非法值反序列化失败:", err) // 输出 非法值反序列化失败: 非法的状态值: invalid
	}
}

解决方案二：使用中间类型转换

如果不想为自定义类型实现接口，也可以先定义结构体使用基础类型接收JSON值，再手动转换为自定义常量类型，示例代码如下：

package main

import (
	"encoding/json"
	"fmt"
)

type Status string

const (
	StatusPending Status = "pending"
	StatusRunning Status = "running"
	StatusDone    Status = "done"
)

// 中间结构体，用 string 类型接收 status 字段
type taskJSON struct {
	ID     int    `json:"id"`
	Status string `json:"status"`
}

type Task struct {
	ID     int
	Status Status
}

// 自定义解析方法
func ParseTaskFromJSON(jsonStr string) (*Task, error) {
	var tmp taskJSON
	if err := json.Unmarshal([]byte(jsonStr), &tmp); err != nil {
		return nil, err
	}
	// 校验并转换状态值
	switch Status(tmp.Status) {
	case StatusPending, StatusRunning, StatusDone:
		return &Task{
			ID:     tmp.ID,
			Status: Status(tmp.Status),
		}, nil
	default:
		return nil, fmt.Errorf("非法的状态值: %s", tmp.Status)
	}
}

func main() {
	jsonStr := `{"id":1,"status":"running"}`
	task, err := ParseTaskFromJSON(jsonStr)
	if err != nil {
		fmt.Println("解析失败:", err)
		return
	}
	fmt.Printf("解析结果: ID=%d, Status=%sn", task.ID, task.Status) // 输出 解析结果: ID=1, Status=running
}

两种方案对比

两种方案各有适用场景，具体对比如下：

注意事项

• 自定义常量类型的底层基础类型需要和JSON对应值的类型匹配，比如JSON里是字符串，底层类型就应该是string，否则反序列化会失败。
• 实现UnmarshalJSON接口时，要注意处理JSON的null值场景，避免出现空指针问题。
• 如果自定义常量类型是基于int等数字类型，处理逻辑和string类型类似，只需要将中间解析的类型换成对应的数字类型即可。

实际开发中建议优先选择实现json.Unmarshaler接口的方案，这样可以在结构体定义时直接使用json标签，更符合Go语言的标准开发习惯，也能减少额外的转换代码。

Go语言JSON反序列化自定义常量类型encoding_json修改时间：2026-07-04 05:39:27