golang简洁读写多源JSON数据插件库ej的使用

Golang简洁读写多源JSON数据插件库ej的使用

Easy Json (EJ)

ej包实现了一个JSON处理器，可以简洁地从不同来源（如文件和HTTP请求）读写JSON数据。

安装

go get -u github.com/lucassscaravelli/ej

示例

文件操作

package main

type exData struct {
	Hello int
	World []string
}

func main() {

	dataWrite := &exData{
		Hello: 1,
		World: []string{"h", "e", "l", "l", "o"},
	}

	var dataRead exData
	
	// 将dataWrite的内容序列化为JSON并写入ex.json文件
	if err := ej.JSON(from.File("ex.json")).Write(&dataWrite); err != nil {
		log.Fatal(err)
	}
	
	// 读取ex.json文件数据并将JSON反序列化到dataRead中
	if err := ej.JSON(from.File("ex.json")).ParseToData(&dataRead); err != nil {
		log.Fatal(err)
	}
	
	// 内容相等
	fmt.Printf("dataWrite: %+v\n", dataWrite)
	fmt.Printf("dataRead: %+v\n", dataRead)
}

HTTP请求处理

package main

import (
	"log"
	"net/http"

	"github.com/lucassscaravelil/ej"
	"github.com/lucassscaravelil/ej/from"
)

type requestPayload struct {
	NumberToFind int
	Numbers      []int
}

type responseErrorPayload struct {
	StatusCode int
	ErrorTxt   string
}

type responsePayload struct {
	Found  bool
	Number int
}

func writeError(jsonHandler *ej.EJ, status int, err error) {
	jsonHandler.Write(&responseErrorPayload{
		StatusCode: status,
		ErrorTxt:   err.Error(),
	})
}

func main() {

	http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) {

		var bodyData requestPayload

		jsonHandler := ej.JSON(from.Request(w, r))

		if err := jsonHandler.ParseToData(&bodyData); err != nil {
			writeError(jsonHandler, http.StatusBadRequest, err)
			return
		}

		found := false
		foundNumber := 0

		for _, number := range bodyData.Numbers {
			if number == bodyData.NumberToFind {
				found = true
				foundNumber = number
				break
			}
		}

		jsonHandler.Write(&responsePayload{
			Found:  found,
			Number: foundNumber,
		})

		return
	})

	log.Fatal(http.ListenAndServe(":8080", nil))
}

HTTP响应处理

package main

import (
	"log"
	"net/http"

	"github.com/lucassscaravelil/ej"
	"github.com/lucassscaravelil/ej/from"
)

type testData struct {
	Count int
	Txt   string
}

func main() {
	var responseData testData
	response, err := http.Get("http://<url>/any")
	if err != nil {
		log.Fatal(err)
	}

	if err := ej.JSON(Response(response)).ParseToData(&responseData); err != nil {
		log.Fatal(err)
	}

	fmt.Printf("dataRead: %+v\n", responseData)
}

更多关于golang简洁读写多源JSON数据插件库ej的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于golang简洁读写多源JSON数据插件库ej的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


使用 ej 库简洁读写多源 JSON 数据

ej 是一个轻量级的 Go 语言 JSON 处理库，专注于简化 JSON 数据的读写操作，特别适合处理多源 JSON 数据。以下是 ej 库的主要功能和使用方法。

安装 ej 库

go get github.com/lrita/ej

基本用法

1. 读取 JSON 数据

package main

import (
	"fmt"
	"github.com/lrita/ej"
)

func main() {
	// 从字符串读取JSON
	jsonStr := `{"name":"Alice","age":25,"address":{"city":"New York"}}`
	v, err := ej.Unmarshal([]byte(jsonStr))
	if err != nil {
		panic(err)
	}

	// 获取字段值
	name, _ := ej.GetString(v, "name")
	age, _ := ej.GetInt(v, "age")
	city, _ := ej.GetString(v, "address", "city")

	fmt.Printf("Name: %s, Age: %d, City: %s\n", name, age, city)
}

2. 写入 JSON 数据

package main

import (
	"fmt"
	"github.com/lrita/ej"
)

func main() {
	// 创建新的JSON对象
	obj := ej.NewObject()

	// 设置字段值
	ej.Set(obj, "name", "Bob")
	ej.Set(obj, "age", 30)
	ej.Set(obj, "address", ej.NewObject())
	ej.Set(obj, "address", "city", "Los Angeles")

	// 转换为JSON字符串
	jsonBytes, err := ej.Marshal(obj)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(jsonBytes))
	// 输出: {"name":"Bob","age":30,"address":{"city":"Los Angeles"}}
}

高级功能

1. 处理多源 JSON 数据

ej 特别适合合并或处理来自多个源的 JSON 数据：

package main

import (
	"fmt"
	"github.com/lrita/ej"
)

func main() {
	// 第一个JSON源
	json1 := `{"name":"Alice","age":25,"hobbies":["reading","swimming"]}`
	
	// 第二个JSON源
	json2 := `{"age":26,"address":{"city":"New York"},"hobbies":["hiking"]}`

	// 解析两个JSON
	v1, _ := ej.Unmarshal([]byte(json1))
	v2, _ := ej.Unmarshal([]byte(json2))

	// 合并两个JSON (v2会覆盖v1中相同的字段)
	merged := ej.Merge(v1, v2)

	// 获取合并后的数据
	name, _ := ej.GetString(merged, "name")
	age, _ := ej.GetInt(merged, "age")
	city, _ := ej.GetString(merged, "address", "city")
	hobbies, _ := ej.GetArray(merged, "hobbies")

	fmt.Printf("Name: %s, Age: %d, City: %s\n", name, age, city)
	fmt.Println("Hobbies:", hobbies)
}

2. 路径表达式查询

ej 支持使用路径表达式查询嵌套的 JSON 数据：

package main

import (
	"fmt"
	"github.com/lrita/ej"
)

func main() {
	jsonStr := `{
		"users": [
			{"name":"Alice","age":25},
			{"name":"Bob","age":30}
		],
		"settings": {"theme":"dark"}
	}`

	v, _ := ej.Unmarshal([]byte(jsonStr))

	// 使用路径表达式查询
	aliceName, _ := ej.GetString(v, "users", 0, "name")
	theme, _ := ej.GetString(v, "settings", "theme")

	fmt.Println("Alice's name:", aliceName)
	fmt.Println("Theme:", theme)
}

3. 修改现有 JSON 数据

package main

import (
	"fmt"
	"github.com/lrita/ej"
)

func main() {
	jsonStr := `{"name":"Alice","age":25,"hobbies":["reading"]}`
	v, _ := ej.Unmarshal([]byte(jsonStr))

	// 修改字段值
	ej.Set(v, "age", 26)
	
	// 向数组添加元素
	hobbies, _ := ej.GetArray(v, "hobbies")
	ej.Set(v, "hobbies", append(hobbies, "swimming"))

	// 添加新字段
	ej.Set(v, "address", ej.NewObject())
	ej.Set(v, "address", "city", "New York")

	jsonBytes, _ := ej.Marshal(v)
	fmt.Println(string(jsonBytes))
	// 输出: {"name":"Alice","age":26,"hobbies":["reading","swimming"],"address":{"city":"New York"}}
}

性能考虑

ej 库在性能上做了优化：

  1. 使用原生 encoding/json 进行底层解析
  2. 延迟计算路径表达式
  3. 最小化内存分配

对于大多数应用场景，ej 提供了良好的性能与简洁API的平衡。

总结

ej 库提供了以下优势：

  • 简洁的API设计，减少样板代码
  • 强大的路径表达式支持
  • 方便的多源JSON合并功能
  • 良好的错误处理机制
  • 与标准库兼容

对于需要处理复杂JSON结构的Go应用，ej是一个值得考虑的选择。它特别适合配置管理、API响应处理和数据分析等场景。

回到顶部