我要评论自定义序列化时间格式
问题场景
有一个user结构体，其中有一个time.time类型的字段
type user struct {
name string `json:"name"`
age int `json:"age"`
birthday time.time `json:"birthday"`
}
定义一个jsonutil
func tostr(v any) string {
b, err := json.marshal(v)
if err != nil {
return ""
}
return string(b)
}
func toobj[t any](s string, v *t) *t {
err := json.unmarshal([]byte(s), v)
if err != nil {
return nil
}
return v
}
如果直接使用默认的json序列化，如下
func test1(t *testing.t) {
var user = user{
name: "yimin",
age: 18,
birthday: time.now(),
}
str := tostr(user)
fmt.println(str)
}
得到的结果是这样的，时间格式不是很友好
{"name":"yimin","age":18,"birthday":"2024-08-15t15:50:51.3876651+08:00"}
实现接口
让user实现marshaler接口，自定义序列化逻辑
func (u *user) marshaljson() ([]byte, error) {
type usertemp user // 避免循环引用
type tomarshal struct {
*usertemp // 这里必须使用匿名嵌套，序列化才会展开平铺，从而使用string类型birthday
birthday string `json:"birthday"`
}
return json.marshal(tomarshal{
usertemp: (*usertemp)(u),
birthday: u.birthday.format(time.datetime),
})
}
思路：
- 不要序列化原结构体，而是序列化一个新的结构体
- 新结构体中将原来time.time类型的字段重新定义为string类型，这样就可以自定义时间格式了
- 同时新结构体还需要保留原结构体所有其他字段
实现：
- 利用json序列化嵌套匿名结构体的特性（展开平铺）
- 这里匿名结构体需要重新定义类型，避免循环引用
- 这样一来，序列化user转化为序列化tomarshal，且将birthday改为了string类型（可以自定义格式）
测试
注意此时需要传递user的指针类型
func test1(t *testing.t) {
var user = user{
name: "yimin",
age: 18,
birthday: time.now(),
}
str := tostr(&user)
fmt.println(str)
}
{"name":"yimin","age":18,"birthday":"2024-08-15 15:59:26"}
那反序列化呢？
func test2(t *testing.t) {
var str = `{"name":"yimin","age":18,"birthday":"2024-08-15 15:59:26"}`
var user = toobj[*user](str, &user{})
fmt.println(user)
}
直接失败了，因为默认不支持这个时间格式
<nil>
解决方法也是一样的，自己实现反序列化逻辑
处理反序列化时间格式
实现接口
func (u *user) unmarshaljson(b []byte) error {
type usertemp user
type tounmarshal struct {
*usertemp
birthday string `json:"birthday"`
}
var t = tounmarshal{
usertemp: (*usertemp)(u), // 确保数据反序列化到u，但不会处理birthday
}
if err := json.unmarshal(b, &t); err != nil {
return err
}
var err error
// 单独处理birthday
u.birthday, err = time.parse(time.datetime, t.birthday)
return err
}
思路：
- 大体思路和序列化是一样的，换个birthday类型是string的结构体反序列化
- 反序列化前需要手动初始化usertemp为this对象，确保该有的数据都能对应上（除了birthday）
- 单独处理this对象的birthday，手动指定格式parse
测试
func test2(t *testing.t) {
var str = `{"name":"yimin","age":18,"birthday":"2024-08-15 15:59:26"}`
var user = toobj[user](str, &user{})
fmt.printf("%+v\n", user)
}
&{name:yimin age:18 birthday:2024-08-15 15:59:26 +0000 utc}
进一步简化
- 上面的方法虽然解决了问题，但是对于每一个结构体都要实现方法，比较繁琐
- 我们关注的只是time.time类型的序列化和反序列化，于是可以自定义时间类型，单独对这个类型实现方法
- 后面需要使用time.time类型的地方，替换为我们自定义的时间类型
自定义类型
type time time.time
const format = "2006-01-02 15:04:05"
// 固定写法，前后加"
func (t time) marshaljson() ([]byte, error) {
b := make([]byte, 0, len(format)+2)
b = append(b, '"')
b = time.time(t).appendformat(b, format)
b = append(b, '"')
return b, nil
}
// 固定写法，格式化字符串前后加上"
// 因为需要修改t，使用指针类型
func (t *time) unmarshaljson(data []byte) error {
formattime, err := time.parseinlocation(`"`+format+`"`, string(data), time.local)
if err != nil {
return err
}
*t = time(formattime)
return nil
}
// 格式化输出
func (t time) string() string {
return time.time(t).format(format)
}
time.time替换为自定义类型
type user struct {
name string `json:"name"`
age int `json:"age"`
birthday time `json:"birthday"`
}
测试
func test1(t *testing.t) {
var user = user{
name: "yimin",
age: 18,
birthday: time(time.now()),
}
str := tostr(&user)
fmt.println(str)
}
func test2(t *testing.t) {
var str = `{"name":"yimin","age":18,"birthday":"2024-08-15 15:59:26"}`
var user = toobj[user](str, &user{})
fmt.printf("%+v\n", user)
}
{"name":"yimin","age":18,"birthday":"2024-08-15 17:23:37"}
&{name:yimin age:18 birthday:2024-08-15 15:59:26}
以上就是golang中自定义json序列化时间格式的示例代码的详细内容，更多关于golang自定义json时间格式的资料请关注代码网其它相关文章！
发表评论