A minimal implementation with a lot of comments.

Author: TomOnTime

jsondemo2/minimal.go

@@ -0,0 +1,99 @@
+package main
+
+/*
+
+The Go JSON module can't not access unexported fields in a struct. So
+how do you work with them?
+
+This demonstrates the solution in http://choly.ca/post/go-json-marshalling/
+where we have a 2nd struct that embeds the primary struct but adds
+fields that will be used to expose the unexported fields.  We then write
+MarshalJSON() and UnmarshalJSON() functions that do the right thing.
+
+This also helps in situations where we have fields that require a custom
+format only in JSON.
+*/
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// Cranberry stores data.
+//  Visible: This field is exported and JSON displays it as usual.
+//  invisible: This field is unexported but we want it to be included in JSON.
+//  Custom: This field has a custom output format.  We store it as time.Time
+//    but when it appears in JSON, it should be in Unix Epoch format.
+type Cranberry struct {
+	Visible   int       `json:"visible"`
+	invisible int       // No tag here
+	Custom    time.Time `json:"-"` // Don't output this field (we'll handle it in CranberryJSON).
+}
+
+// CranberryAlias is an alias of Cranberry. We use an alias because aliases
+// are stripped of any functions and we need a struct without
+// MarshalJSON/UnmarshalJSON defined, otherwise we'd get a recursive defintion.
+type CranberryAlias Cranberry
+
+// CranberryJSON represents out we represent Cranberry to the JSON package.
+type CranberryJSON struct {
+	*CranberryAlias       // All the exported fields.
+	Invisible       int   `json:"invisible"`
+	CustomUnixEpoch int64 `json:"epoch"`
+	// FYI: The json tags "invisble" and "epoch" can be any valid JSON tag.
+	// It is all a matter of how we want the JSON to be presented externally.
+}
+
+// MarshalJSON marshals a Cranberry. (struct to JSON)
+func (u *Cranberry) MarshalJSON() ([]byte, error) {
+	return json.Marshal(&CranberryJSON{
+		CranberryAlias: (*CranberryAlias)(u),
+		// Unexported or custom-formatted fields are listed here:
+		Invisible:       u.invisible,
+		CustomUnixEpoch: u.Custom.Unix(),
+	})
+}
+
+// UnmarshalJSON unmarshals a Cranberry. (JSON to struct)
+func (u *Cranberry) UnmarshalJSON(data []byte) error {
+	temp := &CranberryJSON{
+		CranberryAlias: (*CranberryAlias)(u),
+	}
+	if err := json.Unmarshal(data, &temp); err != nil {
+		return err
+	}
+
+	// Copy the exported fields:
+	*u = (Cranberry)(*(temp).CranberryAlias)
+	// Each unexported field must be copied and/or converted individually:
+	u.invisible = temp.Invisible
+	u.Custom = time.Unix(temp.CustomUnixEpoch, 0) // Convert while copying.
+
+	return nil
+}
+
+func main() {
+	var out []byte
+	var err error
+
+	// Demonstration of marshalling: Marshal s (struct) to out ([]byte)
+	fmt.Printf("Struct to JSON:\n")
+	s := &Cranberry{Visible: 1, invisible: 2, Custom: time.Unix(1521492409, 0)}
+	out, err = json.Marshal(s)
+	if err != nil {
+		panic(err)
+	}
+	fmt.Printf("      got=%v\n", string(out))
+	fmt.Println(` expected={"visible":1,"invisible":2,"epoch":1521492409}`)
+
+	// Demonstration of how to unmarshal: Unmarshal "out" ([]byte) to n (struct)
+	fmt.Printf("JSON to struct:\n")
+	var n = &Cranberry{}
+	err = json.Unmarshal(out, n)
+	if err != nil {
+		panic(err)
+	}
+	fmt.Printf("      got=%+v\n", n)
+	fmt.Println(` expected=&{Visible:1 invisible:2 Custom:2018-03-19 xx:46:49 xxxxx xxx}`)
+}