JSON与XML
JSON（掌握）
JSON：JavaScript Object Notation JS 对象简谱 ， 是一种轻量级的数据交换格式.
1、格式
1、对象格式
一个对象， 由一个大括号表示，括号中描述对象的属性，通过键值对来描述对象的属性 (可以理解为， 大括号中， 包含的是一个个的键值对)
格式：
键与值之间使用冒号连接， 多个键值对之间使用逗号分隔
键值对的键应使用引号引住 (通常Java解析时， 键不使用引号会报错， 而 JS 能正确解析)
键值对的值， 可以是 JS 中的任意类型的数据
{
"name":"张三"，
"age":18
}
{
"name":"李四"，
"age":18
}
2、数组格式
在 JSON 格式中可以与对象互相嵌套
格式：[元素1，元素2…]
["王二"，{
"name":"张三"，"age":18}，{
"name":"李四"，"age":18}]
2、作用
将 Java 中的对象快速的转换为 JSON 格式的字符串
将 JSON 格式的字符串，转换为 Java 的对象
3、解析
1、Gson
将对象转换为 JSON 字符串
转换JSON字符串的步骤:
1、引入 JAR 包
2、在需要转换 JSON 字符串的位置编写如下代码即可:
String json = new Gson().toJSON(要转换的对象);
//1. 创建Gson对象
Gson g = new Gson();
//2. 转换
Book b = new Book("100"，"金苹果"，"种植苹果真辛苦");
String s = g.toJson(b);
System.out.println(s);
Book b = new Book("100"，"金苹果"，"种植苹果真辛苦");
String s = new Gson().toJson(b);
System.out.println(s);
public class Book {
private String id;
private String name;
private String info;
......
}
将 JSON 字符串转换为对象
1、引入 JAR 包
2、在需要转换 JSON 字符串的位置编写如下代码即可:
对象 = new Gson().fromJson(JSON字符串，对象类型.class);
//1. 创建Gson对象
Gson g = new Gson();
//2. 转换 : {"id":"100"，"name":"金苹果"，"info":"种植苹果真辛苦"}
Book b = g.fromJson("{\"id\":\"100\"，\"name\":\"金苹果\"，\"info\":\"种植苹果真辛苦\"}"， Book.class);
System.out.println(b.getId());
//1. 创建Gson对象
Gson g = new Gson();
//2. 转换 : {"id":"100"，"name":"金苹果"，"info":"种植苹果真辛苦"}
HashMap data = g.fromJson("{\"id\":\"100\"，\"name\":\"金苹果\"，\"info\":\"种植苹果真辛苦\"}"， HashMap.class);
List page = (List) data.get("page");
System.out.println(page.get(1));
2、FastJson
将对象转换为 JSON 字符串
转换JSON字符串的步骤:
1、引入 JAR 包
2、在需要转换 JSON 字符串的位置编写如下代码即可:
String json = new JSON.toJSONString(要转换的对象);
Book book = new Book("1002"，"唐诗三百首"，"床前明月光，疑是地上霜。举头望明月，低头思故乡。");
//1. 转换
String json = JSON.toJSONString(book);
System.out.println(json);
将 JSON 字符串转换为对象
1、引入 JAR 包
2、在需要转换 JSON 字符串的位置编写如下代码即可:
类型 对象名 = JSON.parseObject(JSON字符串，对象类型.class);
List<类型> list = JSON.parseArray(JSON字符串，对象类型.class);
//1. 转换 : {"id":"1002"，"name":"唐诗三百首"，"info":"床前明月光，疑是地上霜。举头望明月，低头思故乡。"}
Book book = JSON.parseObject("{\"id\":\"1002\"，\"name\":\"唐诗三百首\"，\"info\":\"床前明月光，疑是地上霜。举头望明月，低头思故乡。\"}"， Book.class);
System.out.println(book.getId());
//1. 转换 : ["一二三"，"二三四"，"三四五"]
List<String> strings = JSON.parseArray("[\"一二三\"，\"二三四\"，\"三四五\"]"， String.class);
System.out.println(strings.get(1));
XML(熟悉)
1、XML
可扩展标记语言，软件与软件交流，
XML具有平台无关性，是一种独立的标记语言，可以跨语言
XML具有自我描述性
为什么要学：网络数据传输、数据存储、配置文件（主要）
2、XML语法格式
1、文档声明
<?xml version="1.0" encoding="UTF-8"?>
// xml 文件
// version 版本
// encoding 编码
2、标记（元素/标签/节点）
XML文档，由一个个的标记组成.，
语法：
开始标记(开放标记)：<标记名称>
结束标记(闭合标记)：
标记名称：自定义名称，必须遵循以下命名规则：
1、名称可以含字母、数字以及其他的字符
2、名称不能以数字或者标点符号开始
3、名称不能以字符 “xml”（或者 XML、Xml）开始
4、名称不能包含空格，不能包含冒号（:）
5、名称区分大小写
标记内容：开始标记与结束标记之间 ，是标记的内容
3、根标记
最外面的，一个 XML 文档中，必须有且仅允许有一个根标记
4、标记可以嵌套，但是不允许交叉
5、标记的层级称呼
子标记、父标记、兄弟标记、后代标记、祖先标记
6、标记名称允许重复
7、标记属性
标记除了开始和结束，还有属性，在标记开始时描述，由属性名和属性值组成
格式:
在开始标记中， 描述属性
可以包含 0-n 个属性， 每一个属性是一个键值对！
属性名不允许重复 ， 键与值之间使用等号连接， 多个属性之间使用空格分割
属性值必须被引号引住
8、注释
注释不能写在文档声明前
注释不能嵌套注释
格式:
注释开始：
注释结束： -->
<?xml version="1.0" encoding="UTF-8"?>
<books>
<book id="1001">
<name>金苹果</name>
<info>床前明月光，疑是地上霜</info>
</book>
<book id="1002">
<name>银苹果</name>
<info>举头望明月，低头思故乡</info>
</book>
</books>
3、解析XML（DOM4J）
有四种：SAX、DOM、JDOM、DOM4J
步骤:
1、引入jar文件 dom4j.jar
2、创建一个指向XML文件的输入流
FileInputStream fis = new FileInputStream(“xml文件的地址”);
3、创建一个XML读取工具对象
SAXReader sr = new SAXReader();
4、使用读取工具对象， 读取XML文档的输入流 ， 并得到文档对象
Document doc = sr.read(fis);
5、 通过文档对象， 获取XML文档中的根元素对象
Element root = doc.getRootElement();
1、文档对象 Document
指的是加载到内存的整个 XML 文档
常用方法：
1、通过文档对象，获取 XML 文档中的根元素对象
Element root = doc.getRootElement();
2、添加根节点
Element root = doc.addElement(“根节点名称”);
2、元素对象 Element
指的是XML文档中的单个节点.
常用方法:
1、获取节点名称
String getName();
2、 获取节点内容
String getText();
3、 设置节点内容
String setText();
4、根据子节点的名称 ， 获取匹配名称的第一个子节点对象.
Element element(String 子节点名称);
5、获取所有的子节点对象
List
6、 获取节点的属性值
String attributeValue(String 属性名称);
7、获取子节点的内容
String elementText(String 子节点名称);
8、添加子节点
Element addElement(String 子节点名称);
9、添加属性
void addAttribute(String 属性名，String 属性值);
3、解析本地文件
//1. 获取输入流
FileInputStream fis = new FileInputStream("f://Demo1.xml");
//2. 创建XML读取对象
SAXReader sr = new SAXReader();
//3. 读取并得到文档对象
Document doc = sr.read(fis);
//4. 通过文档获取根元素
Element root = doc.getRootElement();
//5. 开始解析元素，输出根元素
System.out.println(root.getName());
//操作一波，输出第一个 name 元素的内容
Element book = root.element("book");
Element name = book.element("name");
System.out.println(name.getText());
//获取根节点的所有对象到 List 集合中再输出
List<Element> es = root.elements();
for(int i=0;i<es.size();i++){
Element book1 = es.get(i);
System.out.println(book1.attributeValue("id"));
System.out.println(book1.elementText("name"));
System.out.println(book1.elementText("info"));
System.out.println("-----------------------------");
}
//关闭
fis.close();
4、解析网络文件
String phone = "手机号码";
//1. 获取到XML资源的输入流
URL url = new URL("http://apis.juhe.cn/mobile/get?phone="+phone+"&dtype=xml&key=9f3923e8f87f1ea50ed4ec8c39cc9253");
URLConnection conn = url.openConnection();
InputStream is = conn.getInputStream();
//2. 创建一个XML读取对象
SAXReader sr = new SAXReader();
//3. 通过读取对象 读取XML数据，并返回文档对象
Document doc = sr.read(is);
//4. 获取根节点
Element root = doc.getRootElement();
//5. 解析内容
String code = root.elementText("resultcode");
if("200".equals(code)){
Element result = root.element("result");
String province = result.elementText("province");
String city = result.elementText("city");
if(province.equals(city)){
System.out.println("手机号码归属地为："+city);
}else{
System.out.println("手机号码归属地为："+province+" "+city);
}
}else{
System.out.println("请输入正确的手机号码");
}
//关闭
is.close();
5、XPATH解析XML
1、路径表达式
通过路径快速的查找一个或一组元素
路径表达式:
1、 / : 从根节点开始查找
2、 // : 从发起查找的节点位置 查找后代节点
3、 . : 查找当前节点
4、 … : 查找父节点
5、 @ : 选择属性
属性使用方式:
[@属性名=‘值’]
[@属性名>‘值’]
[@属性名<‘值’]
[@属性名!=‘值’]
2、步骤
通过Node类的两个方法， 来完成查找: (Node是 Document 与 Element 的父接口)
方法1.
//根据路径表达式， 查找匹配的单个节点
Element e = selectSingleNode(“路径表达式”);
方法2.
List
//本地文件
//1. 获取输入流
FileInputStream fis = new FileInputStream("f://Demo1.xml");
//2. 创建XML读取对象
SAXReader sr = new SAXReader();
//3. 读取并得到文档对象
Document doc = sr.read(fis);
//4. 通过文档对象+xpath，查找所有的name节点
List<Node> names = doc.selectNodes("//book[@id='1001']//name");
for (int i=0;i<names.size();i++){
System.out.println(names.get(i).getName());
System.out.println(names.get(i).getText());
}
//5. 查找单个 name 的节点
Node n = doc.selectSingleNode("//book[@id='1002']//name");
System.out.println(n.getName()+":"+n.getText());
//关闭
fis.close();
//网络文件
String phone = "手机号码";
//1. 获取到XML资源的输入流
URL url = new URL("http://apis.juhe.cn/mobile/get?phone="+phone+"&dtype=xml&key=9f3923e8f87f1ea50ed4ec8c39cc9253");
URLConnection conn = url.openConnection();
InputStream is = conn.getInputStream();
//2. 创建一个XML读取对象
SAXReader sr = new SAXReader();
//3. 通过读取对象 读取XML数据，并返回文档对象
Document doc = sr.read(is);
Node node = doc.selectSingleNode("//company");
System.out.println("运营商："+node.getText());
is.close();
6、四种解析 XML 的区别
问: Java 中有几种 XML 解析方式 ? 分别是什么 ? 有什么样的优缺点 ?
答: 四种
1、SAX解析
解析方式是事件驱动机制 !
SAX 解析器，逐行读取 XML 文件解析 ，每当解析到一个标签的开始/结束/内容/属性时，触发事件
我们可以编写程序在这些事件发生时，进行相应的处理
优点:
分析能够立即开始，而不是等待所有的数据被处理
逐行加载，节省内存，有助于解析大于系统内存的文档
有时不必解析整个文档，它可以在某个条件得到满足时停止解析
缺点:
单向解析，无法定位文档层次，无法同时访问同一文档的不同部分数据(因为逐行解析， 当解析第 n 行是， 第 n-1 行已经被释放了， 无法在进行操作了)
无法得知事件发生时元素的层次， 只能自己维护节点的父/子关系.
只读解析方式， 无法修改 XML 文档的内容.
2、DOM解析
是用与平台和语言无关的方式表示 XML 文档的官方 W3C 标准，分析该结构通常需要加载整个文档和内存中建立文档树模型，程序员可以通过操作文档树， 来完成数据的获取修改删除等
优点:
文档在内存中加载， 允许对数据和结构做出更改
访问是双向的，可以在任何时候在树中双向解析数据
缺点:
文档全部加载在内存中 ， 消耗资源大
3、JDOM解析
目的是成为 Java 特定文档模型，它简化与 XML 的交互并且比使用 DOM 实现更快，由于是第一 个 Java 特定模型，JDOM 一直得到大力推广和促进，JDOM 文档声明其目的是“使用20%（或更少）的精力解决80%（或更多）Java/XML 问题” （根据学习曲线假定为20%）
优点:
使用具体类而不是接口，简化了 DOM 的 API
大量使用了 Java 集合类，方便了 Java 开发人员
缺点:
没有较好的灵活性
性能不是那么优异
4、DOM4J解析
它是 JDOM 的一种智能分支，它合并了许多超出基本 XML 文档表示的功能，包括集成的 XPath 支持、XML Schema 支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项， DOM4J 是一个非常优秀的 Java XML API ，具有性能优异、功能强大和极端易用使用的特点，同时它也是一 个开放源代码的软件，如今你可以看到越来越多的 Java 软件都在使用 DOM4J 来读写 XML ，目前许多开源项目中大量采用 DOM4J
4、XML文件
.XML 文件是保存 XML 数据的一种方式
XML 数据也可以以其他的方式存在（如在内存中构建 XML 数据）。
不要将 XML 语言狭隘的理解成 XML 文件。
生成XML文件
步骤:
1、通过文档帮助器 (DocumentHelper) ， 创建空的文档对象
Document doc = DocumentHelper.createDocument();
2、通过文档对象， 向其中添加根节点
Element root = doc.addElement(“根节点名称”);
3、通过根节点对象root ， 丰富我们的子节点
Element e = root.addElement(“元素名称”);
4、创建一个文件输出流 ，用于存储XML文件
FileOutputStream fos = new FileOutputStream(“要存储的位置”);
5、将文件输出流， 转换为XML文档输出流
XMLWriter xw = new XMLWriter(fos);
6、 写出文档
xw.write(doc);
7、释放资源
xw.close();
//1. 通过文档帮助器，创建一个文档对象
Document doc = DocumentHelper.createDocument();
//2. 给文档添加第一个节点（根节点）
Element books = doc.addElement("books");
//3. 通过根节点， 丰富子节点
for(int i=0;i<100;i++){
Element book = books.addElement("book");
Element name = book.addElement("name");
name.setText(i+"种苹果的小姑娘~");
Element info = book.addElement("info");
info.setText(i+"辛勤种植苹果的故事~");
book.addAttribute("id"，100+i+"");
}
//4. 创建一个文件输出流
FileOutputStream fos = new FileOutputStream("f://books.xml");
//5. 将输出流转换为XML输出流
XMLWriter xw = new XMLWriter(fos);
//6. 写出文档
xw.write(doc);
//7. 释放资源
xw.close();
System.out.println("执行完毕");
5、XStream
快速的将 Java 中的对象，转换为 XML 字符串
使用步骤：
1、 创建XStream 对象
XStream x = new XStream();
2、修改类生成的节点名称 (默认节点名称为 包名.类名)
x.alias(“节点名称”，类名.class);
3、传入对象 ， 生成 XML 字符串
String xml字符串 = x.toXML(对象);
Person p = new Person();
p.setName("张三");
p.setAge(18);
//XStream使用
//1、创建XStream对象
XStream x = new XStream();
//2、修改某个类型生成的节点 （可选的，默认为包名.类名）
x.alias("person"，Person.class);
//3、传入对象，开始生成
String xml = x.toXML(p);
System.out.println(xml);
static class Person{
private String name;
private int age;
......
}