Java XML和JSON

从为什么、是什么、怎么做来介绍

文章目录

- 为什么要使用XML和JSON
- XML
- - 什么是XML
  - XML语法规则
  - - 1. XML声明（必选）
    - 2. 标签格式（必选）
    - 3. 根元素（必选）子元素（可选）
    - 4. 元素属性（可选）
    - 5. CDATA（可选）
    - 6. 注释
    - 7. 树状结构（语法决定）
  - 怎么生成XML文件
  - - 1. 逐个元素生成
    - 2. Java对象生成XML文件
    - 3. Java对象生成XML文件参考
  - 怎么解析XML文件
  - - 1. 导入依赖jar（也要理解）
    - 2. 创建指向XML文件的输入流
    - 3. 创建XML读取工具对象（经常忘记）
    - 4. 使用读取工具读取输入流，返回document文档对象
    - 5. 通过document文档对象定位根元素对象
    - 6. 通过父元素定位子元素对象
    - 7. 通过XPATH定位子元素对象
    - 8. 关闭输入流
  - 解析网络XML文件
  - 其他常用的XML方法
  - - 1. document接口
    - 2. Element类
    - 3. SAXReader和XMLWriter
- JSON
- - 什么是JSON
  - JSON语法规则
  - Java类对象与JSON字符串互相转换
  - - 1. GSON
    - 2. faatJSON

为什么要使用XML和JSON

场景1：

Oracle和Mysql里的数据想要互相导入导出，可以先导出成XML、JSON，再导入XML、JSON

场景2：

微服务架构，各个业务发布的时间、版本号不同，可以将这些信息写成XML配置文件，让程序动态加载微服务。

场景3：

客户端、服务器频繁传输大量、多种类型信息，想要精简信息内容，达到比较高的传输效率，可以使用JSON格式。

个人总结一下：

XML和JSON都是为了统一不同系统、不同编程语言、不同软硬件之间使用的信息形式，保证信息可以正确地传递、解析。毕竟这是个信息化时代，信息太重要了，万物都是信息。

XML 什么是XML

XML=EXtensible Markup Language，翻译过来就是可扩展标记语言。

首先，它是一种语言，肯定有自己的语法规则，遵守规则才能使用它。

其次，它是标记语言，由许多标签组成，标签没有被预定义，需要自行定义。

再次，它是可扩展的，层次丰富，还可以用属性自我描述。

最后，其实从使用场景中也可以反推出XML是什么：XML用来存数据，而不是显示数据。

XML语法规则 1. XML声明（必选）

文件第一行需要声明自己是一个xml文件，便于解析

合法举例：

2. 标签格式（必选）

（1）标签的名称由一对尖括号括起，标签名称自定义。

（2）标签的内容包括开始标签、结束标签和其中的内容，标签必须闭合

（3）标签不可交叉嵌套，如...</note>

（4）标签名称建议只用字母数字下划线，不建议用特殊符号

（5）标签名称是大小写敏感的

（6）转义：

写法	转义后	表示
<	<	小于
>	>	大于
&	&	和号
'	’	单引号
"	"	引号

（7）以n存储换行

合法举例：...

3. 根元素（必选）子元素（可选）

XML声明下的第一个标签即为根元素，根元素里面的所有标签都是子元素。

4. 元素属性（可选）

（1）形式是key-value

（2）位置可以参考XML声明，即在元素开始标签中

（3）属性数量没有限制，但每个属性的值只能有一个

合法举例：Learning Note

5. CDATA（可选）

存大量特殊符号时使用，如需要转义的字符< > & ’ "

合法举例：5,问：c和d那个更好看？ ]]>

6. 注释

7. 树状结构（语法决定）

有根有子就想到树状结构，XML应该是缩进不严格的。

怎么生成XML文件 1. 逐个元素生成

//1.创建文档对象
document document = documentHelper.createdocument();

//2.创建根元素！！要不然会NullPointerException报错
Element books = document.addElement("books");

//3.丰富XML内容
for(int i=0;i<10;i++){
	Element book = books.addElement("book");
	book.setText("第"+i+"本书");
}


//4.创建文件输出流
FileOutputStream fos = new FileOutputStream("src/taskxml/temp2.xml");//追加就传入true参数

//5.将XML内容写入输出流
XMLWriter xw = new XMLWriter(fos);
xw.write(document);

//关闭流
xw.close();
fos.close();
System.out.println("finished.");

2. Java对象生成XML文件

依赖xstream.jar

//类
class Person{
        String name;
        int age;

        public Person() {
        }

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }

        public void setName(String name) {
            this.name = name;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }

//方法
public static void main(String[] args) throws IOException {
        Person person = new Person();
        person.setName("tony");
        person.setAge(18);

        //XStream的使用
        //1.创建XStream对象
        XStream sx = new XStream();

        //2.修改XStream对象的根元素
    	//逐个元素生成时，第一步也是生成根元素！
        sx.alias("person", Person.class);//根节点

        //3.用类对象丰富XML内容，返回XML格式的String
        String xmlString = sx.toXML(person);

        //4.输出XML格式的字符串
        System.out.println(xmlString);

        //5.输出XML文件
        FileOutputStream fos = new FileOutputStream("src/taskxml/temp3.xml");
        OutputStreamWriter writer = new OutputStreamWriter(fos, "utf-8");
        writer.write(xmlString);

        //关闭流
        writer.close();//关闭才会写入，不关闭不写入，除非flush()
        fos.close();
        System.out.println("finished.");

    }

3. Java对象生成XML文件参考

https://blog.csdn.net/dc282614966/article/details/80970750

怎么解析XML文件 1. 导入依赖jar（也要理解）

在项目根目录中添加lib文件夹，与src文件夹平级，src文件夹都是对客户端可见的，lib不需要对客户端可见。

lib文件夹中放入依赖的jar包

在Project Structure中创建一个项目的Library，Library中添加lib文件夹下的jar包，

在Project Structure当前项目的Modules中导入刚刚创建的Library，作为项目的依赖库。可以看到项目默认有JDK11自带的jar包。

OK后，lib文件夹下的jar包都可以展开了

2. 创建指向XML文件的输入流

FileInputStream fis = new FileInputStream("path");

3. 创建XML读取工具对象（经常忘记）

SAXReader sr = new SAXReader();//这个对象很重要，没有它就没有read()

4. 使用读取工具读取输入流，返回document文档对象

document doc = sr.read(fis);
//document实际上是一个接口，但是通过追根溯源read()方法，发现实际上read()方法返回的是Defaultdocument类对象！


//Defaultdocument类对象返回createSingleton()
public static synchronized documentFactory getInstance() {
        if (singleton == null) {
            singleton = createSingleton();
        }
        return (documentFactory) singleton.instance();
    }

//createSingleton()方法返回Class.newInstance()
String singletonClass = System.getProperty("org.dom4j.documentFactory.singleton.strategy", "org.dom4j.util.SimpleSingleton");
Class clazz = Class.forName(singletonClass);
result = (SingletonStrategy) clazz.newInstance();

//最后返回Constructor，略复杂，后面没有继续研究了

5. 通过document文档对象定位根元素对象

注意，是先有文档，才有文档中的内容

Element root = doc.getRootElement();
//和document一样，Element也是一个接口，getRootElement()返回

6. 通过父元素定位子元素对象

Element student = root.element("student");
//只能得到第一个student，或者NullPointerException

Element firstname = student.element("firstname");
//firstname是student的子元素

List es = root.elements();
//得到root下一级的所有子元素对象，存在List中

这样解析的弊端就是要非常了解文档的标签。

7. 通过XPATH定位子元素对象

举例结构：

books

book id=1

name

info

book id=2

name

info

写法	含义	举例
/	根节点	/book
//	发起查找的节点位置	//info
.	当前节点	./name（假设现在是book节点）
…	父节点	…/book（假设现在是name节点）
@	选择属性	[@属性名=“属性值”]，大于小于不等于都行

		//1.XML文件的输入流，会抛出异常
        FileInputStream fis = new FileInputStream("src/taskxml/temp.xml");
        //2.创建XML读取工具对象
        SAXReader sr = new SAXReader();
        //3.通过工具读取XML文件输入流，得到XML文件对象，会抛出异常
        document doc = sr.read(fis);

        //4.获取指定元素
        List nodes = doc.selectNodes("//name");
		//获取匹配到的第一个元素是selectSingleNode()，返回Node

        for (Node node: nodes) {
            System.out.println(node.getText());
        }

        //关闭流
        fis.close();

8. 关闭输入流

fis.close();

解析网络XML文件

和解析本地XML文件类似，这里只是想介绍网络请求相关类

String phone = "";//手机号

//接口文档https://www.juhe.cn/docs/api/id/11
URL url = new URL("http://apis.juhe.cn/mobile/get?phone="+phone+"&dtype=xml&key=");//key在个人中心->我的数据,接口名称上方查看

URLConnection conn = url.openConnection();
InputStream is = conn.getInputStream();

SAXReader sr = new SAXReader();
document doc = sr.read(is);

//接下来就跟本地解析XML文件完全一样了

其他常用的XML方法 1. document接口

这些方法的实现其实都靠Defaultdocument类

//创建空文档
documentHelper.createdocument();

//获取元素
Element getRootElement();

//添加元素
Element addElement(String subTagName);//添加子节点，来自Branch接口

//删除元素
boolean remove(Element element);//参数还可以是Comment、Node、ProcessingInstruction

//修改元素
void setRootElement(Element var1);

//其他一些属性
String getXMLEncoding();
void setXMLEncoding(String encoding);

documentType getDocType();
void setDocType(documentType docType);//documentType也是一个类

2. Element类

这些方法的实现其实都靠DefaultElement类

//查看
String getName();

//查看内容
String getText();
String elementText(String name);//参数还可以是QName

//查看属性
Attribute attribute(String name);//参数还可以是QName
String attributevalue(String name);//参数还可以是QName

//获取元素
Element element(String name);//参数还可以是CDATA、Entity、Text、Namespace

//添加
void add(Attribute attribute);//参数还可以是CDATA、Entity、Text、Namespace
Element addAttribute(String name, String value);//添加属性
Element addElement(String subTagName);//添加子节点
void setText(String text);//添加内容，来自Node接口

//删除
boolean remove(Attribute attribute);//参数还可以是CDATA、Entity、Text、Namespace

//修改属性
Element addAttribute(String name, String value);//参数还可以是QName，会覆盖原attr
void setAttributes(List attributes);


//获取多个元素
List elements();//得到多个子 元素

3. SAXReader和XMLWriter

SAXReader.read(FileInputStream fis);//用于读取XML文档输入流

XMLWriter.write(document doc);//用于编辑XML文件

JSON 什么是JSON

JSON = Javascript Object Notation，翻译过来就是JS对象简谱，是一种轻量级的数据交换格式。

（Javascript和Java关系不大）

程序生成和解析JSON比XML快，和类对象的互相转换也方便。

JSON语法规则

//Java描述
class Book{
    private String name;
    private String info;
    //getter，setter
}
Book b = new Book();
b.setName("aaa");
b.setInfo("bbb");


	aaa
    bbb

//JSON描述，[]是数组，{}是key-value对象
{
    "name":"aaa",
    "info":"bbb",
    "writer":["ccc", "ddd"],
    "chapters":{
        "total": "chapter one",
        "pages": [100, 200, 300]
    }
}

Java类对象与JSON字符串互相转换

//类
public class Book{
    private String id;
    private String name;
    private String info;
    //constructor
    //getter&setter
    //toString
}

1. GSON

google的JSON解析jar包，也需要导入项目lib

public static void main(String[] args) {
        //1.类对象转成JSON字符串
        //类对象
        Book b = new Book(100, "哈利波特", "哈利波特与魔法师", new int[]{1, 2, 3});
        //转换工具对象
        String json = new Gson().toJson(b);
        //输出
        System.out.println(json);

        //2.JSON字符串转成类对象
        Book book = new Gson().fromJson(json, Book.class);
        System.out.println(book);

        //3.还可以转成其他对象
        HashMap data = new Gson().fromJson(json, HashMap.class);
        System.out.println(data);

        //4.解析数组对象
        System.out.println(data.get("page").getClass());//数组自动转成List
        List list = (List)(data.get("page"));
        System.out.println(list.get(1));//HashMap的数字默认是double？
}

2. faatJSON

阿里的JSON解析jar包，也需要导入项目lib

		//1.类对象转成JSON字符串
        //类对象
        Book b = new Book(100, "哈利波特", "哈利波特与魔法师", new int[]{1, 2, 3});
        //转换工具对象
        String json = JSON.toJSONString(b);
        //输出
        System.out.println(json);

        //2.JSON字符串转成类对象
        Book book = JSON.parseObject(json, Book.class);
        System.out.println(book);

        //3.JSON字符串转成JSON对象
        Object o = JSON.parseObject(json);
        System.out.println(o);

        //4.强转数组
        List list = (List) JSON.parseObject(json).get("page");
        System.out.println(list);

Java XML和JSON

Java相关栏目本月热门文章