devbox
天景科技苑
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【Unity】数据持久化--JSON

作者：天景科技苑 | 2024-06-28 16:53:34

赞

踩

【Unity】数据持久化--JSON

1、JSON基础语法

1.1 注释内容

单行注释 //

多行注释 /* 内容 */

  1. //注释内容
  2. /*
  3. 多行注释
  4. 123
  5. e1
  6. ds
  7. */
  8. /*

1.2 符号含义

大括号 {} 对象

中括号 [] 数组

冒号   : 键值对对应关系

逗号   , 数据分割

双引号 "" 键名/字符串

1.3 键值对表示

“

"键名":值内容

1.4 值类型

数字(整数或浮点)

字符串

true或false

数组

对象

null

  1. {
  2. 	"name":"小周",
  3. 	"age":24,
  4. 	"sex":true,
  5. 	"ids":[1, 2, 3],
  6. 	"students":[
  7. 		{"name":"小红", "age":18, "sex":false},
  8. 		{"name":"小明", "age":18, "sex":true}
  9. 	],
  10. 	"home":{
  11. 		"address":"重庆市垫江县",
  12. 		"street":""
  13. 	},
  14. 	"son":{
  15. 		"name":"小周周",
  16. 		"age":7,
  17. 		"sex":true
  18. 	}
  19. }

2、JsonUtility

2.1 JsonUtility介绍

JsonUtility是Unity自带的用于解析Json的公共类

它可以将内存中对象序列化为Json格式的字符串，也可以将Json字符串反序列化为类对象

2.2 在文件中存读字符串

1) 存储字符串到指定路径文件中

File.WriteAllText(arg1, arg2)

第一个参数 填写的是存储的路径

第二个参数 填写的是 存储的字符串内容

2) 在指定路径文件中读取字符串

File.ReadAllText(path)

  1.         //1.存储字符串到指定路径文件中
  2.         //第一个参数 填写的是存储的路径!
  3.         //第二个参数 填写的是 存储的字符串内容 
  4.         string path = Application.persistentDataPath + "/Test.json";
  5.         File.WriteAllText(path, "大哥存储的JSON文件");
  6.         Debug.Log(path);
  7.  
  8.         //2.在指定路径文件中读取字符串
  9.         string str = File.ReadAllText(path);
  10.         Debug.Log(str);

2.3 使用JsonUtlity进行序列化

序列化:把内存中的数据 存储到硬盘上

JsonUtility.ToJson(对象)

  1. [Serializable]
  2. public class Student
  3. {
  4.     public int age;
  5.     public string name;
  6.  
  7.     public Student(int age, string name)
  8.     {
  9.         this.age = age;
  10.         this.name = name;
  11.     }
  12. }
  13.  
  14. public class MrTang
  15. {
  16.     public string name;
  17.     public int age;
  18.     public bool sex;
  19.     public float testFloat;
  20.     public double testDouble;
  21.  
  22.     public int[] ids;
  23.     public List<int> ids2;
  24.     public Dictionary<int, string> dic;
  25.     public Dictionary<string, string> dic2;
  26.  
  27.     public Student s1;
  28.     public List<Student> s2s;
  29.  
  30. }
  31.  
  32. [Serializable]
  33. public class RoleInfo
  34. {
  35.     public int hp;
  36.     public int speed;
  37.     public int volume;
  38.     public string resName;
  39.     public int scale;
  40. }
  41.  
  42.         //序列化:把内存中的数据 存储到硬盘上
  43.         //方法:
  44.         //JsonUtility.ToJson(对象)
  45.         MrTang t = new MrTang();
  46.         t.name = "小周";
  47.         t.age = 18;
  48.         t.sex = true;
  49.         t.testFloat = 1.1f;
  50.         t.testDouble = 1.5;
  51.  
  52.         t.ids = new int[] { 1, 2, 3 };
  53.         t.ids2 = new List<int>() { 2, 3, 5, 6 };
  54.         t.dic = new Dictionary<int, string>() {
  55.             {1, "123" },
  56.             {2, "234" }
  57.         };
  58.         t.dic2 = new Dictionary<string, string>() {
  59.             {"12", "123" },
  60.             {"sds", "234" }
  61.         };
  62.  
  63.         t.s1 = new Student(18, "adada");
  64.         t.s2s = new List<Student>() { new Student(12, "小红"), new Student(17, "小明") };
  65.  
  66.         //]sonutility提供了线程的方法 可以把类对象 序列化为 json字符串
  67.         string jsonStr = JsonUtility.ToJson(t);
  68.         File.WriteAllText(Application.persistentDataPath + "/MrTang.json", jsonStr);

注意:

  • float序列化时看起来会有一些误差
  • 自定义类需要加上序列化特性[system.serializable]
  • 想要序列化私有变量 需要加上特性[serializeField]
  • JsonUtility不支持字典
  • Jsonutlity存储nu11对象不会是nu11 而是默认值的数据

2.4 使用JsonUtility进行反序列化

反序列化:把硬盘上的数据 读取到内存中

JsonUtility.FremJson(字符串)

  1.         //读取文件中的 Json字符串
  2.         jsonStr = File.ReadAllText(Application.persistentDataPath + "/MrTang.json");
  3.         //使用Json字符串内容 转换成类对象
  4.         MrTang t2 = JsonUtility.FromJson(jsonStr, typeof(MrTang)) as MrTang;
  5.         MrTang t3 = JsonUtility.FromJson<MrTang>(jsonStr);

注意:

  • 如果Json中数据少了，读取到内存中类对象中时不会报错

2.5 注意事项

  • 自定义尖需变加上序列化特性[System.serializable]
  • 私有保护成员 需要加上[SerializeField]
  • JsonUtility无法直接渎取数据集合
  • 文本编码格式需要时UTF-8 不然无法加载

3、LitJson

3.1 LitJson是什么

  • 它是一个第三方库，用于处理1son的序列化和反序列化
  • LitJson是c#编写的，体积小、速度快、易于使用
  • 它可以很容易的嵌入到我们的代码中
  • 只需要将LitJson代码拷贝到工程中即可

3.2 获取LitJson

  • 前往LitJson官网
  • 通过官网前往GitHub获取最新版本代码
  • 讲代码拷贝到unity工程中 即可开始使用LitJson

3.3 使用LitJson进行序列化

JsonMapper.ToJson(对象)

  1.         //JsonMapper.ToJson(对象)
  2.         MrTang2 t = new MrTang2();
  3.         t.name = "下周";
  4.         t.age = 18;
  5.         t.sex = true;
  6.         t.testFloat = 1.55f;
  7.         t.testDouble = 1.4;
  8.  
  9.         t.ids = new int[] { 1, 2, 3 };
  10.         t.ids2 = new List<int>() { 2, 3, 5, 6 };
  11.         //t.dic = new Dictionary<int, string>() {
  12.         //    {1, "123" },
  13.         //    {2, "234" }
  14.         //};
  15.         t.dic2 = new Dictionary<string, string>() {
  16.             {"12", "123" },
  17.             {"sds", "234" }
  18.         };
  19.  
  20.         //t.s1 = new Student2(18, "adada");
  21.         t.s1 = null;
  22.         t.s2s = new List<Student2>() { new Student2(12, "小红"), new Student2(17, "小明") };
  23.  
  24.         string jsonStr = JsonMapper.ToJson(t);
  25.         Debug.Log(Application.persistentDataPath);
  26.         File.WriteAllText(Application.persistentDataPath + "/MrTang2.json", jsonStr);

注意:

  • 相对JsonUtility不需要加特性
  • 不能序列化私有变量
  • 支持字曲类型
  • 需要引用LitJson命名空间
  • LitJson可以准确保存null

3.4 使用LitJson反序列化

JsonMapper.ToObject(字符串)

  1.         jsonStr = File.ReadAllText(Application.persistentDataPath + "/MrTang2.json");
  2.         JsonData data = JsonMapper.ToObject(jsonStr);
  3.         Debug.Log(data["name"]);
  4.         Debug.Log(data["age"]);
  5.  
  6.         MrTang2 st2 = JsonMapper.ToObject<MrTang2>(jsonStr);

注意:

  • 类结构需要无参构造函数，否则反序列化时报错
  • 字典虽然支持 但是键在使用为数值时会有问题 需要使用字符串类型

3.5 注意事项

  • Litson无需加特性
  • LitJson不支持私有变量
  • LitJson支持字典序列化反序列化
  • Litison可以直接将数据反序列化为数据集合
  • LitJson反序列化时 自定义类型需要无参构造
  • Json文档编码格式必须是UTF-8

4、Json数据管理类

另外需要LitJson代码

  1. using LitJson;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using System.IO;
  5. using UnityEngine;
  6.  
  7. /// <summary>
  8. /// 序列化和反序列化JSON时 使用哪一种方案
  9. /// </summary>
  10. public enum JsonType
  11. {
  12.     JsonUtility,
  13.     LitJson
  14. }
  15.  
  16. /// <summary>
  17. /// Json数据管理类 主要用于进行 json的序列化存储到硬盘 和 反序列化从硬盘中读取到内存中
  18. /// </summary>
  19. public class JsonMgr
  20. {
  21.     private static JsonMgr instance = new JsonMgr();
  22.     public static JsonMgr Instance
  23.     {
  24.         get
  25.         {
  26.             return instance;
  27.         }
  28.     }
  29.     private JsonMgr() { }
  30.  
  31.  
  32.     /// <summary>
  33.     /// 存储JSON数据 序列化
  34.     /// </summary>
  35.     public void SavaData(object data, string fileName, JsonType jsonType = JsonType.LitJson)
  36.     {
  37.         //确定存储路径
  38.         string path = Application.persistentDataPath + "/" + fileName + ".json";
  39.         Debug.Log(path);
  40.  
  41.         //序列化 得到Json字符串
  42.         string jsonStr = "";
  43.         switch (jsonType)
  44.         {
  45.             case JsonType.JsonUtility:
  46.                 jsonStr = JsonUtility.ToJson(data);
  47.                 break;
  48.             case JsonType.LitJson:
  49.                 jsonStr = JsonMapper.ToJson(data);
  50.                 break;
  51.             default:
  52.                 break;
  53.         }
  54.  
  55.         //把序列化的Json字符串 存储到指定路径中
  56.         File.WriteAllText(path, jsonStr);
  57.     }
  58.  
  59.     /// <summary>
  60.     /// 读取指定文件中的 json数据 反序列化
  61.     /// </summary>
  62.     /// <typeparam name="T"></typeparam>
  63.     /// <param name="fileName"></param>
  64.     /// <param name="jsonType"></param>
  65.     /// <returns></returns>
  66.     public T LoadData<T>(string fileName, JsonType jsonType = JsonType.LitJson) where T : class, new()
  67.     {
  68.         //确定从哪个路径读取
  69.         //首先先判断 默认数据文件夹中是否有我们想要的数据 如果有 就从中获取
  70.         string path = Application.persistentDataPath + "/" + fileName + ".json";
  71.         //先判断 是否存在这个文件
  72.         //如果不存在默认文件 就从 读写文件夹中去寻找
  73.         if (!File.Exists(path))
  74.             path = Application.streamingAssetsPath + "/" + fileName + ".json";
  75.         //如果读写文件夹中都还没有 那就返回一个默认对象
  76.         if (!File.Exists(path))
  77.             return new T();
  78.  
  79.         //进行反序列化
  80.         string jsonStr = File.ReadAllText(path);
  81.  
  82.         T data = default(T);
  83.  
  84.         switch (jsonType)
  85.         {
  86.             case JsonType.JsonUtility:
  87.                 data = JsonUtility.FromJson<T>(jsonStr);
  88.                 break;
  89.             case JsonType.LitJson:
  90.                 data = JsonMapper.ToObject<T>(jsonStr);
  91.                 break;
  92.             default:
  93.                 break;
  94.         }
  95.  
  96.         //把对象返回出去
  97.         return data;
  98.     }
  99.  
  100. }

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/天景科技苑/article/detail/766655
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号