Unity数据存储(PlayerPrefabs\XML\JSON)

时间 2020-05-07 标签 unity 数据存储 playerprefabs xml json

数据存储

#1、 PlayerPrefs存储数据

++1.1、PlayerPrefs适用范围node

++++1、适用设备： Mac OSX、Linux、Windows、Windows Store Apps、Windows Phone 8、Web players。数据库

++++2、存储机制： Key-Value。编程

++++3、可存储变量类型： int、float、string。json

++1.2、PlayerPrefs数据存储路径设计模式

++++1、Mac OSX：~/Library/Preferences数组

++++2、Windows：HKCU\Software\[company name]\[product name]服务器

++++3、Linux：~/.config/unity3d/[CompanyName]/[ProductName]网络

++++4、Windows Store Apps: %userprofile%\AppData\Local\Packages\[ProductPackageId]>\LocalState\playerprefs.datapp

++++5、WebPlayer学习

++++6、Mac OS X：~/Library/Preferences/Unity/WebPlayerPrefs

++++7、Windows：%APPDATA%\Unity\WebPlayerPrefs

++1.3、PlayerPrefs经常使用方法

++++SetFloat ：存储float类型的数据。

++++SetInt ：存储int类型的数据。

++++SetString ：存储string类型的数据。

++++DeleteAll ：删除全部PlayerPrefs数据。

++++GetFloat ：经过Key值获取float类型的数据。

++++GetInt ：经过Key值获取int类型的数据。

++++GetString ：经过Key值获取string类型的数据。

++++HasKey ：判断是否存在该Key值的数据。

++实例

void Example(){

PlayerPrefs.SetFloat(“Player Score”, 10.0F);

print(PlayerPrefs.GetFloat(“Player Score”));

}

++拓展：《Unity3D游戏开发之数据持久化PlayerPrefs的使用》

++++前言：

--数据持久化在任何一个开发领域都是一个值得关注的问题，小到一个应用中配置文件的读写，大到数据库的管理维护，均可以看到数据持久化的身影。

--数据持久化从某种意义上来讲，就是序列化和反序列化的过程。

++++Unity3D中实现数据读写的简单代码：

//保存数据

PlayerPrefs.SetString(“Name”,mName);

PlayerPrefs.SetInt(“Age”,mAge);

PlayerPrefs.SetFloat(“Grade”,mGrade);

//读取数据

mName = PlayerPrefs.GetString(“Name”,“DefaultValue”);

mAge = PlayerPrefs.GetInt(“Age”, 0);

mGrade = PlayerPrefs.GetFloat(“Grade”, 0F);

--经过上面两段代码，咱们能够发现两点：

---1、Unity3D中的数据持久化是以键值的形式存储的，能够看做是一个字典。

---2、Unity3D中的值是经过键名来读取的，当值不存在时，返回默认值。

++++Unity3D中支持int、string、float三种数据类型的读取。

#2、XML数据生成和解析

++2.1、XML简介

++++1、XML指可扩展标记语言（EXtensible Markup Language）。

++++2、XML是一种标记语言，很相似HTML。

++++3、XML的设计宗旨是传输数据，而非显示数据。

++2.2、XML结构

++++每一个标签内部能够有多个属性。标签能够层层嵌套，造成一个树形结构。

++++例如：

</position>

++2.3、XML节点

<Time>

StringValue

</Time>

</Alarm>

--以上Alarm(元素节点)，lock(属性节点)，Time(元素节点)，StringValue(文本节点)都是节点（Node），

--可是只有<Alarm> ...... </Alarm>和<Time> StringValue </Time>是元素（Element）。

++2.4、XML经常使用的类

++++1、XmlDocument：XML文件类。

++++2、XmlNode：XML节点类。

++++3、XmlAttribute：XML属性类。

++++4、XmlElement：XML元素类。

++2.5、XML继承结构

++++结构：

-System.Object

-System.Xml.XmlNode（表示XML节点）

+System.Xml.XmlDocument（表示XML文档）

+System.Xml.XmlAttribute（表示XML属性）

-System.Xml.XmlLinkedNode

+System.Xml.XmlElement（表示XML元素）

++2.6、XmlNode

++++InnerText ：获取或设置节点及其全部子节点的值。（仅元素节点拥有）

++++Value ：获取或设置节点的值。（仅属性节点拥有）

++++AppendChild ：将指定的节点添加到该节点的子节点列表的末尾。

++2.7、XmlDocument

++++CreateXmlDeclaration ：建立一个具备指定值的XmlDeclaration节点。

++++CreateElement ：建立具备指定名称的元素。

++++CreateNode ：建立具备指定的节点类型、Name和NamespaceURI的XmlNode。

++++AppendChild ：将指定的节点添加到该节点的子节点列表的末尾。（继承自XmlNode）

++++Save ：将XML文档保存到指定的文件。

++2.8、XmlElement

++++SetAttribute ：设置具备指定名称的特性的值。

++++HasAttributes ：判断该元素节点是否具备属性。

++2.9、Xml数据生成步骤

++++在Unity引擎中如何生成本地XML数据？

--第一步：引用C#的命名空间：System.Xml。

--第二步：生成XML文档（XmlDocument类）。

--第三步：生成根元素（XmlElement类）添加给文档对象。

--第四步：循环生成子元素添加给父元素。

--第五步：将生成的XML文档保存。

++++Xml数据生成示例：

using System.Xml; //引用Xml命名空间

XmlDocument doc = new XmlDocument(); //建立xml文件对象

XmlNode xmldct = doc.CreateXmlDeclaration(“1.0”,“utf-8”,null); //建立xml头

doc.AppendChild(xmldct); //添加xml头

XmlNode root = doc.CreateElement(“users”); //建立xml根节点（元素属于节点）users

doc.AppendChild(root); //添加Xml根节点

XmlNode xn_element = doc.CreateNode(XmlNodeType.Element, “name”,null); //建立子节点

xn_element.InnerText = “Albert”; //设置子节点的值

XmlAttribute xa = doc.CreateAttribute(“no”); //建立属性

xa.Value = “1234”; //设置属性值

XmlDocument xd = xn_element.OwnerDocument; //获取元素的document

xn_element.Attributes.SetNamedItem(xa); //设置元素属性

root.AppendChild(xn_element); //添加子节点到root节点

doc.Save(Application.dataPath+“/test.xml”); //保存xml

++练习

++++编写代码生成XML文档，存储右边对象的Transform信息：

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using System.Xml; //使用xml时引入的命名空间

using System.Xml.XPath;

using UnityEditor;

public class Scene07Sql_1218_Xml_1716 :MonoBehaviour{

XmlDocument docXml; //1、建立xml文档

string filePath; //xml保存的路径//这里Assets路径

void Start(){

filePath = Application.dataPath + “/Part20171218SQL/MySql_Data1218/MySql_XmlData1218.xml”;

docXml = new XmlDocument(); //实例化xml文档

MyXml_CreateXML(); //使用代码建立XML文件

}

void MyXml_CreateXML(){

XmlDeclaration decHead = docXml.CreateXmlDeclaration(“1.0”,“UTF-8”,null); //1、建立头部信息

docXml.AppendChild(decHead); //添加：头部信息放置到XML文档中

XmlElement rootMyXml = docXml.CreateElement(“Player_rootXml”); //生成根元素

XmlAttribute attrRoot = docXml.CreateAttribute(“Name_Player_rootXml”); //为root添加一个属性标签

attrRoot.Value = “立钻哥哥”; //给属性标签设置标签值

rootMyXml.Attributes.SetNamedItem(attrRoot); //将属性标签设置为root的一个属性

docXml.AppendChild(rootMyXml); //将root添加到文件中

//3、向根节点添加子元素

XmlElement m_gameObject = docXml.CreateElement(“gameObject_SubElement”);

m_gameObject.SetAttribute(“tag”,“Player”); //属性

m_gameObject.SetAttribute(“layer”,“Default”);

rootMyXml.AppendChild(m_gameObject);

//继续添加子元素

XmlElement m_transform = docXml.CreateElement(“Transform_SubElement”);

rootMyXml.AppendChild(m_transform);

XmlElement m_position = docXml.CreateElement(“Position”);

m_transform.AppendChild(m_position);

docXml.Save(filePath); //4、保存xml

UnityEditor.AssetDatabase.Refresh(); //文本刷新

}

++2.10、Xml序列化

++++序列化是将对象状态转换为可保持或传输的格式的过程。

++++咱们能够把对象序列化为不一样的格式，好比说，Json序列化、XML序列化、二进制序列化等，以上这些不一样的格式也都是为了适应具体的业务需求。

++++序列化示例：

public class BaseInfo{

List<Person> perList = new List<Person>(); //BaseInfo对象中保存Person对象

//建立元素节点

[XmlElement(ElementName =“Person”)]

public List<Person> PerList{

get{

return perList;

}

set{

perList = value;

}

Person p1 = newPerson(“小王”,33); //实例化Person对象

Person p2 = newPerson(“小李”,44);

BaseInfo baseInfo = newBaseInfo(); //实例化序列化对象

baseInfo.PerList.Add(p1); //保存person对象

baseInfo.PerList.Add(p2);

StringWriter sw = new StringWriter(); //用于将信息写入字符串

//指定Xml序列化名字空间

XmlSerializerNamespaces ns = new XmlSerializerNamespaces();

ns.Add(“”,“”);

//声明Xml序列化对象示例serializer，对BaseInfo类进行序列化

XmlSerializer serializer = new XmlSerializer(typeof(BaseInfo));

Serializer.Serialize(sw,baseInfo,ns); //使用StringWriter和指定的命名空间将BaseInfo对象写入Xml文件

sw.Close();

++练习

++++将下面关于人物的信息进行XML序列化。

---Scene04Xml_Book1219.cs

---Scene04Xml_Books1219.cs

---Scene04Xml_Person1219.cs

---Scene04Xml_BaseInfo1219.cs

---Scene04Xml_MainCamera_Serialization.cs

++++Scene04Xml_Book1219.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

//书籍类Book

public class Scene04Xml_Book1219{

string title; //书名

string price; //价格

public string Title{

get{

return title;

}

set{

title=value;

}

public string Price{

get{

return price;

}

set{

price = value;

}

public Scene04Xml_Book1219(){

}

public Scene04Xml_Book1219(string _title, string _price){

this.title = _title;

this.price = _price;

}

++++Scene04Xml_Books1219.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using System.Xml.Serialization; //引入序列化命名空间

//书籍类

public class Scene04Xml_Books1219{

List<Scene04Xml_Book1219> bookList =new List<Scene04Xml_Book1219>(); //Books存储Book类

[XmlElement(ElementName=“ylzBook”)] //元素名称为Book，也就是将Book转换为XML中的元素时指定的名称

publicList<Scene04Xml_Book1219>BookList{

get{

return bookList;

}

set{

bookList=value;

}

++++Scene04Xml_Person1219.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using System.Xml.Serialization; //引入序列化命名空间

public class Scene04Xml_Person1219{

public string name;

public int age;

public List<Scene04Xml_Books1219> booksList =new List<Scene04Xml_Books1219>();

public string Name{

get{

return name;

}

set{

name = value;

}

public int Age{

get{

return age;

}

set{

age = value;

}

[XmlElement(ElementName =“ylzBooks”)] //元素名称为Books，也就是将Books转换为XML中的元素时指定的名称

public List<Scene04Xml_Books1219> BooksList{

get{

return booksList;

}

set{

booksList = value;

}

public Scene04Xml_Person1219(){

}

public Scene04Xml_Person1219(string _name, int _age){

this.name = _name;

this.age = _age;

}

++++Scene04Xml_BaseInfo1219.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using System.Xml.Serialization; //引入序列化命名空间

public class Scene04Xml_BaseInfo1219{

List<Scene04Xml_Person1219> personList = new List<Scene04Xml_Person1219>();

}

[XmlElement(ElementName =“ylzBaseInfo”)] //元素名称为BaseInfo，也就是将BaseInfo转换为XML中的元素时指定的名称

public List<Scene04Xml_Person1219> PersonList{

get{

return personList;

}

set{

personList = value;

}

public Scene04Xml_BaseInfo1219(){

}

++++Scene04Xml_MainCamera_Serialization.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using System.IO;

using System.Xml.Serialization;

using System.Text;

public class Scene04Xml_MainCamera_Serialization:MonoBehavior{

void Start(){

MyXml_SerializationXml();

}

void MyXml_SerializationXml(){

//建立对象

Scene04Xml_Book1219 b1 = new Scene04Xml_Book1219(“三国1”,“12”);

Scene04Xml_Book1219 b2 = new Scene04Xml_Book1219(“三国2”,“22”);

Scene04Xml_Book1219 b3 = new Scene04Xml_Book1219(“三国3”,“32”);

//建立书籍对象的集合

Scene04Xml_Books1219 books = new Scene04Xml_Books();

books.BookList.Add(b1);

books.BookList.Add(b2);

books.BookList.Add(b3);

Scene04Xml_Person1219 p1 = new Scene04Xml_Person1219(“人物1”,12);

Scene04Xml_Person1219 p2 = new Scene04Xml_Person1219(“人物2”,22);

p1.booksList.Add(books); //添加书籍对象集合

Scene04Xml_BaseInfo1219 baseInfo = new Scene04ml_BaXseInfo1219();

baseInfo.PersonList.Add(p1); //保存Person对象

baseInfo.PersonList.Add(p2);

//---------------------以上是实例化操做

StringWriter sw = new StringWriter(); //用于将信息写入字符串

XmlSerializerNamespaces ns = new XmlSerializerNamespaces(); //指定Xml序列化的命名空间

//typeof(BaseInfo)：指定对BaseInfo类进行序列化

XmlSerializer serialize = new XmlSerializer(typeof(Scene04Xml_BaseInfo1219));

serialize.Serialize(sw,baseInfo,ns); //使用StringWrite和指定命名空间，将BaseInfo对象写入Xml文件中

sw.Close();

string filePath = Application.dataPath + “/Part20171219Xml/MyXml_Data1219/MyXml_BaseInfo1219.xml”;

string[] content = new string[]{sw.ToString() };

File.WriteAllLines(filePath,content,Encoding.UTF8);

UnityEditor.AssetDataBase.Refresh(); //文本刷新

序列化：

--1、序列化的是类中的字段、属性--->除此以外，其余一切不会参与序列化的过程。

--2、序列化：属性、字段必须为public。

--3、序列化的过程能够看作是：先建立一个对象，而后再对对象里边的成员进行复制，因此xml序列化的成员必须是public，public说明成员能够在类外部进行访问，对象一旦被建立就会为它分配空间。

}

++2.11、XmlNode

++++ChildNodes ：获取节点的全部子节点。

++++FirstChild ：获取节点的第一个子节点。

++++HasChildNodes ：判断该节点是否有任何子节点。

++++InnerText ：获取或设置节点及其全部子节点的值。

++++SelectSingleNode ：选择匹配XPath表达式的第一个XmlNode。

++2.12、XmlDocument

++++Load ：从指定的URL加载XML文档。

++++LoadXml ：从指定的字符串加载XML文档。

++2.13、XmlElement

++++GetAttribute ：返回具备指定名称的属性值。

++Xml解析示例

++++示例：

XmlDocument doc = new XmlDocument(); //建立xml文件对象

doc.Load(Application.dataPath+“/book.xml”); //加载xml文件

XmlElement root = doc.DocumentElement; //获取根节点

XmlNodeList listNodes = root.SelectNodes(“/bookstore/book/price”); //筛选节点

//获取List中每个节点

foreach(XmlNode node in listNodes){

Debug.Log(node.InnerText); //打印节点内容

}

++2.14、Xml反序列化

++++与序列化相对的是反序列化，它将流转换为对象。这两个过程结合起来，能够轻松地存储和传输数据。这就是序列化的意义所在。

++++反序列化示例：

FileStream fs = new FileStream(Application.dataPath + “/Practise5/test.xml”, FileMode.Open, FileAccess.Read); //根据指定路径读取，实例化FileStream对象

XmlSerializer serializer = new XmlSerializer(typeof(BaseInfo)); //指定反序列化的类型

BaseInfo baseInfo = (BaseInfo)serializer.Deserialize(fs);

fs.Close();

//遍历baseinfo对象中的信息，输出到控制台

for(int i=0; i <baseInfo.PerList.Count; i++){

Person per = baseInfo.PerList[i];

Debug.Log(“名字：” + per.Name + “,年龄：” + per.Age);

for(int j=0; j< per.BooksList.Count; j++){

Books books = per.BooksList[j];

for(int k = 0; k<books.BookList.Count; k++){

Book book = books.BooList[k];

Debug.Log(“书名:” + book.Ttile +“,价格:” + book.Price);

}

#3、JSON数据生成和解析

++3.1、JSON简介

++++1、JSON是纯文本。

++++2、JSON是一种轻量级的数据交换格式。

++++3、JSON具备层级结构（值中存在值）。

++3.2、JSON基本结构

++++1、数据在键值对。

++++2、数据由逗号分隔。

++++3、花括号保存对象。

++++4、方括号保存数组。

---先来看一段服务器返回的数据格式：

++++网络传输中，json返回数据示意图：

++3.3、JSON开发

++++使用类库有两种：

--1、System.Json（便于JSON生成）

---须要将System.Json.dll放入到Assets文件夹下。

--2、LitJson（便于JSON解析）

---须要将LitJson.dll放入到Assets文件夹下。

++++解析服务器返回的这段Json数据（此处使用LitJson进行解析）

[

{“id”:10,“Name”:”Leichao”,“age”:28},

{“id”:20,“Name”:”LinfenPiPi”,“age”:20},

{“id”:30,“Name”:”SunYin”,“age”:27}

]

//解析出咱们能够识别的对象

string path = “Assets/Resources/TextFile.txt”;

string textOne = File.ReadAllText(path);

JsonData data1= JsonMapper.ToObject(textOne);

for(int i=0; i <data1.Count; i++){

JsonData nameValue = data1[i][“Name”];

Debug.Log(nameValue);

NameText.text = nameValue.ToString();

JsonData IDValue = data1[i][“id”];

IDText.text = IDValue.ToString();

JsonData AgeValue = data1[i][“age”];

AgeText.text = AgeValue.ToString();

Debug.Log(“名字是：” + NameText + “ID:” + IDText);

}

++++解析出来并给对象赋值

Person[] p = new Person[]{

p1 = new Person();

p2 = new Person();

p3 = new Person();

}

string path = “Assets/Resource/TextFile.txt”;

string textOne = File.ReadAllText(path);

JsonData data = JsonMapper.ToObject(File.ReadAllText(path));

Debug.Log(p.Length);

for(inti = 0; i <data.Count; i++){

JsonData idValue = data[i][“id”];

p[i].id = int.Parse(idValue.ToString());

JsonData AgeValue = data[i][“age”];

p[i].age = int.Parse(AgeValue.ToString());

JsonData nameValue = data[i][“Name”];

p[i].name = nameValue.ToString();

Debug.Log(“name:” + nameValue.ToString());

}

Debug.Log(“-------” + p[0].age +“++++++” + p[1].name);

++3.4、System.Json

++++JsonArray ：JsonArray是零个或多个JsonValue对象的有序序列。

++++JsonObject ：JsonObject是一个无序的零个或更多的键/值对的集合。

++++JsonValue ：具体一个Value值。

----++++----

//大括号 -->一对一对

JsonObject jsonTransform = new JsonObject(); //建立一个JSON对象，至关于一个大括号

JsonValue jsonPosition = “10,20,30”; //建立一个JSON值对象，存储一个Value

jsonTransform.Add(“position”,jsonPosition); //JSON对象，也就是大括号，添加一个key:value

Debug.Log(jsonTransform.ToString()); //打印结果

显示：{“position” :“10,20,30”}

----++++----

//中括号 --->一个一个

JsonValue[] rotationYZ = new JsonValue[]{ 20,30,40 }; //定义一个值数组，用来存储，中括号中的一个个的值

JsonArray jsonRotation = new JsonArray(rotationXYZ); //将这个数组中的一个个的值放到JsonArray数组对象中

jsonTransform.Add(“rotation”,jsonRatation); //一个JsonArray对象，也能够是一个Value，因此能够用jsonTransform来Add

Debug.Log(jsonTransform); //打印结果

结果显示：{“position”:”10,20,30”,”rotation”:[20,30,40]}

-----++++-----

//jsonArray中添加对象（大括号中包含的全部内容）

JsonObject x = new JsonObject();

x.Add(“x”,10);

JsonObject y = new JsonObject();

y.Add(“y”,20);

JsonObject z = new JsonObject();

z.Add(“z”,30);

//实例一个jsonValues数组（全部类型均可以转换成jsonValue）

JsonValue[] scaleXYZ =new JsonValue[]{x,y,z};

//将实例好了的数组，添加到jsonArray对象中，造成一个jsonArray对象做用在于给这个总体，添加一个中括号[]

JsonArray jsonScale = new JsonArray(scaleXYZ);

jsonTransform.Add(“scale”,jsonScale); //将这个总体，放入到jsonTransform中

Debug.Log(jsonTransform); //打印结果

结果显示：{“position”:”10,20,30”,“rotation”:[20,30,40],”scale”:[{“x”:10},{“y”:20},{“z”:30}]}

++3.5、LitJson.JsonMapper

++++1、把对象转化成JSON格式字符串：JsonMapper.ToJson

++++2、把JSON格式字符串转化成对象：JsonMapper.ToObject

++3.6、把对象转换成JSON

public class Person{

public string Name{get;set; }

public int Age{get;set; }

}

Person p = new Person(){

Name = “William SHakespear”,

Age = 51;

};

结果：{“Name”:”William SHakespear”,“Age”:51}

----====----

Person bill = new Person();

bill.Name = “William SHakespear”;

bill.Age = 51;

string json_bill = JsonMapper.ToJson(bill);

Debug.Log(json_bill);

++3.7、把JSON转化为对象（非泛型）

string json = @”{“mxy”:{“name”:”Albert”,”artist”:”Sing Song”,”year”:1999,”tracks”:[“Bistu”,”CSS”,”Lovezuanzuan”]}}”;

JsonData data = JsonMapper.ToObject(json);

Debug.Log(“mxy’s name” + data[“mxy”][“name”]);

string artist = (string)data[“mxy”][“artist”];

int year = (int)data[“mxy”][“year”];

Debug.Log(“Recorded by” + artist +“in” + year);

Debug.Log(“First track:” + data[“mxy”[“tracks”][0]]);

++3.8、JSON和XML的比较

	XML	JSON
语法格式	用节点表示的树形结构	数组与键值对（字典/对象）
数据量	文件庞大	轻量级
可读性	较强	较弱
解析难度	相对麻烦	相对容易
执行效率	较低	较高