XML-JSON

XML和JSON解析 ---

XML解析

xml文件

1. XML是指可扩展标记语言(eXtensible Markup Language)，它也是一种标记语言，很类似HTML。它被设计的宗旨是传输数据，而非显示数据。

2. XML标签没有被预定义，需要用户自行定义标签。

3. XML技术是W3C组织(World Wide Web Consortium万维网联盟)发布的，目前遵循的是W3C组织于2000年发布的XML1.0规范。

4. XML被广泛认为是继Java之后在Internet上最激动人心的新技术。

xml常见应用

• 用于数据存储
• 用在软件配置，用于描述模块之间的关系（如果著名的Spring和mybatis都是基于XML作为配置文件的）
• 在一个软件系统中，通过XML配置文件可以提高系统的灵活性。即程序的行为是通过XML文件来配置的，而不是硬编码。

xml语法

• 文档声明

  1. 在编写XML文档时，需要先使用文档声明来声明XML文档。且必须出现在文档的第一行。（前面注释都不允许）
  2. 最简单的语法:
  3. 用encoding属性说明文档所使用的字符编码。保存在磁盘上的文件编码要与声明的编码一致。
     • 如：
  4. 用standalone属性说明文档是否独立，即是否依赖其他文档。
     • 如：

• 元素

  1. XML元素指XML文件中出现的标签。一个标签分为起始和结束标签(不能省略)。一个标签有如下几种书写形式：

     包含标签主体：<mytag>some content</mytag>
     不含标签主体：<mytag    />（有时也叫空标签）
     

  2. 一个标签中可以嵌套若干子标签，但所有标签必须合理的嵌套，不允许有交叉嵌套。

  3. 一个XML文档必须有且仅有一个根标签，其他标签都是这个根标签的子标签或孙标签。

  4. 对于XML标签中出现的所有空格和换行，XML解析程序都会当作标签内容进行处理。

  5. 由于在XML中，空格和换行都作为原始内容被处理，所以，在编写XML文件时，使用换行和缩进等方式来让原文件中的内容清晰可读的“良好”书写习惯可能要被迫改变。

  6. 元素命名规范：一个XML元素可以包含字母、数字以及其它一些可见字符，但必须遵守下面的一些规范：

     1. 区分大小写，例如，和是两个不同的标记。（与java、c变量命名一致）
     2. 不能以数字或”_” (下划线)开头。（与java、c变量命名一致）
     3. 不能以xml(或XML、或Xml 等)开头。(xml 为关键字，所以不能重复)
     4. 不能包含空格。
     5. 名称中间不能包含冒号（:）。

• 属性

  • 一个元素可以有多个属性，每个属性都有它自己的名称和取值，例如：<mytag name=“value” …/>
  • 属性值一定要用引号(单引号或双引号)引起来。(引号用法与java不同)
  • 属性名称的命名规范与元素的命名规范相同
  • 元素中属性没有顺序要求，但是不准重复。
  • 在XML技术中，标签属性所代表的信息也可以被改成用子元素的形式来描述

• 注释

  • XML中的注释语法为：

    <!--这是注释-->
    XML声明之前不能有注释(xml声明必须放在文档第一行)
    注释不能嵌套，例如：
    <!--大段注释
    …
             <!—又一大段注释-->
    …
    -->
    

实体引用

• 在 XML 中，一些字符拥有特殊的意义。如果你把字符 “<” 放在 XML 元素中，会发生错误，这是因为解析器会把它当作新元素的开始。如下这样会产生 XML 错误：

  <message>if salary < 1000 then</message>
  

• 在xml中，有五个预定义实体应用：

  特殊字符	替代符号
  &	&amp ;
  <	&lt ; 重点记住
  >	&gt ; 重点记住
  “	&quot ;
  ‘	&ap ;

xml语法总结

1. 所有 XML 元素都须有关闭标签
2. XML 标签对大小写敏感
3. XML 必须正确地嵌套顺序
4. XML 文档必须有根元素(有且仅有一个)
5. XML 的属性值须加引号
6. 特殊字符必须转义 —
7. XML 中的空格、回车换行会解析时被保留

xml约束（了解）

作用

• 规定xml文档的书写规则
• XML都是用户自定义的标签，若出现小小的错误，软件程序将不能正确地获取文件中的内容而报错。(如：Tomcat)
• XML技术中，可以编写一个文档来约束一个XML的书写规范，这个文档称之为约束。
• 两个概念：格式良好的XML：遵循XML语法的XML。有效的XML：遵循约束文档的XML
• 总之：约束文档定义了在XML中允许出现的元素名称、属性及元素出现的顺序等等。

分类

• DTD:一种简单的约束技术
• Schema:一种复杂的约束技术

DTD

• DTD入门

• 创建book.xml

  <?xml version="1.0" ?>
  <!DOCTYPE 书架  SYSTEM "book.dtd">
  <书架>
      <书 编号="BK1">
          <书名>葵花宝典</书名>
          <作者>东方不败</作者>
          <售价>59.00元</售价>
      </书>
      <书 编号="BK2">
          <书名>九阳神功</书名>
          <作者>张无忌</作者>
          <售价>57.00元</售价>
      </书>
  </书架>
  

• 创建book.dtd

  <!ELEMENT 书架 (书+)>
  <!ELEMENT 书 (书名,作者,售价)>
  <!ELEMENT 书名 (#PCDATA)>
  <!ELEMENT 作者 (#PCDATA)>
  <!ELEMENT 售价 (#PCDATA)>
  <!ATTLIST 书 编
  

• dtd语法

  <!ELEMENT 元素名称 使用规则>
  

• 使用规则

  （#PCDATA）指示元素的主题内容只能是普通的文本。
  EMPTY：用于指示元素的主体为空。比如<br/>
  ANY：用于指示元素的主题内容为任意类型。
  （子元素）：指示元素中包含的子元素。
  定义子元素及描述它们的关系：
    1） 如果子元素用逗号隔开，必须按照声明顺序去编写XML文档。
       例如：<!ELEMENT FILE(TITLE, AUTHOR, EMAIL)>
    2）如果子元素用"|" 分开，说明任选其一。
       例如：<!ELEMENT FILE(TITLE|AUTHOR|EMAIL)>
    3）用+、*、? 来表示元素出现的次数。
       如果元素后面没有+*?表示必须且只能出现一次。
       +：表示至少出现一次，一次或多次。
       *：表示可有可无，零次、一次或多次。
       ?：表示可以有也可以无，有的话只能出现一次。零次或一次。
  

xml解析技术

dom4j解析

• 准备xml

  <?xml version="1.0" encoding="UTF-8"?>
  <games>
         <game id="1">
             <name>完美国际</name>
             <company>完美世界</company>
         </game>
         <game id="2">
             <name>LOL</name>
             <company>Tencent</company>
         </game>
         <game id="3">
             <name>DOTA</name>
             <company>暴雪</company>
         </game>
  </games>
  

• 导入jar包

• 解析xml（方法一）

  
  /**
   * 解析mygames.xml的所有内容
   *
   * @throws Exception
   */
  public static void readXml() throws Exception {
      // 构建一个解析对象
      SAXReader reader = new SAXReader();
      // 创建管道指向XML文件(把文本文件加载到系统内存中)
      Document document = reader.read(new File("xml/dom4j/mygames.xml"));
      // 读取根节点
      Element rootElm = document.getRootElement();
      // 打印根节点
      System.out.println("--" + rootElm.getName());
      // 读取games
      Iterator iter1 = rootElm.elementIterator();
      // 循环遍历
      while (iter1.hasNext()) {
          Element e1 = iter1.next();
          // 打印game 和取出里面的id属性值
          System.out.println("----" + e1.getName()+"\t"+e1.attributeValue("id"));
          // 迭代game
          Iterator iter2 = e1.elementIterator();
          // 循环遍历
          while (iter2.hasNext()) {
              Element e3 = iter2.next();
              // 打印game里面的name company id的名字和文本
              System.out.println("-------- " + e3.getName() + ":"+ e3.getText());
          }
      }
  }
  

• 解析xml（方法二）

   //获取dom解析工厂
          DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
          //得到解析器对象
          DocumentBuilder builder = dbf.newDocumentBuilder();
          //获取要解析的文件
          FileInputStream fis = new FileInputStream(new File("D:\\course11\\04-javaweb\\domproject\\text.xml"));
          //解析文件，得到dom对象
          Document parse = builder.parse(fis);
          //获取xml的根节点
          Element documentElement = parse.getDocumentElement();
          //获取根节点的下一个子节点
          NodeList games = documentElement.getElementsByTagName("game");
          //遍历子元素
          for (int i = 0; i < games.getLength(); i++) {
              Element item = (Element) games.item(i);
              //获取子元素中的name元素
              Node name = item.getElementsByTagName("name").item(0);
              //获取name元素中的值
              String nameTextContent = name.getTextContent();
              //获取子元素中的company元素
              Node company = item.getElementsByTagName("company").item(0);
              String companyTextContent = company.getTextContent();
  
              System.out.println("name = " + nameTextContent);
              System.out.println("company = " + companyTextContent);
          }
  

JSON解析

JSON基本结构

• 对象

  • 对象在js中表示为“{}”扩起来的内容，数据结构为 {key：value,key：value,…}的键值对的结构，在面向对象的语言中，key为对象的属性，value为对应的属性值，所以很容易理解，取值方法为 对象.key 获取属性值，这个属性值的类型可以是 数字、字符串、数组、对象几种。

  • 比如：

    1. 最简单的形式，可以用下面这样的 JSON 表示”名称 / 值对”：

    { "firstName": "Brett" }  //相当于==》firstName=Brett
    

    2. 多个”名称 / 值对”串

    { "firstName": "Brett", "lastName":"McLaughlin", "email": "aaaa" }
    

• 数组

  • 数组在js中是中括号“[]”扩起来的内容，数据结构为 [“java”,”javascript”,”vb”,…]，取值方式和所有语言中一样，使用索引获取，字段值的类型可以是数字、字符串、数组、对象几种。

  • 语法1—-[1,2,3,4,5] 语法2—-[{k1:v1,k2:v2},{},{},{}]

  • 比如：

    1. 含有1个变量的数组：

    { "people": [
    { "firstName": "Brett", "lastName":"McLaughlin", "email": "aaaa" },
    { "firstName": "Jason", "lastName":"Hunter", "email": "bbbb"},
    { "firstName": "Elliotte", "lastName":"Harold", "email": "cccc" }
    ]}
    

fastJSON解析

• fastJSON特点：

  1. 快速FAST (比其它任何基于Java的解析器和生成器更快，包括jackson）
  2. 强大（支持普通JDK类包括任意Java Bean Class、Collection、Map、Date或enum）
  3. 零依赖（没有依赖其它任何类库除了JDK）

• 先导包

• 创建对象

  package com.powernode.bean;
  
  import java.util.Date;
  
  public class User {
      private Integer id;
      private String name;
      private String address;
      private Date birth;
      public User() {
      }
      public User(Integer id, String name, String address, Date birth) {
          this.id = id;
          this.name = name;
          this.address = address;
          this.birth = birth;
      }
      public Integer getId() {
          return id;
      }
      public void setId(Integer id) {
          this.id = id;
      }
      public String getName() {
          return name;
      }
      public void setName(String name) {
          this.name = name;
      }
      public String getAddress() {
          return address;
      }
      public void setAddress(String address) {
          this.address = address;
      }
      public Date getBirth() {
          return birth;
      }
      public void setBirth(Date birth) {
          this.birth = birth;
      }
  }
  

• 生成简单的JSON对象

  package com.abc.fastjson;
  
  import com.alibaba.fastjson.JSON;
  import com.alibaba.fastjson.JSONObject;
  import com.powernode.bean.User;
  
  import java.util.Date;
  
  public class Test01FastJson {
      public static void main(String[] args) {
          User user=new User(1,"小明","武汉",new Date());
          //转化成JSON字符串
          String json = JSON.toJSONString(user);
          System.out.println(json);
          //转化成JSON对象  本质也就是一个Map
          JSONObject o = (JSONObject) JSON.toJSON(user);
          System.out.println(o.get("id"));
          System.out.println(o.get("name"));
          System.out.println(o.get("address"));
          System.out.println(o.get("birth"));
      }
  }
  

• 生成简单的数组

  package com.powernode.fastjson;
  
  import com.alibaba.fastjson.JSON;
  import com.alibaba.fastjson.JSONArray;
  import com.alibaba.fastjson.JSONObject;
  import com.powernode.bean.User;
  
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.List;
  
  
  public class Test02FastJson {
      public static void main(String[] args) {
          List users=new ArrayList<>();
          for (int i = 1; i <=5 ; i++) {
              users.add(new User(i,"小明"+i,"武汉"+i,new Date()));
          }
          //转化成JSON字符串
          String json = JSON.toJSONString(users);
          System.out.println(json);
          //转化成JSON对象  本质也就是一个Map
          JSONArray o = (JSONArray) JSON.toJSON(users);
          for (Object o1 : o) {
              JSONObject o2= (JSONObject) o1;
              System.out.println(o2.get("id")+" "+o2.get("name")+" "+o2.get("address")+" "+o2.get("birth"));
          }
      }
  }
  

• 解析简单的JSON对象

  package com.powernode.fastjson;
  
  import com.alibaba.fastjson.JSON;
  import com.alibaba.fastjson.JSONArray;
  import com.alibaba.fastjson.JSONObject;
  import com.powernode.bean.User;
  
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.List;
  
  
  public class Test03FastJson {
      public static void main(String[] args) {
          String json="{\"address\":\"武汉\",\"birth\":1609943410183,\"id\":1,\"name\":\"小明\"}";
          JSONObject jsonObj = (JSONObject) JSON.parse(json);
          System.out.println(json);
          System.out.println(jsonObj.get("id"));
          System.out.println(jsonObj.get("name"));
          System.out.println(jsonObj.get("address"));
          System.out.println(jsonObj.get("birth"));
          //直接转成User对象
          User user = JSON.parseObject(json, User.class);
          System.out.println(user.getId()+" "+user.getName()+"  "+user.getAddress()+"  "+user.getBirth());
      }
  }
  

• 解析简单的数组

  package com.powernode.fastjson;
  
  import com.alibaba.fastjson.JSON;
  import com.alibaba.fastjson.JSONArray;
  import com.alibaba.fastjson.JSONObject;
  import com.powernode.bean.User;
  
  import java.util.List;
  
  
  public class Test04FastJson {
      public static void main(String[] args) {
          String json="[{\"address\":\"武汉1\",\"birth\":1609943580570,\"id\":1,\"name\":\"小明1\"},{\"address\":\"武汉2\",\"birth\":1609943580570,\"id\":2,\"name\":\"小明2\"},{\"address\":\"武汉3\",\"birth\":1609943580570,\"id\":3,\"name\":\"小明3\"},{\"address\":\"武汉4\",\"birth\":1609943580570,\"id\":4,\"name\":\"小明4\"},{\"address\":\"武汉5\",\"birth\":1609943580570,\"id\":5,\"name\":\"小明5\"}]";
          JSONArray jsonArray = (JSONArray) JSON.parse(json);
          System.out.println(jsonArray);
          for (Object o1 : jsonArray) {
              JSONObject o2= (JSONObject) o1;
              System.out.println(o2.get("id")+" "+o2.get("name")+" "+o2.get("address")+" "+o2.get("birth"));
          }
          //直接转成List对象
          List users = JSON.parseArray(json, User.class);
          for (User user : users) {
              System.out.println(user.getId()+" "+user.getName()+"  "+user.getAddress()+"  "+user.getBirth());
          }
      }
  }
  

• 解析本地的JSON文件

  package com.powernode.fastjson;
  
  import com.alibaba.fastjson.JSON;
  import com.alibaba.fastjson.JSONArray;
  import com.alibaba.fastjson.JSONObject;
  import com.sun.xml.internal.messaging.saaj.util.ByteOutputStream;
  import com.powernode.bean.User;
  
  import java.io.*;
  import java.util.List;
  
  
  public class Test05FastJson {
      public static void main(String[] args) throws Exception {
          //读流
          File file=new File("json/json/users.json");
          FileInputStream fileInputStream=new FileInputStream(file);
          ByteArrayOutputStream bos=new ByteArrayOutputStream();
          byte[] b=new byte[1024];
          int len=0;
          while((len=fileInputStream.read(b))!=-1){
              bos.write(b,0,len);
          }
          byte[] bytes = bos.toByteArray();
          bos.close();
          fileInputStream.close();
          //解析
          String json=new String(bytes);
          JSONArray jsonArray = (JSONArray) JSON.parse(json);
          System.out.println(jsonArray);
          for (Object o1 : jsonArray) {
              JSONObject o2= (JSONObject) o1;
              System.out.println(o2.get("id")+" "+o2.get("name")+" "+o2.get("address")+" "+o2.get("birth"));
          }
          //直接转成List对象
          List users = JSON.parseArray(json, User.class);
          for (User user : users) {
              System.out.println(user.getId()+" "+user.getName()+"  "+user.getAddress()+"  "+user.getBirth());
          }
      }
  }