Unity序列化之XML,JSON--------合成与解析

1.先介绍一下 XML 和 JSON 是什么东西吧？

      (1)XML

扩展标记语言 (Extensible Markup Language, XML) ，用于标记电子文件使其具有结构性的标记语言，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进 行定义的源语言。 XML使用DTD(document type definition)文档类型定义来组织数据;格式统一，跨平台和语言，早已成为业界公认的标准。
XML是标准通用标记语言 (SGML) 的子集，非常适合 Web 传输。XML 提供统一的方法来描述和交换独立于应用程序或供应商的结构化数据。

      (2)Json

JSON(JavaScript Object Notation)一种轻量级的数据交换格式，具有良好的可读和便于快速编写的特性。可在不同平台之间进行数据交换。JSON采用兼容性很高的、完全独立于语言文本格式，同时也具备类似于C语言的习惯(包括C, C++, C#, Java, JavaScript, Perl, Python等)体系的行为。这些特性使JSON成为理想的数据交换语言。

        说了那么多，其实就是数据的两种保存格式。主要用于配置文件，描述数据，存储数据，数据传输等等。

 

2.因为Xml和Json都可以办到这些事情，那么它们之间有什么区别么？各自的优缺点？

      (1)XML

优点：格式统一，符合标准；.容易与其他系统进行远程交互，数据共享比较方便。

        缺点：XML文件庞大，文件格式复杂，传输占带宽；服务器端和客户端解析XML花费较多的资源和时间；需要花费大量代码来解析XML；

      (2)Json

 

优点：数据格式比较简单，易于读写，格式都是压缩的，占用带宽小；.支持多种语言；

        缺点：可读性较xml略差；

         总而言之，两者可以相互转换，功能都是相差无几的。但是json比xml较好，但xml更加通用。

 

3.XML使用的简单介绍.

a.先来看一段简单的xml代码。

 

1.  
   <team name="Dreamer">
2.  
   <student>
3.  
   <name>Tom</name>
4.  
   <age>20</age>
5.  
   <id>20111234</id>
6.  
   </student>
7.  
   <student>
8.  
   <name>Shierly</name>
9.  
   <age>19</age>
10.  
    <id>20113210</id>
11.  
    </student>
12.  
    <student>
13.  
    <name>Lili</name>
14.  
    <age>21</age>
15.  
    <id>20111110</id>
16.  
    </student>
17.  
    </team>

很显然，可以看出来，这段代码描述的是一个名叫Dreamer的团队有三个成员，还分别记录了这三个成员的相关信息。所以可以看出来XML的可读性十分强。所以我们可以用XML去描述 我们代码中的一些数据关系，描述一个对象。这也就是将对象序列化。然后使用的地方再将xml文件解析出来重新组成原来的对象，这就实现了复杂数据的传输。

b.在untiy中用代码生成xml文件。( 可以使用C#自带的库,不需要引入其他库。using System.Xml )

1.  
   public void CreateXML()
2.  
   {
3.  
    
4.  
   //xml保存的路径，注意路径。
5.  
   string filepath = "E:/my.xml";
6.  
   //继续判断当前路径下是否有该文件
7.  
   if(!File.Exists (filepath))
8.  
   {
9.  
   //创建XML文档实例
10.  
    XmlDocument xmlDoc = new XmlDocument();
11.  
    //创建root节点，也就是最上一层节点
12.  
    XmlElement root = xmlDoc.CreateElement("team");
13.  
    root.SetAttribute("name", "Dreamer");
14.  
    //继续创建下一层节点
15.  
    XmlElement student = xmlDoc.CreateElement("student");
16.  
     
17.  
    //继续创建下一层节点
18.  
    XmlElement name = xmlDoc.CreateElement("name");
19.  
    //设置节点中的数值
20.  
    name.InnerText = "Tom";
21.  
    XmlElement age = xmlDoc.CreateElement("age");
22.  
    age.InnerText = "20";
23.  
    XmlElement id = xmlDoc.CreateElement("id");
24.  
    id.InnerText = "20111234";
25.  
     
26.  
    //把节点一层一层的添加至XMLDoc中 ，请仔细看它们之间的先后顺序，这将是生成XML文件的顺序
27.  
    student.AppendChild(name);
28.  
    student.AppendChild(age);
29.  
    student.AppendChild(id);
30.  
    root.AppendChild(student);
31.  
     
32.  
    student = xmlDoc.CreateElement("student");
33.  
    name = xmlDoc.CreateElement("name");
34.  
    name.InnerText = "Shierly";
35.  
    age = xmlDoc.CreateElement("age");
36.  
    age.InnerText = "19";
37.  
    id = xmlDoc.CreateElement("id");
38.  
    id.InnerText = "20113210";
39.  
    student.AppendChild(name);
40.  
    student.AppendChild(age);
41.  
    student.AppendChild(id);
42.  
    root.AppendChild(student);
43.  
     
44.  
    student = xmlDoc.CreateElement("student");
45.  
    name = xmlDoc.CreateElement("name");
46.  
    name.InnerText = "Lili";
47.  
    age = xmlDoc.CreateElement("age");
48.  
    age.InnerText = "21";
49.  
    id = xmlDoc.CreateElement("id");
50.  
    id.InnerText = "20111110";
51.  
    student.AppendChild(name);
52.  
    student.AppendChild(age);
53.  
    student.AppendChild(id);
54.  
    root.AppendChild(student);
55.  
     
56.  
    xmlDoc.AppendChild(root);
57.  
    //把XML文件保存至本地
58.  
    xmlDoc.Save(filepath);
59.  
    }
60.  
     
61.  
    }

这个代码运行后就会在目标文件夹中生成一个xml文件而文件内容就是1中的那段xml代码。

可以看出来 XmlElement 是基本结构单元。也就是xml中的一对<Name></Name>。

1.我们可以对这个结构单元添加属性：xmlelement.SetAttribute(name,value)。

2.也可以对这个结构单元添加子结构单元：xmlelement.AppendChild(childelement)。

3.如果该结构单元没有子结构了还可以设置它的内容值：xmlelement.InnerText = value.

c.更新xml文件( 修改第三个学生的名字为Jack )

1.  
   public void UpdateXml()
2.  
   {
3.  
   string filepath = "E:/my.xml";
4.  
   if (File.Exists(filepath))
5.  
   {
6.  
   XmlDocument xmlDoc = new XmlDocument();
7.  
   //根据路径将XML读取出来
8.  
   xmlDoc.Load(filepath);
9.  
   //得到team下的所有student节点.
10.  
    XmlNodeList studentlist = xmlDoc.SelectSingleNode("team").ChildNodes;
11.  
    //遍历所有子节点
12.  
    foreach (XmlElement student in studentlist)
13.  
    {
14.  
     
15.  
    XmlNode name = student.SelectSingleNode("name");
16.  
    if (name.InnerText.Equals("Lili"))
17.  
    {
18.  
    name.InnerText = "Jack";
19.  
    }
20.  
    }
21.  
    xmlDoc.Save(filepath);
22.  
    }
23.  
    }

请注意：xmlelement.SelectSingleNode(name)是选取该节点下第一个子节点中名字为name的节点。必须是父子，不能隔两级及以上。

更新结果：

1.  
   <team name="Dreamer">
2.  
   <student>
3.  
   <name>Tom</name>
4.  
   <age>20</age>
5.  
   <id>20111234</id>
6.  
   </student>
7.  
   <student>
8.  
   <name>Shierly</name>
9.  
   <age>19</age>
10.  
    <id>20113210</id>
11.  
    </student>
12.  
    <student>
13.  
    <name>Jack</name>
14.  
    <age>21</age>
15.  
    <id>20111110</id>
16.  
    </student>
17.  
    </team>

d.添加xml属性( 增加一个学生：Sharo,22,20112312 )

1.  
   public void InsertXml()
2.  
   {
3.  
   string filepath = "E:/my.xml";
4.  
   if (File.Exists(filepath))
5.  
   {
6.  
   XmlDocument xmlDoc = new XmlDocument();
7.  
   //根据路径将XML读取出来
8.  
   xmlDoc.Load(filepath);
9.  
    
10.  
    XmlNode team = xmlDoc.SelectSingleNode("team");
11.  
    XmlElement newstudent = xmlDoc.CreateElement("student");
12.  
     
13.  
    XmlElement name = xmlDoc.CreateElement("name");
14.  
    name.InnerText = "Sharo";
15.  
     
16.  
    XmlElement age = xmlDoc.CreateElement("age");
17.  
    age.InnerText = "22";
18.  
     
19.  
    XmlElement id = xmlDoc.CreateElement("id");
20.  
    id.InnerText = "20112312";
21.  
    //向新队员添加属性
22.  
    newstudent.AppendChild(name);
23.  
    newstudent.AppendChild(age);
24.  
    newstudent.AppendChild(id);
25.  
    //将新队员添加到团队里面
26.  
    team.AppendChild(newstudent);
27.  
     
28.  
    xmlDoc.Save(filepath);
29.  
    }
30.  
    }

上述代码演示了添加节点，其实对节点添加属性也是一样的。

更新结果：

1.  
   <team name="Dreamer">
2.  
   <student>
3.  
   <name>Tom</name>
4.  
   <age>20</age>
5.  
   <id>20111234</id>
6.  
   </student>
7.  
   <student>
8.  
   <name>Shierly</name>
9.  
   <age>19</age>
10.  
    <id>20113210</id>
11.  
    </student>
12.  
    <student>
13.  
    <name>Jack</name>
14.  
    <age>21</age>
15.  
    <id>20111110</id>
16.  
    </student>
17.  
    <student>
18.  
    <name>Sharo</name>
19.  
    <age>22</age>
20.  
    <id>20112312</id>
21.  
    </student>
22.  
    </team>

e.删除xml节点(删除Tom学生的信息)

1.  
   public void DeleteXml()
2.  
   {
3.  
   string filepath = "E:/my.xml";
4.  
   if (File.Exists(filepath))
5.  
   {
6.  
   XmlDocument xmlDoc = new XmlDocument();
7.  
   //根据路径将XML读取出来
8.  
   xmlDoc.Load(filepath);
9.  
    
10.  
    XmlNode team = xmlDoc.SelectSingleNode("team");
11.  
    XmlNodeList studentlist = team.ChildNodes;
12.  
     
13.  
    foreach(XmlNode student in studentlist)
14.  
    {
15.  
    XmlNode name = student.SelectSingleNode("name");
16.  
    if(name.InnerText.Equals("Tom"))
17.  
    {
18.  
    team.RemoveChild(student);
19.  
    }
20.  
    }
21.  
     
22.  
    xmlDoc.Save(filepath);
23.  
    }
24.  
    }

可以使用 xmlelement.RemoveAll() 删除所有子节点

更新结果：

1.  
   <team name="Dreamer">
2.  
   <student>
3.  
   <name>Shierly</name>
4.  
   <age>19</age>
5.  
   <id>20113210</id>
6.  
   </student>
7.  
   <student>
8.  
   <name>Jack</name>
9.  
   <age>21</age>
10.  
    <id>20111110</id>
11.  
    </student>
12.  
    <student>
13.  
    <name>Sharo</name>
14.  
    <age>22</age>
15.  
    <id>20112312</id>
16.  
    </student>
17.  
    </team>

f.解析xml文件

1.  
   public void LoadXml()
2.  
   {
3.  
   string filepath = "E:/my.xml";
4.  
   if (File.Exists(filepath))
5.  
   {
6.  
   XmlDocument xmlDoc = new XmlDocument();
7.  
   //根据路径将XML读取出来
8.  
   xmlDoc.Load(filepath);
9.  
    
10.  
    XmlElement team = (XmlElement)xmlDoc.SelectSingleNode("team");
11.  
    string teamname = team.GetAttribute("name");
12.  
     
13.  
    Console.WriteLine("这是一个名叫\"" + teamname + "\"的队伍:");
14.  
    XmlNodeList studentlist = team.ChildNodes;
15.  
    Console.WriteLine("一共有" + studentlist.Count + "人");
16.  
    foreach (XmlNode student in studentlist)
17.  
    {
18.  
    XmlNode name = student.SelectSingleNode("name");
19.  
    XmlNode age = student.SelectSingleNode("age");
20.  
    XmlNode id = student.SelectSingleNode("id");
21.  
    Console.WriteLine("姓名：" + name.InnerText + "，年龄：" + age.InnerText + "，学号：" + id.InnerText);
22.  
    }
23.  
     
24.  
    xmlDoc.Save(filepath);
25.  
    }
26.  
    }

在实际情况中，我们一般在解析xml的时候去给对象相关属性赋值。相当于是在还原xml中表示的对象数据。

输出结果：

1.  
   这是一个名叫"Dreamer"的队伍:
2.  
   一共有3人
3.  
   姓名：Shierly，年龄：19，学号：20113210
4.  
   姓名：Jack，年龄：21，学号：20111110
5.  
   姓名：Sharo，年龄：22，学号：20112312

 

4.Json使用的简单介绍.(Json使用需要下载LitJson的包)

 

a.先来看看json代码

1.  
   {
2.  
   "Name" : "Dreamer",
3.  
   "Number" : 3,
4.  
   "Member" :
5.  
   [
6.  
   {
7.  
   "Name" : "Tom",
8.  
   "Age" : 20,
9.  
   "Id" : "20111234"
10.  
    },
11.  
    {
12.  
    "Name" : "Jack",
13.  
    "Age" : 22,
14.  
    "Id" : "20112312"
15.  
    }
16.  
    ]
17.  
    }

恩这个描述看起来比较熟悉？没错，这就是键值对的表现方式。相比起xml来说json省略了很多冗余的表达格式。

仔细看可以发现json的基本结构单元就是以{ }括起来的一组键值对，而这个结构单元也可以作为值。而[ ]中括号就表示数组，数组的每个元素都是一个结构单元。

键值对的表示是 key ：value,键值对之间用，隔开。

b.生成json代码

1.  
   public void CreateJson()
2.  
   {
3.  
   string path = "E:/json.txt";
4.  
   FileInfo t = new FileInfo(path);
5.  
    
6.  
   StreamWriter sw = t.CreateText();
7.  
    
8.  
   StringBuilder sb = new StringBuilder();
9.  
   JsonWriter writer = new JsonWriter(sb);
10.  
    //相当于写下了'{'
11.  
    writer.WriteObjectStart();
12.  
    //相当于写下了"Name":
13.  
    writer.WritePropertyName("Name");
14.  
    //相当于写下了"Dreamer"
15.  
    writer.Write("Dreamer");
16.  
     
17.  
    writer.WritePropertyName("Number");
18.  
    writer.Write("3");
19.  
     
20.  
    writer.WritePropertyName("Member");
21.  
    //相当于写下了'['
22.  
    writer.WriteArrayStart();
23.  
     
24.  
    writer.WriteObjectStart();
25.  
    writer.WritePropertyName("Name");
26.  
    writer.Write("Tom");
27.  
    writer.WritePropertyName("Age");
28.  
    writer.Write("20");
29.  
    writer.WritePropertyName("Id");
30.  
    writer.Write("20111234");
31.  
    //相当于写下了'}'
32.  
    writer.WriteObjectEnd();
33.  
     
34.  
    writer.WriteObjectStart();
35.  
    writer.WritePropertyName("Name");
36.  
    writer.Write("Jack");
37.  
    writer.WritePropertyName("Age");
38.  
    writer.Write("22");
39.  
    writer.WritePropertyName("Id");
40.  
    writer.Write("20112312");
41.  
    writer.WriteObjectEnd();
42.  
    //相当于写下了']'
43.  
    writer.WriteArrayEnd();
44.  
    writer.WriteObjectEnd();
45.  
    sw.WriteLine(sb.ToString());
46.  
    sw.Close();
47.  
    }

这段代码就是生成上面json代码的生成代码。

很显然，json生成的代码更像是html这类代码一样，按照生成文件的格式调用对应的API。不过，json有更好的方式，它可以直接对对象序列化。

看下面的例子：

1.  
   using UnityEngine;
2.  
   using LitJson;
3.  
   public class A
4.  
   {
5.  
   public string name = "yzl";
6.  
   public int old = 20;
7.  
   }
8.  
   public class Test : MonoBehaviour
9.  
   {
10.  
    void Start()
11.  
    {
12.  
    A a = new A();
13.  
    Debug.Log(JsonMapper.ToJson(a));
14.  
    }
15.  
    }

观察控制台输出：{"name":"yzl","old":20}

发现,json可以直接对对象里面的属性序列化生成对应的json文件。这就是很方便的地方了。当然,xml也有这个功能，但是需要对类的属性添加节点标签。相比json要麻烦一些。

c.json的增删改( 增加队伍地址属性,删除队伍人数属性,修改队名 )

1.  
   using UnityEngine;
2.  
   using System.Collections;
3.  
   using System;
4.  
   using System.Collections.Generic;
5.  
   using LitJson;
6.  
   using System.IO;
7.  
   public class Test : MonoBehaviour
8.  
   {
9.  
   void Start()
10.  
    {
11.  
    StreamReader sr = File.OpenText("E:/json.txt");
12.  
    string strline = sr.ReadToEnd();
13.  
     
14.  
    JsonData jd = JsonMapper.ToObject(strline);
15.  
     
16.  
    //修改队名
17.  
    jd["Name"] = "Winer";
18.  
    //添加队伍地址属性
19.  
    jd["Address"] = "Sichuan";
20.  
    //删除队伍人数属性
21.  
    ((IDictionary)jd).Remove("Number");
22.  
    Debug.Log(jd.ToJson());
23.  
     
24.  
    sr.Close();
25.  
    }
26.  
    }

可以看出来json使用起来要比xml方便许多，解析的使用方法和C#的字典类似。

d.json的解析查看

1.  
   using UnityEngine;
2.  
   using System.Collections;
3.  
   using System;
4.  
   using System.Collections.Generic;
5.  
   using LitJson;
6.  
   using System.IO;
7.  
    
8.  
   public class Test : MonoBehaviour
9.  
   {
10.  
    void Start()
11.  
    {
12.  
    StreamReader sr = File.OpenText("E:/json.txt");
13.  
    string strline = sr.ReadToEnd();
14.  
     
15.  
    JsonData jd = JsonMapper.ToObject(strline);
16.  
     
17.  
    Debug.Log("队伍名：" + jd["Name"]);
18.  
    Debug.Log("队伍人数：" + jd["Number"]);
19.  
     
20.  
    for (int i = 0; i < jd["Member"].Count; i++)
21.  
    {
22.  
    Debug.Log("姓名：" + jd["Member"][i]["Name"] + ",年龄：" + jd["Member"][i]["Age"] + ",学号：" + jd["Member"][i]["Id"]);
23.  
    }
24.  
    sr.Close();
25.  
    }
26.  
    }

输出结果：

队伍名：Dreamer
队伍人数：3
姓名：Tom,年龄：20,学号：20111234
姓名：Jack,年龄：22,学号：20112312