golang json传递time类型参数

目录

一 前言

二 实现

三 验证

四 总结

---

一 前言

1. golang的强制类型转换可以让人抓狂，遇上json序列化/反序列化时候的时间类型参数，需要不断的转换参数类型，简直让人抓狂。
2. 本文通过组合方式对时间类型进行拓展，并实现序列化/反序列化接口来解决时间json传递类型转换问题。

二 实现

• 自定义jsonTime，时间格式以"2006-01-02 15:04:05" 为例

const (
	YYYYMMDDHHMISS = "2006-01-02 15:04:05" //常规类型
)

type JSONTime struct {
	time.Time
}

• 实现序列化接口。（将时间转化为"2006-01-02 15:04:05"格式）

// MarshalJSON on JSONTime format Time field with %Y-%m-%d %H:%M:%S
func (t JSONTime) MarshalJSON() ([]byte, error) {
	formatted := fmt.Sprintf("\"%s\"", t.Format(YYYYMMDDHHMISS))
	return []byte(formatted), nil
}

// Value insert timestamp into mysql need this function.
func (t JSONTime) Value() (driver.Value, error) {
	var zeroTime time.Time
	if t.Time.UnixNano() == zeroTime.UnixNano() {
		return nil, nil
	}
	return t.Time, nil
}

// Scan valueof time.Time
func (t *JSONTime) Scan(v interface{}) error {
	value, ok := v.(time.Time)
	if ok {
		*t = JSONTime{Time: value}
		return nil
	}
	return fmt.Errorf("can not convert %v to timestamp", v)
}

• 实现反序列化接口（将时间"2006-01-02 15:04:05"格式转化为时间）

// UnmarshalJSON implements the json.Unmarshaler interface.
// The time is expected to be a quoted string in RFC 3339 format.
func (t *JSONTime) UnmarshalJSON(data []byte) error {
	// Ignore null, like in the main JSON package.
	if string(data) == "null" {
		return nil
	}
	// Fractional seconds are handled implicitly by Parse.
	var err error
	(*t).Time, err = time.ParseInLocation(`"`+YYYYMMDDHHMISS+`"`, string(data), time.Local)
	return err
}

三 验证

• 测试代码

package util

import (
	"encoding/json"
	"fmt"
	"testing"
	"time"
)

type TestTime struct {
	Time JSONTime `json:"time"`
	Name string   `json:"name"`
}

//格式化输出
func (t *TestTime) ToString() string {
	return fmt.Sprintf("time:%+v,name:%+v", t.Time, t.Name)
}

func TestJsonMarshal(t *testing.T) {

	//测试序列化
	testMarshal := &TestTime{
		Time: JSONTime{time.Now()},
		Name: "序列化",
	}
	marshal, err := json.Marshal(testMarshal)
	if err != nil {
		fmt.Print(err.Error())
	}
	fmt.Println("序列化字符串：",string(marshal))

	//测试反序列化
	src := []byte(`{"time":"2020-05-26 20:20:44","name":"反序列化"}`)
	var testUnMarshal TestTime
	err = json.Unmarshal(src, &testUnMarshal)
	if err != nil {
		fmt.Print(err.Error())
	}
	fmt.Println("反序列化结构体：",testUnMarshal.ToString())
}

• 结果验证 

=== RUN   TestJsonMarshal
序列化字符串： {"time":"2020-05-26 20:30:53","name":"序列化"}
反序列化结构体： time:2020-05-26 20:20:44 +0800 CST,name:反序列化
--- PASS: TestJsonMarshal (0.00s)
PASS

四 总结

组合加实现接口是golang常用的扩展类的方式，由此可拓展出各种各种类型的数据参数序列化。

例如：golang实现mysql json数据类型的封装，等。