golang使用json格式实现增删查改示例

需求和思路

在一般的小项目或者一个小软件,例如客户端之类的小程序中,可能会需要数据的持久化.但是使用一般的数据库(Mysql)之类的不合适.使用sqlite3这种嵌入式的是个较好的方法,但是Go语言中sqlite3的库是C语言的,Cgo不支持跨平台编译.正是由于这种需求,才想到使用json格式将数据直接保存在文件中.
具体的思路是怎么样呢? 在Go语言中如果要将数据转化成json格式的话,有两种格式 struct 和 map. 如果同时需要增删查改功能的话,将map作为中间格式是比较合适的.接下来我们就来实现它.

查询操作

这种操作的实现比较简单,直接将文件中的数据读取出来,使用json库反序列化就可以了. 代码如下 :

type Product struct {
Name string `json:"name"`
Num int  `json:"num"`
}

func findAll() {
ps := make([]Product, 0)

data, err := ioutil.ReadFile("./index.json")
if err != nil {
  log.Fatal(err)
}

// 这里参数要指定为变量的地址
err = json.Unmarshal(data, &ps)
if err != nil {
  log.Fatal(err)
}

fmt.Println(ps)
}

添加操作

添加的实现实在查询的基础上的,我们需要先查询文件中的数据库,并转化为map格式,再将struct也转化为map格式(这里要使用反射),合并map,json序列化,最后保存在文件中.代码如下:

func create() {
fields := make([]map[string]interface{}, 0)

p1 := &Product{
  Name: "Blog",
  Num: 2,
}

_, _ = json.Marshal(p1)
// 读取文件中的数据,保存为map格式
data, _ := ioutil.ReadFile("./index.json")
err := json.Unmarshal(data, &fields)
if err != nil {
  log.Fatal(err)
}

// 使用反射将struct转化为map
tp := reflect.TypeOf(p1).Elem()
vp := reflect.ValueOf(p1).Elem()
field := make(map[string]interface{}, 0)
for i := 0; i < tp.NumField(); i++ {
  field1 := tp.Field(i)
  field2 := vp.Field(i)
  key := field1.Tag.Get("json")
  field[key] = field2.Interface()
}
// 合并map
fields = append(fields, field)

// 写入文件
out, _ := json.Marshal(fields)
_ = ioutil.WriteFile("./index.json", out, 0755)
}

条件查询

思路: 将struct转化为map,根据输入的条件查询.查询的结果转化为struct.代码如下:

func FindOne() {
product := &Product{}

p1 := &Product{
  Name: "John",
  Num: 23,
}

// 使用反射将struct转化为map
tp := reflect.TypeOf(p1).Elem()
vp := reflect.ValueOf(p1).Elem()
field := make(map[string]interface{}, 0)
for i := 0; i < tp.NumField(); i++ {
  field1 := tp.Field(i)
  field2 := vp.Field(i)
  key := field1.Tag.Get("json")
  switch field2.Kind() {
  case reflect.Int:
    field[key] = float64(field2.Interface().(int))
  case reflect.Int8:
    field[key] = float64(field2.Interface().(int8))
  case reflect.Int16:
    field[key] = float64(field2.Interface().(int16))
  case reflect.Int32:
    field[key] = float64(field2.Interface().(int32))
  case reflect.Int64:
    field[key] = float64(field2.Interface().(int64))
  case reflect.Uint:
    field[key] = float64(field2.Interface().(uint))
  case reflect.Uint8:
    field[key] = float64(field2.Interface().(uint8))
  case reflect.Uint16:
    field[key] = float64(field2.Interface().(uint16))
  case reflect.Uint32:
    field[key] = float64(field2.Interface().(uint32))
  case reflect.Uint64:
    field[key] = float64(field2.Interface().(uint64))
  case reflect.Float32:
    field[key] = float64(field2.Interface().(float32))
  case reflect.Float64:
    field[key] = field2.Interface()
  default:
    field[key] = field2.Interface()
  }
}

_, _ = json.Marshal(p1)
// 读取文件中的数据,保存为map格式
// 数据转化为map时,数值类型的统一变成float64
data, _ := ioutil.ReadFile("./index.json")
fields := make([]map[string]interface{}, 0)
err := json.Unmarshal(data, &fields)
if err != nil {
  log.Fatal(err)
}

// 查询的条件
columns := []string{"name", "num"}
length := len(columns)
for _, item := range fields {
  for i := 0; i < length; i++ {
    // 这里的比较需要改进
    if item[columns[i]] != field[columns[i]] {
      break
    }
    if i == length-1 {
      field = item
      goto OVER
    }
  }
}
OVER:
fmt.Println(field)

out, _ := json.Marshal(field)
_ = json.Unmarshal(out, &product)

fmt.Println(product)
}

修改操作

修改操作在查询操作的基础上实现, 修改操作需要有一个id值,能确定元素的唯一性.代码如下:

func Update() {
p1 := &Product{
  Id:  "2bbec87025968879c3c9682abe3bf730",
  Name: "John_e",
  Num: 100,
}

// 使用反射将struct转化为map
tp := reflect.TypeOf(p1).Elem()
vp := reflect.ValueOf(p1).Elem()
field := make(map[string]interface{}, 0)
for i := 0; i < tp.NumField(); i++ {
  field1 := tp.Field(i)
  field2 := vp.Field(i)
  key := field1.Tag.Get("json")
  switch field2.Kind() {
  case reflect.Int:
    field[key] = float64(field2.Interface().(int))
  case reflect.Int8:
    field[key] = float64(field2.Interface().(int8))
  case reflect.Int16:
    field[key] = float64(field2.Interface().(int16))
  case reflect.Int32:
    field[key] = float64(field2.Interface().(int32))
  case reflect.Int64:
    field[key] = float64(field2.Interface().(int64))
  case reflect.Uint:
    field[key] = float64(field2.Interface().(uint))
  case reflect.Uint8:
    field[key] = float64(field2.Interface().(uint8))
  case reflect.Uint16:
    field[key] = float64(field2.Interface().(uint16))
  case reflect.Uint32:
    field[key] = float64(field2.Interface().(uint32))
  case reflect.Uint64:
    field[key] = float64(field2.Interface().(uint64))
  case reflect.Float32:
    field[key] = float64(field2.Interface().(float32))
  case reflect.Float64:
    field[key] = field2.Interface()
  default:
    field[key] = field2.Interface()
  }
}

_, _ = json.Marshal(p1)
// 读取文件中的数据,保存为map格式
// 数据转化为map时,数值类型的统一变成float64
data, _ := ioutil.ReadFile("./index.json")
fields := make([]map[string]interface{}, 0)
err := json.Unmarshal(data, &fields)
if err != nil {
  log.Fatal(err)
}

// 修改的条件
columns := []string{"name", "num"}
for _, v := range fields {
  if v["_id"] == field["_id"] {
    for _, col := range columns {
      v[col] = field[col]
    }
    field = v
  }
}

out, _ := json.MarshalIndent(fields, "", " ")
_ = ioutil.WriteFile("./index.json", out, 0755)
}

删除操作

最后就是删除操作了,这个比较思路简单,输入唯一的id值,删除对应的字段,再保存到文件就可以了.代码如下:

func Delete() {
p1 := &Product{
  Id:  "db43fa2d4f69cddce7494941cb36032b",
  Name: "John_e",
  Num: 100,
}

_, _ = json.Marshal(p1)
// 读取文件中的数据,保存为map格式
// 数据转化为map时,数值类型的统一变成float64
data, _ := ioutil.ReadFile("./index.json")
fields := make([]map[string]interface{}, 0)
err := json.Unmarshal(data, &fields)
if err != nil {
  log.Fatal(err)
}

length := len(fields)
for index, field := range fields {
  if field["_id"] == p1.Id {
    if index == length - 1 {
      fields = fields[0:index]
    } else {
      fields = append(fields[0:index], fields[index+1:]...)
    }
  }
}

out, _ := json.MarshalIndent(fields, "", " ")
_ = ioutil.WriteFile("./index.json", out, 0755)
}

完整版

最后在附上完整版代码：

package store

import (
"bytes"
"crypto/md5"
"encoding/json"
"errors"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"reflect"
"strings"
"time"
)

type Store struct {
Dir string
}

func NewStore(dir string) (*Store, error) {

// .开头的为相对路径,补全为全路径
if strings.HasPrefix(dir, ".") {
  pwd, _ := os.Getwd()
  dir = filepath.Join(pwd, dir)
}
store := &Store{Dir: dir}

st, err := os.Stat(dir)
if err != nil {
  err = os.Mkdir(dir, 0755)
  if err != nil {
    return nil, err
  }
} else if st != nil && !st.IsDir() {
  return nil, errors.New("file already exists")
}

return store, nil
}

// 创建与结构体对应的json文件
func (s *Store) Sync(values ...interface{}) error {
for _, v := range values {
  tb := parseTn(v)
  if tb == "" {
    return errors.New("does not find store")
  }
  _path := filepath.Join(s.Dir, tb)
  _, err := os.Stat(_path)
  if err != nil {
    _ = ioutil.WriteFile(_path, []byte("[]"), 0755)
  }
}
return nil
}

// 删除所有
func (s *Store) Destroy() error {
return os.RemoveAll(s.Dir)
}

func (s *Store) FindAll(v interface{}) error {

_path, err := s.before(v)
if err != nil {
  return err
}

out, err := s.readAll(_path)
if err != nil {
  return err
}
err = json.Unmarshal(out, &v)
return err
}

func (s *Store) FindOne(v interface{}, columns ...string) (interface{}, error) {

_path, err := s.before(v)
if err != nil {
  return nil, err
}

data, err := s.readAll(_path)
if err != nil {
  return nil, err
}

fields := make([]map[string]interface{}, 0)
err = json.Unmarshal(data, &fields)
if err != nil {
  return nil, err
}

m := structToMap(v)
length := len(columns)
for _, item := range fields {
  for i := 0; i < length; i++ {
    // TODO 这里的比较需要改进
    if item[columns[i]] != m[columns[i]] {
      break
    }
    if i == length-1 {
      m = item
      goto OVER
    }
  }
}
OVER:

err = mapToStruct(m, &v)
if err != nil {
  return nil, err
}

return v, nil
}

func (s *Store) Create(v interface{}) error {

_path, err := s.before(v)
if err != nil {
  return err
}

data, err := s.readAll(_path)
if err != nil {
  return err
}

fields := make([]map[string]interface{}, 0)
err = json.Unmarshal(data, &fields)
if err != nil {
  return err
}

m := structToMap(v)
m["_id"] = randId()

fields = append(fields, m)

err = s.writeAll(_path, fields)
if err != nil {
  return err
}

err = mapToStruct(m, v)
if err != nil {
  return err
}

return nil
}

func (s *Store) Update(v interface{}, columns ...string) error {

_path, err := s.before(v)
if err != nil {
  return err
}

data, err := s.readAll(_path)
if err != nil {
  return err
}

fields := make([]map[string]interface{}, 0)
err = json.Unmarshal(data, &fields)
if err != nil {
  return err
}

m := structToMap(v)
for _, v := range fields {
  if v["_id"] == m["_id"] {
    for _, col := range columns {
      v[col] = m[col]
    }
    m = v
  }
}

err = s.writeAll(_path, fields)
if err != nil {
  return err
}

return nil
}

func (s *Store) Delete(v interface{}) error {

_path, err := s.before(v)
if err != nil {
  return err
}

data, err := s.readAll(_path)
if err != nil {
  return err
}

fields := make([]map[string]interface{}, 0)
err = json.Unmarshal(data, &fields)
if err != nil {
  return err
}

m := structToMap(v)
length := len(fields)
for index, field := range fields {
  if field["_id"] == m["_id"] {
    if index == length-1 {
      fields = fields[0:index]
    } else {
      fields = append(fields[0:index], fields[index+1:]...)
    }
  }
}

err = s.writeAll(_path, fields)
if err != nil {
  return err
}

return nil
}

func (s *Store) Clean(v interface{}) error {
_path, err := s.before(v)
if err != nil {
  return err
}

return os.Remove(_path)
}

func (s *Store) readAll(file string) ([]byte, error) {
out, err := ioutil.ReadFile(file)
if err != nil {
  return nil, err
}
return out, nil
}

func (s *Store) writeAll(file string, v interface{}) error {
out, err := json.MarshalIndent(v, "", " ")
if err != nil {
  return err
}

err = ioutil.WriteFile(file, out, 0755)
if err != nil {
  return err
}

return nil
}

func (s *Store) before(v interface{}) (string, error) {
tb := parseTn(v)
if tb == "" {
  return "", errors.New("invalid table name")
}

_path := filepath.Join(s.Dir, tb)
_, err := os.Stat(_path)
if err != nil {
  return "", err
}

return _path, nil
}

func structToMap(v interface{}) map[string]interface{} {
tp := reflect.TypeOf(v).Elem()
vp := reflect.ValueOf(v).Elem()
field := make(map[string]interface{}, 0)
for i := 0; i < tp.NumField(); i++ {
  field1 := tp.Field(i)
  field2 := vp.Field(i)
  key := field1.Tag.Get("json")
  field[key] = field2.Interface()
  switch field2.Kind() {
  case reflect.Int:
    field[key] = float64(field2.Interface().(int))
  case reflect.Int8:
    field[key] = float64(field2.Interface().(int8))
  case reflect.Int16:
    field[key] = float64(field2.Interface().(int16))
  case reflect.Int32:
    field[key] = float64(field2.Interface().(int32))
  case reflect.Int64:
    field[key] = float64(field2.Interface().(int64))
  case reflect.Uint:
    field[key] = float64(field2.Interface().(uint))
  case reflect.Uint8:
    field[key] = float64(field2.Interface().(uint8))
  case reflect.Uint16:
    field[key] = float64(field2.Interface().(uint16))
  case reflect.Uint32:
    field[key] = float64(field2.Interface().(uint32))
  case reflect.Uint64:
    field[key] = float64(field2.Interface().(uint64))
  case reflect.Float32:
    field[key] = float64(field2.Interface().(float32))
  case reflect.Float64:
    field[key] = field2.Interface()
  default:
    field[key] = field2.Interface()
  }
}

return field
}

func mapToStruct(m map[string]interface{}, v interface{}) error {
out, err := json.Marshal(m)
if err != nil {
  return err
}
return json.Unmarshal(out, &v)
}

func toSnake(s string) string {
out := bytes.Buffer{}

bName := []byte(s)

point := 0
for index, b := range bName {
  // 非大写,不需要转化
  if b < 65 || b > 90 || index-point < 2 {
    out.WriteByte(b)
    continue
  }
  // 首字符大写,直接转化为小写
  if index == 0 {
    out.WriteByte(b + 32)
    point = index
  }
  // 连续三个大写,触发转化
  if index-point >= 2 {
    out.WriteByte(95)
    out.WriteByte(b + 32)
    point = index
  }
}

return out.String()
}

func parseTn(v interface{}) string {
var name string

tp := reflect.TypeOf(v).Elem()
switch tp.Kind() {
case reflect.Ptr:
  sp := strings.Split(tp.String(), ".")
  name = sp[len(sp)-1]
case reflect.Slice:
  sp := strings.Split(tp.String(), ".")
  name = sp[len(sp)-1]
case reflect.Struct:
  name = tp.Name()
}
name = toSnake(name)
return name + ".json"
}

func randId() string {
return fmt.Sprintf("%x", md5.Sum([]byte(time.Now().String())))
}

关于golang使用json格式实现增删查改的实现示例的文章就介绍至此，更多相关golang json增删查改内容请搜索编程宝库以前的文章，希望大家多多支持编程宝库！

viper作为配置框架，其功能非常的强大，我们没有理由不去了解一下。我们先看官网对它的功能简介：viper是完整配置解决方案，他可以处理所有类型和格式的配置文件，他有如下功能：设置默 ...