Marshal

• programmer from Rayark, a game company in Taiwan
• backend engineer
• usually develop something related to my work in Python, Ruby, Golang, C#
• built almost entire VOEZ game server by myself only

type UnixTime struct {
	//anonymous field
	time.Time `bson:",inline" json:",inline"`
}
 
func (unixTime UnixTime) MarshalJSON() ([]byte, error) {
	return json.Marshal(unixTime.Time.Unix())
}
 
func (unixTime *UnixTime) UnmarshalJSON(data []byte) error {
	var unixTimeInt int64
 
	err := json.Unmarshal(data, &unixTimeInt)
	if err != nil {
		return err
	}
 
	unixTime.Time = time.Unix(unixTimeInt, 0)
	return nil
}

is this it?

there seems to be much behind all this!

3. conclusion
4. outline
5. preface: type system
6. origin: json package
   1. json marshal/unmarshal package
   2. usage
   3. implementation & example
7. customization
   1. requirement
   2. try it
   3. result
   4. solution

8. new coming problem
   1. case
   2. try it
   3. reason
   4. dirty solution
9. better way
10. summary
    1. slogan
    2. special thanks
11. appendix: code to test marshal/unmarshal
12. Q&A

// struct
type Person struct {
	Name string
	Age  int
}
 
// interface
type Reader interface {
	Read(p []byte) (n int, err error)
}

json marshal/unmarshal package

• https://golang.org/pkg/encoding/json/

usage

// encode
b, err := json.Marshal(&fromData)
 
enc := json.NewEncoder(writer)
err := enc.Encode(&fromData)
 
// decode
err := json.Unmarshal(b, &toData)
 
dec := json.NewDecoder(reader)
err := dec.Decode(&toData)

implementation

// encoder will call this method
type Marshaler interface {
	MarshalJSON() ([]byte, error)
}
 
// decoder will call this method
type Unmarshaler interface {
	UnmarshalJSON([]byte) error
}

example

// can be value or pointer receiver
func (variable Type) MarshalJSON() ([]byte, error)
 
// must be pointer receiver (need to overwrite variable)
func (variable *Type) UnmarshalJSON([]byte) error

requirement

• time.Time.MarshalJSON() -> 2017-08-06T13:40:00+08:00
• prefer to use UNIX epoch time -> 1501998000

try it

type AccountCoreData struct {
	Name      string
	UUID      string
	CreatedAt time.Time
	UpdatedAt time.Time
}

// AccountCoreData reflection redefinition
type _AuxAccountCoreData struct {
	*AccountCoreData `bson:",inline" json:",inline"`
	CreatedAt        int64
	UpdatedAt        int64
}

func (accountCoreData AccountCoreData) MarshalJSON() ([]byte, error) {
	return json.Marshal(_AuxAccountCoreData{
		AccountCoreData: &accountCoreData,
		CreatedAt:       accountCoreData.CreatedAt.Unix(),
		UpdatedAt:       accountCoreData.UpdatedAt.Unix(),
	})
}

func (accountCoreData *AccountCoreData) UnmarshalJSON(data []byte) error {
	aux := &_AuxAccountCoreData{
		AccountCoreData: accountCoreData,
	}
 
	err := json.Unmarshal(data, aux)
	if err != nil {
		return err
	}
 
	accountCoreData.CreatedAt = time.Unix(aux.CreatedAt, 0)
	accountCoreData.UpdatedAt = time.Unix(aux.UpdatedAt, 0)
	return nil
}

result

然後它就死掉了

• infinite call -> stack overflow!
  • MarshalJSON() -> json.Marshal() -> MarshalJSON() -> json.Marshal() -> …
  • UnmarshalJSON() -> json.Unmarshal() -> UnmarshalJSON() -> json.Unmarshal() -> …

solution

avoid inheritance

// avoid inheritance!!!
type _AccountCoreDataAlias AccountCoreData
 
// AccountCoreData reflection redefinition
type _AuxAccountCoreData struct {
	*_AccountCoreDataAlias `bson:",inline" json:",inline"`
	CreatedAt              int64
	UpdatedAt              int64
}

func (accountCoreData AccountCoreData) MarshalJSON() ([]byte, error) {
	return json.Marshal(_AuxAccountCoreData{
		_AccountCoreDataAlias: (*_AccountCoreDataAlias)(&accountCoreData),
		CreatedAt:             accountCoreData.CreatedAt.Unix(),
		UpdatedAt:             accountCoreData.UpdatedAt.Unix(),
	})
}

func (accountCoreData *AccountCoreData) UnmarshalJSON(data []byte) error {
	aux := &_AuxAccountCoreData{
		_AccountCoreDataAlias: (*_AccountCoreDataAlias)(accountCoreData),
	}
 
	err := json.Unmarshal(data, aux)
	if err != nil {
		return err
	}
 
	accountCoreData.CreatedAt = time.Unix(aux.CreatedAt, 0)
	accountCoreData.UpdatedAt = time.Unix(aux.UpdatedAt, 0)
	return nil
}

case

type AccountInfo struct {
	AccountCoreData `bson:",inline" json:",inline"`
	BirthYear       int64
	Description     string
}

try it

call json.Marshal() or json.Unmarshal() …

• BirthYear and Description are gone

reason

why?

receiver fallback

• AccountInfo.MarshalJSON() = AccountCoreData.MarshalJSON()
• AccountInfo.UnmarshalJSON() = AccountCoreData.UnmarshalJSON()

dirty solution

// AccountInfo reflection redefinition
type _AuxAccountInfo struct {
	*_AuxAccountCoreData `bson:",inline" json:",inline"`
	BirthYear            *int64
	Description          *string
}

func (accountInfo AccountInfo) MarshalJSON() ([]byte, error) {
	return json.Marshal(_AuxAccountInfo{
		_AuxAccountCoreData: &_AuxAccountCoreData{
			_AccountCoreDataAlias: (*_AccountCoreDataAlias)(&accountInfo.AccountCoreData),
			CreatedAt:             accountInfo.AccountCoreData.CreatedAt.Unix(),
			UpdatedAt:             accountInfo.AccountCoreData.UpdatedAt.Unix(),
		},
		BirthYear:   &accountInfo.BirthYear,
		Description: &accountInfo.Description,
	})
}

func (accountInfo *AccountInfo) UnmarshalJSON(data []byte) error {
	aux := &_AuxAccountInfo{
		_AuxAccountCoreData: &_AuxAccountCoreData{
			_AccountCoreDataAlias: (*_AccountCoreDataAlias)(&accountInfo.AccountCoreData),
		},
		BirthYear:   &accountInfo.BirthYear,
		Description: &accountInfo.Description,
	}
 
	err := json.Unmarshal(data, aux)
	if err != nil {
		return err
	}
 
	accountInfo.AccountCoreData.CreatedAt = time.Unix(aux._AuxAccountCoreData.CreatedAt, 0)
	accountInfo.AccountCoreData.UpdatedAt = time.Unix(aux._AuxAccountCoreData.UpdatedAt, 0)
	return nil
}

code is like a sh*t!!!

type UnixTime time.Time
// MarshalJSON() and UnmarshalJSON() is gone

type UnixTime struct {
	//anonymous field
	time.Time `bson:",inline" json:",inline"`
}
// 1. MarshalJSON() and UnmarshalJSON() is inherited
// 2. keep bson or xml Marshal/Unmarshal

func (unixTime UnixTime) MarshalJSON() ([]byte, error) {
	return json.Marshal(unixTime.Time.Unix())
}

func (unixTime *UnixTime) UnmarshalJSON(data []byte) error {
	var unixTimeInt int64
 
	err := json.Unmarshal(data, &unixTimeInt)
	if err != nil {
		return err
	}
 
	unixTime.Time = time.Unix(unixTimeInt, 0)
	return nil
}

Panacea?

• UnixTime as anonymous field of struct

slogan

http://i.imgur.com/SWwsRq3.jpg

http://i.imgur.com/XDq9TWd.gif

"不要太看重得與失, 而是你要享受這個過程"
田中謙介

there are big stories in type, struct field, interface, and receiver

special thanks

• Rayark Inc.
  • CTO & CIO
  • backend team
  • other teams

code to test marshal/unmarshal

package main
 
import (
	"encoding/json"
	"encoding/xml"
	"fmt"
	"time"
)
 
type UnixTime struct {
	//anonymous field
	time.Time `bson:",inline" json:",inline"`
}
 
func (unixTime UnixTime) MarshalJSON() ([]byte, error) {
	return json.Marshal(unixTime.Time.Unix())
}
 
func (unixTime *UnixTime) UnmarshalJSON(data []byte) error {
	var unixTimeInt int64
 
	err := json.Unmarshal(data, &unixTimeInt)
	if err != nil {
		return err
	}
 
	unixTime.Time = time.Unix(unixTimeInt, 0)
	return nil
}
 
// AccountCoreData
 
type AccountCoreData struct {
	Name      string
	UUID      string
	CreatedAt UnixTime
	UpdatedAt UnixTime
	//CreatedAt time.Time
	//UpdatedAt time.Time
}
 
/*
// avoid inheritance!!!
type _AccountCoreDataAlias AccountCoreData
 
// AccountCoreData reflection redefinition
type _AuxAccountCoreData struct {
	//*AccountCoreData       `bson:",inline" json:",inline"`
	*_AccountCoreDataAlias `bson:",inline" json:",inline"`
	CreatedAt              int64
	UpdatedAt              int64
}
 
func (accountCoreData AccountCoreData) MarshalJSON() ([]byte, error) {
	return json.Marshal(_AuxAccountCoreData{
		//AccountCoreData:       &accountCoreData,
		_AccountCoreDataAlias: (*_AccountCoreDataAlias)(&accountCoreData),
		CreatedAt:             accountCoreData.CreatedAt.Unix(),
		UpdatedAt:             accountCoreData.UpdatedAt.Unix(),
	})
}
 
func (accountCoreData *AccountCoreData) UnmarshalJSON(data []byte) error {
	aux := &_AuxAccountCoreData{
		//AccountCoreData: accountCoreData,
		_AccountCoreDataAlias: (*_AccountCoreDataAlias)(accountCoreData),
	}
 
	err := json.Unmarshal(data, aux)
	if err != nil {
		return err
	}
 
	accountCoreData.CreatedAt = time.Unix(aux.CreatedAt, 0)
	accountCoreData.UpdatedAt = time.Unix(aux.UpdatedAt, 0)
	return nil
}
*/
 
// AccountInfo
 
type AccountInfo struct {
	AccountCoreData `bson:",inline" json:",inline"`
	BirthYear       int64
	Description     string
}
 
/*
// avoid inheritance!!!
//type _AccountInfoAlias AccountInfo
 
// AccountInfo reflection redefinition
type _AuxAccountInfo struct {
	*_AuxAccountCoreData `bson:",inline" json:",inline"`
	BirthYear            *int64
	Description          *string
}
 
func (accountInfo AccountInfo) MarshalJSON() ([]byte, error) {
	return json.Marshal(_AuxAccountInfo{
		_AuxAccountCoreData: &_AuxAccountCoreData{
			//AccountCoreData:       &accountInfo.AccountCoreData,
			_AccountCoreDataAlias: (*_AccountCoreDataAlias)(&accountInfo.AccountCoreData),
			CreatedAt:             accountInfo.AccountCoreData.CreatedAt.Unix(),
			UpdatedAt:             accountInfo.AccountCoreData.UpdatedAt.Unix(),
		},
		BirthYear:   &accountInfo.BirthYear,
		Description: &accountInfo.Description,
	})
}
 
func (accountInfo *AccountInfo) UnmarshalJSON(data []byte) error {
	aux := &_AuxAccountInfo{
		_AuxAccountCoreData: &_AuxAccountCoreData{
			//AccountCoreData: &accountInfo.AccountCoreData,
			_AccountCoreDataAlias: (*_AccountCoreDataAlias)(&accountInfo.AccountCoreData),
		},
		BirthYear:   &accountInfo.BirthYear,
		Description: &accountInfo.Description,
	}
 
	err := json.Unmarshal(data, aux)
	if err != nil {
		return err
	}
 
	accountInfo.AccountCoreData.CreatedAt = time.Unix(aux._AuxAccountCoreData.CreatedAt, 0)
	accountInfo.AccountCoreData.UpdatedAt = time.Unix(aux._AuxAccountCoreData.UpdatedAt, 0)
	return nil
}
*/
 
func main() {
	accountCoreData := AccountCoreData{
		Name:      "Rasmus Faber",
		UUID:      "123e4567-e89b-12d3-a456-426655440000",
		CreatedAt: UnixTime{Time: time.Now()},
		UpdatedAt: UnixTime{Time: time.Unix(1501998000, 0)},
		//CreatedAt: time.Now(),
		//UpdatedAt: time.Unix(1501998000, 0),
	}
 
	accountInfo := AccountInfo{
		AccountCoreData: accountCoreData,
		BirthYear:       1979,
		Description:     "Swedish pianist, DJ, remixer, composer, record producer, sound engineer, and founder of the record label Farplane Records.",
	}
 
	fmt.Println("account core data:")
	fmt.Println("original:")
	fmt.Println(accountCoreData)
	accountCoreDataJson, err := json.Marshal(accountCoreData)
	if err != nil {
		panic(err)
	}
	fmt.Println("JSON:")
	fmt.Println(string(accountCoreDataJson))
	var accountCoreDataParsed AccountCoreData
	json.Unmarshal(accountCoreDataJson, &accountCoreDataParsed)
	fmt.Println("parsed:")
	fmt.Println(accountCoreDataParsed)
 
	accountCoreDataXML, err := xml.Marshal(accountCoreData)
	if err != nil {
		panic(err)
	}
	fmt.Println("XML:")
	fmt.Println(string(accountCoreDataXML))
 
	fmt.Println("account info:")
	fmt.Println("original:")
	fmt.Println(accountInfo)
	accountInfoJson, err := json.Marshal(accountInfo)
	if err != nil {
		panic(err)
	}
	fmt.Println("JSON:")
	fmt.Println(string(accountInfoJson))
	var accountInfoParsed AccountInfo
	json.Unmarshal(accountInfoJson, &accountInfoParsed)
	fmt.Println("parsed:")
	fmt.Println(accountInfoParsed)
 
	accountInfoXML, err := xml.Marshal(accountInfo)
	if err != nil {
		panic(err)
	}
	fmt.Println("XML:")
	fmt.Println(string(accountInfoXML))
}