XML与JSON在java的使用
文章目录
前言
提示：下面案例都引入XML与JSON的工具类才能实现以下方法
一、XML和JSON优缺点
1.定义介绍
(1).XML定义
扩展标记语言 (Extensible Markup Language, XML) ，用于标记电子文件使其具有结构性的标记语言，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。 XML使用DTD(document type definition)文档类型定义来组织数据;格式统一，跨平台和语言，早已成为业界公认的标准。
(2).JSON定义
JSON(JavaScript Object Notation)一种轻量级的数据交换格式，具有良好的可读和便于快速编写的特性。可在不同平台之间进行数据交换。
2.优缺点
(1).XML的优缺点
<1>.XML的优点
1、.格式统一，符合标准；
2、容易与其他系统进行远程交互，数据共享比较方便。
<2>.XML的缺点
1、XML文件庞大，文件格式复杂，传输占带宽；
2、服务器端和客户端都需要花费大量代码来解析XML，导致服务器端和客户端代码变得异常复杂且不易维护；
3、客户端不同浏览器之间解析XML的方式不一致，需要重复编写很多代码；
4、、服务器端和客户端解析XML花费较多的资源和时间。
(2).JSON的优缺点
1.JSON的优点：
1、.数据格式比较简单，易于读写，格式都是压缩的，占用带宽小；
2、.易于解析，客户端JavaScript可以简单的通过eval()进行JSON数据的读取；
3、.支持多种语言，包括ActionScript, C, C#, ColdFusion, Java, JavaScript, Perl, PHP, Python, Ruby等服务器端语言，便于服务器端的解析；
4、在PHP世界，已经有PHP-JSON和JSON-PHP出现了，偏于PHP序列化后的程序直接调用，PHP服务器端的对象、数组等能直接生成JSON格式，便于客户端的访问提取；
5、.因为JSON格式能直接为服务器端代码使用，大大简化了服务器端和客户端的代码开发量，且完成任务不变，并且易于维护。
2.JSON的缺点
1、没有XML格式这么推广的深入人心和喜用广泛，没有XML那么通用性；
2、.JSON格式目前在Web Service中推广还属于初级阶段。
3.XML和JSON的优缺点对比
(1).可读性方面。
JSON和XML的数据可读性基本相同，JSON和XML的可读性可谓不相上下，一边是建议的语法，一边是规范的标签形式，XML可读性较好些。
(2).可扩展性方面。
XML天生有很好的扩展性，JSON当然也有，没有什么是XML能扩展，JSON不能的。
(3).编码难度方面。
XML有丰富的编码工具，比如Dom4j、JDom等，JSON也有json.org提供的工具，但是JSON的编码明显比XML容易许多，即使不借助工具也能写出JSON的代码，可是要写好XML就不太容易了。
(4).解码难度方面。
XML的解析得考虑子节点父节点，让人头昏眼花，而JSON的解析难度几乎为0。这一点XML输的真是没话说。
(5).流行度方面。
XML已经被业界广泛的使用，而JSON才刚刚开始，但是在Ajax这个特定的领域，未来的发展一定是XML让位于JSON。到时Ajax应该变成Ajaj(Asynchronous Javascript and JSON)了。
(6).解析手段方面。
JSON和XML同样拥有丰富的解析手段。
(7).数据体积方面。
JSON相对于XML来讲，数据的体积小，传递的速度更快些。
(8).数据交互方面。
JSON与JavaScript的交互更加方便，更容易解析处理，更好的数据交互。
(9).数据描述方面。
JSON对数据的描述性比XML较差。
(10).传输速度方面。
JSON的速度要远远快于XML。
二、语法格式
1、写XML文档
- XML文档声明
<?xml version="1.0" encoding="UTF-8"?>
- 标记 ( 元素 / 标签 / 节点)XML文档,由一个个的标记组成.
语法:
开始标记(开放标记): <标记名称>
结束标记(闭合标记): </标记名称>
标记名称: 自定义名称，必须遵循以下命名规则：
1.名称可以含字母、数字以及其他的字符
2.名称不能以数字或者标点符号开始
3.名称不能以字符 “xml”（或者 XML、Xml）开始
4.名称不能包含空格，不能包含冒号（:）
5.名称区分大小写
标记内容: 开始标记与结束标记之间 ,是标记的内容.
例如 ,我们通过标记, 描述一个人名:
李伟杰 - 一个XML文档中, 必须有且且仅允许有一个根标记.
正例:
<names>
<name>张三</name>
<name>李四</name>
</names>
反例:
<name>李四</name>
<name>麻子</name>
- 标记可以嵌套, 但是不允许交叉.
正例:
<person>
<name>李四</name>
<age>18</age>
</person>
反例:
<person>
<name>李四<age></name>
18</age>
</person>
- 标记的层级称呼 (子标记, 父标记 , 兄弟标记, 后代标记 ,祖先标记)
例如:
<persons>
<person>
<name>李四</name>
<length>180cm</length>
</person>
<person>
<name>李四</name>
<length>200cm</length>
</person>
</persons>
name是person的子标记.也是person的后代标记
name是persons的后代标记.
案例:
语法进阶CDATA （了解）
name是length的兄弟标记.
person是name的父标记.
persons是name的祖先标记.
6. 标记名称 允许重复
7. 标记除了开始和结束 , 还有属性.
标记中的属性, 在标记开始时 描述, 由属性名和属性值 组成.
格式:
在开始标记中, 描述属性.
可以包含0-n个属性, 每一个属性是一个键值对!
属性名不允许重复 , 键与值之间使用等号连接, 多个属性之间使用空格分割.
属性值 必须被引号引住.
案例:
<persons>
<person id="10001" groupid="1">
<name>李四</name>
<age>18</age>
</person>
<person id="10002" groupid="1">
<name>李四</name>
<age>20</age>
</person>
</persons>
- 注释
注释不能写在文档文档声明前
注释不能嵌套注释
格式:
注释开始: <!--
注释结束: -->
1、解析XML
代码如下（示例）：
public static void main(String[] args) throws IOException, DocumentException {
// 文件获取输入流
FileInputStream fis = new FileInputStream("Demo1.xml");
// 创建XML读取对象
SAXReader sax = new SAXReader();
// 读取并得到文档对象
Document read = sax.read(fis);
// 通过文档获取根元素
Element root = read.getRootElement();
// 开始解析元素
System.out.println(root.getName());
//通过根元素获取子元素book
Element book = root.element("book");
//通过book元素获取子元素name
Element name = book.element("name");
//打印元素name中的内容
System.out.println(name.getText());
System.out.println("-----------------------------");
//把元素放入集合中 通过根元素获取子元素
List<Element> es = root.elements();
for (int i=0;i<2;i++){
Element book1 = es.get(i);
//打印book属性中的‘id’内容
System.out.println(book1.attributeValue("id"));
//打印获取book中子元素name的内容
System.out.println(book1.elementText("name"));
System.out.println(book1.elementText("info"));
System.out.println("----------------");
}
// 结束输入流
fis.close();
}
2、解析网络XML文件案例
public static void main(String[] args) throws IOException, DocumentException {
String phone = "17681688646";
//1
//获取到XML资源的输入流
URL utl = new URL("http://apis.juhe.cn/mobile/get?phone="+phone+"&dtype=xml&key=9f3923e8f87f1ea50ed4ec8c39cc9253");
//打开链接
URLConnection conn = utl.openConnection();
//拿到网址下的输入流
InputStream is = conn.getInputStream();
//2
//创建一个XML读取对象
SAXReader rs = new SAXReader();
//3通过读取对象 读取XML数据 并返回文档对象
Document read = rs.read(is);
//获取根节点
Element root = read.getRootElement();
//5、解析内容
// 获取根节点中resultcode元素的内容 转成Stringt类型的对象
String kod = root.elementText("resultcode");
//如果kod中的内容根200一样则进入if
if ("200".equals(kod)){
// 根据resultcode元素获取result元素中的内容 转成Element类型的对象
Element res = root.element("result");
// 根据resultcode元素获取province元素中的内容 转成String类型的对象
String sheng = res.elementText("province");
// 根据resultcode元素获取citye元素中的内容 转成String类型的对象
String feng = res.elementText("city");
// 如果省份跟市区一样则进入if
if (sheng.equals(feng)){
System.out.println("手机号归属地："+feng);
}else {
System.out.println("手机号归属地："+sheng+" "+feng);
}
// 根据resultcode元素获取company元素中的内容 转成String类型的对象
String yu = res.elementText("company");
System.out.println(yu);
}else {//如果手机号查不到则打印手机号不正确
System.out.println("请输入正确的手机号！");
}
}
3、通过路径快速的查找一个或一组元素
public static void main(String[] args) throws DocumentException, IOException {
// 文件获取输入流
FileInputStream fis = new FileInputStream("Demo1.xml");
// 创建XML读取对象
SAXReader sax = new SAXReader();
// 读取并得到文档对象
Document read = sax.read(fis);
// 通过文档对象+xpath,查找所有的name节点
List<Node> names = read.selectNodes("//name");
for (int i = 0;i <names.size();i++ ){
System.out.println(names.get(i).getName());
System.out.println(names.get(i).getText());
}
//如果name节点是‘多个‘用selectNode方法来查 通过文档对象+xpath,查找book属性和id=‘1001’属性中所有的name节点
List<Node> name = read.selectNodes("//book[@id='1001']//name");
for (int i = 0;i <name.size();i++ ){
System.out.println(name.get(i).getName());
System.out.println(name.get(i).getText());
}
//如果name节点是‘一个’用selectSingleNode方法来查 通过文档对象+xpath,查找book属性和id=‘1001’属性中所有的name节点
Node n = read.selectSingleNode("//book[@id='1001']//name");
System.out.println(n.getName()+":"+n.getText());
fis.close();
}
4、XStream 的使用，快速的将Java中的对象, 转换为 XML字符串.
public static void main(String[] args) throws IOException {
Person p = new Person();
p.setName("章梓枫");
p.setAge(19);
//XStream使用
//1、创建XStresm对象
XStream x = new XStream();
//2、修改生成的根节点(可选的， 默认为包名。类名)
//把person生成最外面的节点名
x.alias("person",Person.class);
//3、传入对像开始生成
String xml = x.toXML(p);
System.out.println(xml);
//4、创建文件的输出流
FileOutputStream fos = new FileOutputStream("Dome3.xml");
//5、将输出流转换为XML输出流
XMLWriter xw = new XMLWriter(fos);
//6、写出文档
xw.write(xml);
//释放资源
xw.close();
System.out.println("执行完成！");
}
static class Person{
private String name;
private int age;
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public Person() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
5、Java生成XML文档
public static void main(String[] args) throws IOException {
//1、通过文档帮助器，创建一个文档对象
Document dos = DocumentHelper.createDocument();
//2、 给文档添加第一个节点（根节点）
Element book = dos.addElement("books");
//3、通过根节点，丰富子节点
for (int i =0;i<12;i++){
//添加子元素
Element book1 = book.addElement("book");
Element name = book1.addElement("name");
//向name元素中添加内容
name.setText("java");
Element info = book1.addElement("neirong");
//向neirong元素中添加内容
info.setText("讲述了一门编程语言");
//添加属性
book.addAttribute("id",156+i+"");
}
//4、创建文件的输出流
FileOutputStream fos = new FileOutputStream("Dome2.xml");
//5、将输出流转换为XML输出流
XMLWriter xw = new XMLWriter(fos);
//6、写出文档
xw.write(dos);
//释放资源
xw.close();
System.out.println("执行完成！");
}
2、写JSON文档
JSON:
{
“name”:“金苹果”,
“info”:“种苹果”
}
1、一个对象, 由一个大括号表示.
2、括号中 描述对象的属性 . 通过键值对来描述对象的属性
(可以理解为, 大括号中, 包含的是一个个的键值对.)格式:
3、键与值之间使用冒号连接, 多个键值对之间使用逗号分隔.
4、键值对的键 应使用引号引住 (通常Java解析时, 键不使用引号会报错. 而JS能正确解析.)
5、键值对的值, 可以是JS中的任意类型的数据
6、在JSON格式中可以与对象互相嵌套
[元素1,元素2…]
代码如下（示例）：
{
"name":"伟杰老师",
"age":18,
"pengyou":["张三","李四","王二","麻子",{
"name":"野马老师",
"info":"像匹野马一样狂奔在技术钻研的道路上"
}],
"heihei":{
"name":"大长刀",
"length":"40m"
}
}
Java与JSON做什么?
1、将Java中的对象 快速的转换为 JSON格式的字符串.
2、将JSON格式的字符串, 转换为Java的对象.
创建一个Book类给下面的方法使用：
public class Book {
private String id;
private String name;
private String info;
@Override
public String toString() {
return "Book{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", info='" + info + '\'' +
'}';
}
public Book(String id, String name, String info) {
this.id = id;
this.name = name;
this.info = info;
}
public Book() {
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Book book = (Book) o;
return Objects.equals(id, book.id) && Objects.equals(name, book.name) && Objects.equals(info, book.info);
}
@Override
public int hashCode() {
return Objects.hash(id, name, info);
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
1、Gson
1、将对象转换为JSON字符串
转换JSON字符串的步骤:
- 引入JAR包
- 在需要转换JSON字符串的位置编写如下代码即可:
String json = new Gson().toJSON(要转换的对象);
代码如下（示例）：
//1、创建Gson对象
Gson g= new Gson();
//2、转换
Book b= new Book("1001","科技","关于科技的图书");
//把Book中内容转换成JSON类型d
String s = g.toJson(b);
System.out.println(s);
System.out.println("---------------------------------------------");
//如果只用一次Gson可以这样写
String s1 = new Gson().toJson(b);
System.out.println(s1);
2、将JSON字符串转换为对象
代码如下（示例）：
//1、创建Gson对象
Gson g= new Gson();
//2、把JSON类型的{"id":"1001","name":"科技","info":"关于科技的图书"} 转换成 java类型的book类
//把JSON类型转换成别的类型的fromJson方法 //要转的类型
Book b = g.fromJson("{\"id\":\"1001\",\"name\":\"科技\",\"info\":\"关于科技的图书\"}", Book.class);
System.out.println(b.getId());
2、FastJson
1、将对象转换为JSON字符串
代码如下（示例）：
Book b= new Book("1001","科技","关于科技的图书");
//转换成 ＪＳＯＮ类型的
String j = JSON.toJSONString(b);
System.out.println(j);
2、将JSON字符串转换为对象
代码如下（示例）：
//2、把JSON类型的{"id":"1001","name":"科技","info":"关于科技的图书"} 转换成 java的Book类
Book book = JSON.parseObject("{\"id\":\"1001\",\"name\":\"科技\",\"info\":\"关于科技的图书\"}", Book.class);
System.out.println(book.getId());
扫一扫
942
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
