交流群:462197261站长百科站长论坛热门标签收藏本站北冥有鱼 互联网前沿资源第一站 助力全行业互联网+
点击这里给我发消息
  • 当前位置:
  • golang使用json格式实现增删查改的实现示例

    北冥有鱼 教程大全 2020-05-22 ,,

    需求和思路

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


    广而告之:
    热门推荐:
    HTML中的标签和元素的区别详解

    相信很多初学网页的朋友都和我一样,搞不明白HTML中元素、标签、属性之间到底是怎么定义的,元素和标签有什么区别。为了彻底弄明白,我特意搜索查阅了一些资料,现将我得出的结论写出来,分享给和我有着同样迷惑的网友们: 很多人可能都没有把哪个叫标签,哪个叫元素这···

    JavaScript中操作Mysql数据库实例

    //创建数据库连接对象 var conn = new ActiveXObject("ADODB.Connection"); //创建数据集对象 var rs = new ActiveXObject("ADODB.Recordset"); try{ //数据库连接串,具体配置请参考:http://www.connectionstrings.com/ //如果不知道如何配置连接串,可以通过配置UDL文件后···

    为什么要少用Iframe的几个原因分析

    下图显示创建 100 个不同的元素中iframe到底有多耗费时间。 创建100个 elements 的耗时   使用 iframe 的页面一般不会包含太多 iframe,所以创建 DOM 节点所花费的时间不会占很大的比重。但带来一些其它的问题:onload 事件以及连接池(connection pool)。  If···

    使用express获取微信小程序二维码小记

    前言 遇到了一个需求,想要扫码后,进入微信小程序的某一个页面,这就要求二维码携带参数。 微信小程序开发文档很简单,但不太具体。 经百度和折腾,在express中成功获得了带参数的二维码。 总结以下几步,供参考。 1.express项目中引入http请求工具 为什么要在服务端引入这···

    js读取json的两种常用方法示例介绍

    方法一:js中最著名的eval方法 复制代码 代码如下: var strJson="{name:'张三'}";//json var obj=eval("("+strJson+")");//转换后的json对象 alert(obj.name);//json name 此方法需要注意的是: 对象表达式{'name':'张三'}必须用“()”扩住,否则 复制代码 代码如下: var strJS···

    jQuery 入门讲解1

    jQuery构造函数 JQuery优点 ◦体积小(v1.2.3 15kb) ◦丰富的DOM选择器(CSS1-3 + XPath) ◦跨浏览器(IE6,FF,Safari,Opera) ◦链式代码 ◦强大的事件、样式支持 ◦强大的AJAX功能 ◦易于扩展,插件丰富 jQuery的构造函数接收四种类···

    javascript中的闭包概念与用法实践分析

    本文实例讲述了javascript中的闭包概念与用法。分享给大家供大家参考,具体如下: 闭包的概念:闭包是指有权访问另一个函数作用域中的变量的函数 (引自《javascript高级程序设计第三版》178页)。闭包的优点是不会产生全局变量,避免变量污染问题,但是闭包也有一个缺点就是闭包···

    Angular2开发——组件规划篇

    本文集中讲讲笔者目前使用ng2来开发项目时对其组件的使用的个人的一些拙劣的经验。 先简单讲讲从ng1到ng2框架下组件的职责与地位: ng1中的一大特色——指令,分为属性型、标签型、css类型和注释型。其中写在css类以及注释中的组件想必多数人都不会去使用,而属性型指令与标签型···

    node.js操作MongoDB的实例详解

    node.js操作MongoDB时,需要安装mongodb包 1、使用npm安装cnpm npm install -g cnpm --registry=https://registry.npm.taobao.org 2、使用cnpm安装mongodb包 cnpm install mongodb node.js操作MongoDB时的四种方式:插入数据、更新数据、删除数据、查找数据。 操作步骤 ···

    jQuery 标题的自动翻转实现代码

    即一条新闻滚 进视图之后,会暂停几秒钟,然后继续向上2滚动,淡出视图,同时,下一条新闻接着滚入视图。这次主要是用jquery来开发这个功能,里面肯定有许多不足 之处,欢迎大家点评。 先粘贴一下代码, 复制代码 代码如下: <style> <%-- #news-feed { padding:···