1. encoding/json 標準ライブラリの概要
Go言語には、JSONデータ形式を扱うための強力な encoding/json ライブラリが用意されています。このライブラリを使用すると、Goのデータ型を簡単にJSON形式に変換（シリアライズ）したり、JSONデータをGoのデータ型に変換（デシリアライズ）したりすることができます。また、このライブラリにはエンコード、デコード、ストリームIO、およびカスタムJSONパースロジックのサポートなど、多くの機能が提供されています。
このライブラリで最も重要なデータ型や関数には次のようなものがあります:
-
MarshalおよびMarshalIndent: Goのデータ型をJSON文字列にシリアライズするのに使用されます。 -
Unmarshal: JSON文字列をGoのデータ型にデシリアライズするのに使用されます。 -
EncoderおよびDecoder: JSONデータのストリームIOに使用されます。 -
Valid: 指定された文字列が有効なJSON形式かどうかをチェックするのに使用されます。
これらの関数や型の使用方法については、今後の章で具体的に学んでいきます。
2. Goデータ構造のJSONへのシリアライズ
2.1 json.Marshal の使用
json.Marshal は、Goのデータ型をJSON文字列にシリアライズするための関数です。この関数は、Go言語のデータ型を入力として受け取り、それらをJSON形式に変換してバイトスライスと可能なエラーを返します。
以下は、Goの構造体をJSON文字列に変換する方法を示す簡単な例です:
package main
import (
"encoding/json"
"fmt"
"log"
)
type Person struct {
Name string `json:"name"`
Age int `json:"age"`
}
func main() {
person := Person{"Alice", 30}
jsonData, err := json.Marshal(person)
if err != nil {
log.Fatalf("JSON marshaling failed: %s", err)
}
fmt.Println(string(jsonData)) // 出力: {"name":"Alice","age":30}
}
構造体以外にも、json.Marshal 関数はマップやスライスなどの他のデータ型もシリアライズすることができます。以下は map[string]interface{} と slice を使用した例です:
// マップをJSONに変換
myMap := map[string]interface{}{
"name": "Bob",
"age": 25,
}
jsonData, err := json.Marshal(myMap)
// ... エラーハンドリングと出力は省略しています ...
// スライスをJSONに変換
mySlice := []string{"Apple", "Banana", "Cherry"}
jsonData, err := json.Marshal(mySlice)
// ... エラーハンドリングと出力は省略しています ...
2.2 構造体タグ
Goでは、構造体タグを使用して構造体フィールドのメタデータを提供し、JSONシリアライゼーションの動作を制御します。最も一般的な使用例には、フィールドの名前変更、フィールドの無視、および条件付きシリアライゼーションがあります。
たとえば、 json:"<name>" タグを使用してJSONフィールドの名前を指定できます:
type Animal struct {
SpeciesName string `json:"species"`
Description string `json:"desc,omitempty"`
Tag string `json:"-"` // "-" を追加することで、このフィールドはシリアライズされないことを示します
}
上記の例では、Tag フィールドの前にある json:"-" タグは、json.Marshal にこのフィールドを無視するよう指示しています。Description フィールドの omitempty オプションは、フィールドが空（空の文字列などのゼロ値）の場合には、シリアライズされたJSONに含まれないことを示しています。
以下は、構造体タグを使用した完全な例です:
package main
import (
"encoding/json"
"fmt"
"log"
)
type Animal struct {
SpeciesName string `json:"species"`
Description string `json:"desc,omitempty"`
Tag string `json:"-"`
}
func main() {
animal := Animal{
SpeciesName: "African Elephant",
Description: "A large mammal with a trunk and tusks.",
Tag: "endangered", // このフィールドはJSONにシリアライズされません
}
jsonData, err := json.Marshal(animal)
if err != nil {
log.Fatalf("JSON marshaling failed: %s", err)
}
fmt.Println(string(jsonData)) // 出力: {"species":"African Elephant","desc":"A large mammal with a trunk and tusks."}
}
このようにして、JSON表現を柔軟に制御しながら、明確なデータ構造を確保することができます。
3. JSONをGoのデータ構造にデシリアライズ
3.1 json.Unmarshalの使用
json.Unmarshal関数を使用すると、JSON文字列をGoの構造体やマップなどのデータ構造にパースできます。json.Unmarshalを使用するためには、まずJSONデータに一致するGoのデータ構造を定義する必要があります。
次のJSONデータがあると仮定してみましょう：
{
"name": "Alice",
"age": 25,
"emails": ["[email protected]", "[email protected]"]
}
このデータをGoの構造体にパースするために、一致する構造体を定義する必要があります：
type User struct {
Name string `json:"name"`
Age int `json:"age"`
Emails []string `json:"emails"`
}
これでjson.Unmarshalを使って逆シリアル化することができます：
import (
"encoding/json"
"fmt"
)
func main() {
jsonData := `{
"name": "Alice",
"age": 25,
"emails": ["[email protected]", "[email protected]"]
}`
var user User
err := json.Unmarshal([]byte(jsonData), &user)
if err != nil {
fmt.Println("JSONの逆シリアル化エラー:", err)
return
}
fmt.Printf("ユーザー: %+v\n", user)
}
上記の例では、json:"name"のようなタグを使用して、JSONフィールドと構造体フィールドのマッピングについてjson.Unmarshal関数に通知しています。
3.2 動的パース
時には、事前にJSON構造がわからない場合や、JSONデータの構造が動的に変化する場合があります。そのような場合には、interface{}またはjson.RawMessageを使用できます。
interface{}を使用すると、JSON構造を事前に知らなくてもパースできます：
func main() {
jsonData := `{
"name": "Alice",
"details": {
"age": 25,
"job": "Engineer"
}
}`
var result map[string]interface{}
json.Unmarshal([]byte(jsonData), &result)
fmt.Println(result)
// タイプアサーションを使用して、使用する前に型が一致していることを確認します
name := result["name"].(string)
fmt.Println("名前:", name)
details := result["details"].(map[string]interface{})
age := details["age"].(float64) // 注意：interface{}内の数値はfloat64として扱われます
fmt.Println("年齢:", age)
}
json.RawMessageを使用すると、元のJSONを保持しながらその一部を選択的にパースすることができます：
type UserDynamic struct {
Name string `json:"name"`
Details json.RawMessage `json:"details"`
}
func main() {
jsonData := `{
"name": "Alice",
"details": {
"age": 25,
"job": "Engineer"
}
}`
var user UserDynamic
json.Unmarshal([]byte(jsonData), &user)
var details map[string]interface{}
json.Unmarshal(user.Details, &details)
fmt.Println("名前:", user.Name)
fmt.Println("年齢:", details["age"])
fmt.Println("職業:", details["job"])
}
このアプローチは、特定のフィールドに異なる種類のデータが含まれる可能性のあるJSON構造を処理するのに役立ち、柔軟なデータ処理を可能にします。
4 入れ子構造体と配列の処理
4.1 入れ子のJSONオブジェクト
一般的なJSONデータはしばしばフラットではなく、入れ子構造を含んでいます。Goでは、このような状況には入れ子の構造体を定義することで対処できます。
次の入れ子のJSONがあると仮定してみましょう：
{
"name": "Bob",
"contact": {
"email": "[email protected]",
"address": "123 Main St"
}
}
この場合、次のようにGoの構造体を定義できます：
type ContactInfo struct {
Email string `json:"email"`
Address string `json:"address"`
}
type UserWithContact struct {
Name string `json:"name"`
Contact ContactInfo `json:"contact"`
}
逆シリアル化操作は、非入れ子の構造体と同様です：
func main() {
jsonData := `{
"name": "Bob",
"contact": {
"email": "[email protected]",
"address": "123 Main St"
}
}`
var user UserWithContact
err := json.Unmarshal([]byte(jsonData), &user)
if err != nil {
fmt.Println("JSONの逆シリアル化エラー:", err)
}
fmt.Printf("%+v\n", user)
}
4.2 JSONの配列
JSONでは、配列は一般的なデータ構造です。Go言語では、これらはスライスに対応します。
以下のJSON配列を考えてみましょう:
[
{"name": "Dave", "age": 34},
{"name": "Eve", "age": 28}
]
Go言語では、次のように対応する構造体とスライスを定義します:
type Person struct {
Name string `json:"name"`
Age int `json:"age"`
}
func main() {
jsonData := `[
{"name": "Dave", "age": 34},
{"name": "Eve", "age": 28}
]`
var people []Person
json.Unmarshal([]byte(jsonData), &people)
for _, person := range people {
fmt.Printf("%+v\n", person)
}
}
このようにすることで、JSON配列内の各要素をGoの構造体のスライスに逆シリアル化して、さらなる処理やアクセスが可能となります。
5 エラーハンドリング
JSONデータを扱う際、構造化されたデータをJSON形式に変換する（シリアライズ）か、JSONを構造化されたデータに戻す（逆シリアル化）過程でエラーが発生することがあります。次に、一般的なエラーとその対処方法について説明します。
5.1 シリアライズエラーのハンドリング
シリアライズエラーは、通常、構造体や他のデータ型をJSON文字列に変換する過程で発生します。例えば、JSONで表現できないフィールド（チャネル型やJSONに表現できない関数など）を含む構造体をシリアライズしようとすると、json.Marshal はエラーを返します。
import (
"encoding/json"
"fmt"
"log"
)
type User struct {
Name string
Age int
// ここにシリアル化できないフィールドがあると仮定
// Data chan struct{} // チャネルはJSONで表現できません
}
func main() {
u := User{
Name: "Alice",
Age: 30,
// Data: make(chan struct{}),
}
bytes, err := json.Marshal(u)
if err != nil {
log.Fatalf("JSONのシリアライズに失敗しました：%v", err)
}
fmt.Println(string(bytes))
}
上記の例では、意図的にDataフィールドをコメントアウトしました。コメントを外すと、シリアライズは失敗し、プログラムはエラーをログ出力して実行を終了します。このようなエラーの対処は、通常、エラーを確認し、対応するエラーハンドリング戦略を実装すること（エラーのログ記録、デフォルトデータの返却など）が含まれます。
5.2 逆シリアライズエラーのハンドリング
逆シリアライズエラーは、JSON文字列をGoの構造体や他のデータ型に変換する過程で発生する可能性があります。例えば、JSON文字列の形式が間違っていたり、ターゲット型と互換性がない場合、json.Unmarshal はエラーを返します。
import (
"encoding/json"
"fmt"
"log"
)
func main() {
var data = []byte(`{"name":"Alice","age":"unknown"}`) // "age"は整数であるべきですが、ここでは文字列が提供されています
var u User
err := json.Unmarshal(data, &u)
if err != nil {
log.Fatalf("JSONの逆シリアライズに失敗しました：%v", err)
}
fmt.Printf("%+v\n", u)
}
このコード例では、意図的にageフィールドに間違ったデータ型（整数ではなく文字列）を提供し、json.Unmarshal がエラーをスローするようにしました。そのため、このような状況を適切にハンドリングする必要があります。一般的な手順は、エラーメッセージをログ出力し、シナリオに応じて空のオブジェクト、デフォルト値、あるいはエラーメッセージを返すことです。
6. 高度な機能とパフォーマンス最適化
6.1 カスタムのマーシャルとアンマーシャル
Goのencoding/jsonパッケージはデフォルトでリフレクションを使ってJSONのシリアライズとデシリアライズを行います。しかし、json.Marshalerとjson.Unmarshalerインターフェースを実装することで、これらのプロセスをカスタマイズすることができます。
import (
"encoding/json"
"fmt"
)
type Color struct {
Red uint8
Green uint8
Blue uint8
}
func (c Color) MarshalJSON() ([]byte, error) {
hex := fmt.Sprintf("\"#%02x%02x%02x\"", c.Red, c.Green, c.Blue)
return []byte(hex), nil
}
func (c *Color) UnmarshalJSON(data []byte) error {
_, err := fmt.Sscanf(string(data), "\"#%02x%02x%02x\"", &c.Red, &c.Green, &c.Blue)
return err
}
func main() {
c := Color{Red: 255, Green: 99, Blue: 71}
jsonColor, _ := json.Marshal(c)
fmt.Println(string(jsonColor))
var newColor Color
json.Unmarshal(jsonColor, &newColor)
fmt.Println(newColor)
}
ここでは、Color型を定義し、MarshalJSONとUnmarshalJSONメソッドを実装してRGBカラーを16進数文字列に変換し、逆にRGBカラーに戻しています。
6.2 エンコーダとデコーダ
大きなJSONデータを扱う場合、json.Marshalやjson.Unmarshalを直接使用するとメモリ消費が多くなったり、I/O処理が非効率になることがあります。そのため、Goのencoding/jsonパッケージはストリーム処理でJSONデータを扱うためのEncoderとDecoder型を提供しています。
6.2.1 json.Encoderの使用
json.Encoderは、io.Writerインタフェースを実装した任意のオブジェクトに直接JSONデータを書き込むことができます。つまり、JSONデータをファイルやネットワーク接続などに直接エンコードすることができます。
import (
"encoding/json"
"os"
)
func main() {
users := []User{
{Name: "Alice", Age: 30},
{Name: "Bob", Age: 25},
}
file, _ := os.Create("users.json")
defer file.Close()
encoder := json.NewEncoder(file)
if err := encoder.Encode(users); err != nil {
log.Fatalf("エンコードエラー: %v", err)
}
}
6.2.2 json.Decoderの使用
json.Decoderは、io.Readerインタフェースを実装した任意のオブジェクトから直接JSONデータを読み取り、JSONオブジェクトや配列を検索して解析することができます。
import (
"encoding/json"
"os"
)
func main() {
file, _ := os.Open("users.json")
defer file.Close()
var users []User
decoder := json.NewDecoder(file)
if err := decoder.Decode(&users); err != nil {
log.Fatalf("デコードエラー: %v", err)
}
for _, u := range users {
fmt.Printf("%+v\n", u)
}
}
エンコーダとデコーダを使用してデータを処理することで、読み取りながらJSON処理を行い、メモリ使用量を削減し処理効率を向上させることができます。特にネットワーク転送や大きなファイルを扱う場合に有用です。