当前位置：移动技术网 > IT编程>脚本编程>Go语言 > golang使用json格式实现增删查改的实现示例

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

2020年06月18日 | 移动技术网IT编程 | 我要评论

需求和思路

在一般的小项目或者一个小软件,例如客户端之类的小程序中,可能会需要数据的持久化.但是使用一般的数据库(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增删查改内容请搜索移动技术网以前的文章或继续浏览下面的相关文章希望大家以后多多支持移动技术网！

您可能感兴趣的文章:

如对本文有疑问，点击进行留言回复！！

Go Web 编程中的模板库应用指南(超详细)

如果你有过web编程的经验，那么或多或少都听说过或者使用过模板。简而言之，模板是可用于创建动态内容的文本文件。例如，你有一个网站导航栏的模板，其中动态内容的一部... [阅读全文]
如何用golang运行第一个项目

安装一些必要的环境1.下载go sdk (本人装的是1.9) 2.下载golang3.下载git 因为有些依赖要用 go get 去github上获取 4.配... [阅读全文]
Go打包二进制文件的实现

背景众所周知，go语言可打包成目标平台二进制文件是其一大优势，如此go项目在服务器不需要配置go环境和依赖就可跑起来。操作需求：打包部署到centos7笔者打包... [阅读全文]
golang包快速生成base64验证码的方法

base64captcha快速生成base64编码图片验证码字符串支持多种样式,算术,数字,字母,混合模式,语音模式.base64是网络上最常见的用于传输8bi... [阅读全文]
使用Go语言创建WebSocket服务的实现示例

今天介绍如何用 go 语言创建 websocket 服务，文章的前两部分简要介绍了 websocket 协议以及用 go 标准库如何创建 websocket 服... [阅读全文]
Golang通过小程序获取微信openid的方法示例

为什么要获取小程序的 openid在开发微信小程序的过程中，小程序可以通过微信官方提供的登录能力方便地获取微信提供的用户身份标识，快速建立小程序内的用户体系。那... [阅读全文]
golang语言编码规范的实现

本规范旨在为日常go项目开发提供一个代码的规范指导，方便团队形成一个统一的代码风格，提高代码的可读性，规范性和统一性。本规范将从命名规范，注释规范，代码风格和 ... [阅读全文]
Windows下安装VScode 并使用及中文配置方法

首先明确一点，vscode是开发go应用的基础编辑器，是microsoft（微软的产品），可以运行在windows、linux、mac os x上使用，默认提供... [阅读全文]
GoLang之使用Context控制请求超时的实现

起因之前接触了一个需求：提供一个接口，这个接口有一个超时时间，如果超时了返回超时异常；这个接口中调用其他的接口，如果调用超时了，所有... [阅读全文]
Golang HTTP 服务平滑重启及升级的思路

golang http服务在上线时，需要重新编译可执行文件，关闭正在运行的进程，然后再启动新的运行进程。对于访问频率比较高的面向终端用户的产品，关闭、重启的过程... [阅读全文]

网友评论


验证码：

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

2020年06月18日 | 移动技术网IT编程 | 我要评论

您可能感兴趣的文章:

相关文章:

网友评论