XML解析、JSON解析

最新推荐文章于 2022-04-29 14:36:28 发布

胡萝卜★

最新推荐文章于 2022-04-29 14:36:28 发布

阅读量364

点赞数

分类专栏： json xml 文章标签： xml dom gson json

本文链接：https://blog.csdn.net/qq_41128049/article/details/104503886

版权

xml 同时被 2 个专栏收录

1 篇文章 0 订阅

订阅专栏

json

0 篇文章 0 订阅

订阅专栏

一、XML

1.xml标记语言

可扩展的标记语言 XML ：

(1)写法格式：同 html 样式

(2)仅关注数据本身

(3)标记可扩展，可自定义

2、xml作用

1)数据存储、数据描述、数据交互
2)配置文件（web项目的web.xml文件、spring框架的spring.xml等）

3.格式良好的xml

要求：
文档的后缀名是 xml
每个文档有且仅有一个根元素,所谓根元素就是包含了其他所有元素的元素。
XML 目前只有一个版本，即 1.0.XML 是自描述数据，使用现有的国际标准。
语法规范：
1) 必须有 xml 文档声明
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<? 表示文档的开始

xml 表示当前是xml文档
?> 表示文档的结束
version 表示xml文档的版本，目前只有1.0
encoding 表示文档的编码格式
standalone 表示文档是否独立存在
注：文档声明必须写在xml文件中的第一行，顶个写，不能出现空*格和换行.
2) 必须有且仅有一个根元素
3) 严格区分大小写
4) 属性值用引号(双引号或单引号) :等号分开的名称-值对；在一个元素上，相同的属性只能出现一次
5) 标记成对；
6) 空标记关闭；
7) 元素正确嵌套。

元素命名规则：
1) 名称中可以包含字母、数字或者其他可见字符；
2) 名称不能以数字开头；
3) 不能以 XML/xml/Xml…开头；
4) 名称中不能含空格；
5) 名称中不能含冒号（注：冒号留给命名空间使用）

实体：
实体叫 ENTITY，实体的作用是避免重复输入。作用相当于宏或者变量。
1) 内置的 5 种实体
实体符号
< <
> >
& &
" "
’ ’
2) 自定义实体

]>
2) 使用实体
&实体名;
文档类型声明：
文档类型定义——DOCTYPE，文档类型声明，紧跟 XML 声明之后，包含所有实体声明

构成：
1、元素
2、属性
3、实体
4、PCDATA
被解析的字符数据（被解析的字符数据不应当包含任何 &、< 或者 > 字符；需要使用 &、< 以及 > 的内置实体来分别替换它们。）
5、CDATA
用于把整段文本解释为纯字符数据而不是标记的情况。如包含大量的<、>、&、或者" 字符。
CDATA 节中的所有字符都会被当做元素字符数据的常量部分，而不是 XML 标记，可以输入除]]>外任意字符，不能嵌套。
格式：
<![CDATA[ ...... ]]>

<!DOCTYPE people[
	
	<!ENTITY xb "男" >
	<!ENTITY nl "18" >
]>
<people> 
	<person  sex='1' id="1">
		<name>张三</name>
		<age>&nl;</age>
		<height>&lt;</height>
	</person>
	<person  sex="0">
		<name>李四</name>
		<age>19</age>
		<usex>&xb;</usex>
		<desc><![CDATA[战国时期，芈月是楚威王最宠爱的<小公主，但<desc>在楚威王
死后生活一落千丈，母亲向氏被楚威后逐出宫，芈月&弟弟芈戎躲过了一次次灾难和危机。
芈月与楚公子黄歇青梅竹马，真心相爱，但被作为嫡公主芈姝的陪嫁>媵侍远嫁秦国。芈姝当
上了秦国的王后，芈月不得已成为宠妃...]]></desc>
	</person>
</people>

二、XML解析

1.DOM解析

DOM解析
 * 	① 建 立 DocumentBuilderFactory : DocumentBuilderFactory factory =  DocumentBuilderFactory.newInstance(); 
	② 建立 DocumentBuilder: DocumentBuilder builder = factory.newDocumentBuilder(); 
	③ 建立 Document : Document doc = builder.parse(“要解析的文件路径”); 
	④ 建立 NodeList : NodeList nl = doc.getElementsByTagName(“读取节点”); 
	⑤ 进行 XML 信息读取
	
	public static void main(String[] args) {
		
		try {
			// 建 立 DocumentBuilderFactory解析工厂
			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
			// 建立 DocumentBuilder解析器
			DocumentBuilder builder = factory.newDocumentBuilder();
			// 解析xml文件，得到Document对象
			Document document = builder.parse("src/day01-test.xml");
			// 通过解析文档中的指定节点，得到NodeList对象
			NodeList nodeList = document.getElementsByTagName("people");
			// 遍历节点集合
			for (int i = 0; i < nodeList.getLength(); i++) {
				// 获取节点对象
				Node node = nodeList.item(i);
				// 获取节点名称
				String rootName = node.getNodeName();
				System.out.println("根节点名称：" + rootName);
				// 得到根节点的节点类型
				short nodeType = node.getNodeType();
				System.out.println("根节点节点类型：" + nodeType);
				System.out.println("元素节点类型：" + Node.ELEMENT_NODE); // 1
				System.out.println("文本节点类型：" + Node.TEXT_NODE); // 3
				
				// 得到根节点的所有子节点
				NodeList childrenNodeList = node.getChildNodes();
				// 遍历所有子节点
				for (int j = 0; j < childrenNodeList.getLength(); j++) {
					// 得到子节点的对象
					Node childNode = childrenNodeList.item(j);
					// 得到子节点对象的名称
					//System.out.println(childNode.getNodeName());
					// 判断是否是元素节点
					if (Node.ELEMENT_NODE == childNode.getNodeType()) { // 元素节点   person
						// 获取person节点的子节点
						NodeList personNodeList = childNode.getChildNodes();
						// 遍历节点
						for (int a = 0; a < personNodeList.getLength(); a++) {
							// 判断节点名称是否等于name
							//System.out.println(personNodeList.item(a).getNodeName());
							if (personNodeList.item(a).getNodeName().equals("name")) {
								// 获取节点的文本值
								System.out.println(personNodeList.item(a).getTextContent());
							}
						}
					}
				}
			}
		} catch (Exception e) {
			 // 打印异常
			e.printStackTrace();
		}
	}

//简洁版

public static void main(String[] args) {
		
		try {
			// 建 立 DocumentBuilderFactory解析工厂
			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
			// 建立 DocumentBuilder解析器
			DocumentBuilder builder = factory.newDocumentBuilder();
			// 解析xml文件，得到Document对象
			Document document = builder.parse("src/day01-test.xml");
			
			// 获取指定节点的节点对象
			NodeList nameNodeList = document.getElementsByTagName("name");
			// 获取指定节点的文本
			System.out.println(nameNodeList.item(0).getTextContent());
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}

/**
*	创建xml文件
*
*/

public static void main(String[] args) throws Exception{ 
		//获取解析器工厂
		DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance(); 
		//获取解析器
		DocumentBuilder builder=factory.newDocumentBuilder(); 
		//创建文档
		Document doc=builder.newDocument(); 
		//创建元素、设置关系
		Element root=doc.createElement("people"); 
		Element person=doc.createElement("person"); 
		Element name=doc.createElement("name"); 
		Element age=doc.createElement("age"); 
		name.appendChild(doc.createTextNode("shsxt")); 
		age.appendChild(doc.createTextNode("10")); 
		doc.appendChild(root); 
		root.appendChild(person); 
		person.appendChild(name); 
		person.appendChild(age); 
		//写出去
		// 获得变压器工厂
		TransformerFactory tsf=TransformerFactory.newInstance(); 
		Transformer ts=tsf.newTransformer(); 
		//设置编码
		ts.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); 
		//创建带有 DOM 节点的新输入源，充当转换 Source 树的持有者
		DOMSource source=new DOMSource(doc); 
		//充当转换结果的持有者
		File file=new File("src/output.xml"); 
		StreamResult result=new StreamResult(file); 
		ts.transform(source, result); 
	}

2.Sax解析了解

// 1、创建解析器工厂  
SAXParserFactory factory = SAXParserFactory.newInstance();  
// 2、获得解析器  
SAXParser parser = factory.newSAXParser();  
// SAX解析器 ，继承 DefaultHandler  
String path = new File("resource/demo01.xml").getAbsolutePath();  
// 解析 
parser.parse(path, new MySaxHandler()); 
/**
	 * 开始文档节点
	 */
	@Override
	public void startDocument() throws SAXException {
		// TODO Auto-generated method stub
		super.startDocument();
		
	}
	
	/**
	 * 开始元素解析
	 */
	@Override
	public void startElement(String arg0, String arg1, String arg2, Attributes arg3) throws SAXException {
		// TODO Auto-generated method stub
		super.startElement(arg0, arg1, arg2, arg3);
	}

	/**
	 * 开始文本解析
	 */
	@Override
	public void characters(char[] arg0, int arg1, int arg2) throws SAXException {
		// TODO Auto-generated method stub
		super.characters(arg0, arg1, arg2);
	}

	

	/**
	 * 结束元素解析
	 */
	@Override
	public void endElement(String arg0, String arg1, String arg2) throws SAXException {
		// TODO Auto-generated method stub
		super.endElement(arg0, arg1, arg2);
	}

	/**
	 * 结束文档解析
	 */
	@Override
	public void endDocument() throws SAXException {
		// TODO Auto-generated method stub
		super.endDocument();
	}

3.DOM4J解析

/**
 * Dom4J解析
 * 	1、得到要解析文件对象 file对象
 * 	2、得到解析器
 * 	3、通过解析器将file文件解析成Document对象
 * 	4、得到文档对象的根元素对象  Element对象
 * 	5、根元素对象的所有子节点，返回迭代器
 * 	6、遍历迭代器，得到元素名称和文本
 * @author Lisa Li
 *
 */
public class Dom4JParser {

	@SuppressWarnings("unchecked")
	public static void main(String[] args) throws Exception {
		
		// 1、得到要解析文件对象 file对象
		File file = new File("src/day01-test.xml");
		// 2、得到解析器
		SAXReader reader = new SAXReader();
		// 3、通过解析器将file文件解析成Document对象
		Document document = reader.read(file);
		// 4、得到文档对象的根元素对象  Element对象
		Element rootElement = document.getRootElement(); // people
		System.out.println(rootElement.getName());
		// 5、根元素对象的所有子节点，返回迭代器
		Iterator<Element> iterator = rootElement.elementIterator();
		// 6、遍历迭代器，得到元素名称和文本
		while(iterator.hasNext()) {
			Element element = iterator.next();
			System.out.println("Name：" + element.getName());
			System.out.println("Text：" + element.getText());
			System.out.println("StringValue：" + element.getStringValue());
		}
		
	}
}

/**
	创建xml文件
*/

public static void main(String[] args) throws Exception {
		
		// 使用 DocumentHelper 来创建 Document 对象
		Document document = DocumentHelper.createDocument(); 
		// 创建元素并设置关系
		Element person = document.addElement("person"); 
		Element name = person.addElement("name"); 
		Element age = person.addElement("age"); 
		// 设置文本
		name.setText("shsxt"); 
		age.setText("10"); 
		// 创建格式化输出器
		OutputFormat of = OutputFormat.createPrettyPrint(); 
		of.setEncoding("utf-8"); 
		// 输出到文件
		File file = new File("src/outputdom4j.xml"); 
		XMLWriter writer = new XMLWriter(new FileOutputStream(new 
		File(file.getAbsolutePath())),of); 
		// 写出
		writer.write(document); 
		writer.flush(); 
		writer.close();
	}

4.JDOM解析

// 获取SAX解析器  
SAXBuilder builder = new SAXBuilder();  
File file = new File("resource/demo01.xml");  
// 获取文档  
Document doc = builder.build(new File(file.getAbsolutePath()));  
// 获取根节点  
Element root = doc.getRootElement();  
System.out.println(root.getName());  
// 获取根节点下所有的子节点， 也可以根据标签名称获取指定的直接点  
List<Element> list = root.getChildren();  System.out.println(list.size());  for(int x = 0; x<list.size(); x++){  
Element e = list.get(x);  
// 获取元素的名称和里面的文本  
String name = e.getName();  
System.out.println(name + "=" + e.getText());  
System.out.println("==================");}  


//创建xml文件

// 创建节点  
Element person = new Element("person");  
Element name = new Element("name");  
Element age = new Element("age");  
// 创建属性  
Attribute id = new Attribute("id","1");  
// 设置文本  
name.setText("shsxt");  age.setText("10");  
// 设置关系  
Document doc = new Document(person);  person.addContent(name);  name.setAttribute(id);  person.addContent(age);  
XMLOutputter out = new XMLOutputter();  
File file = new File("src/outputjdom.xml");  out.output(doc, new FileOutputStream(file.getAbsoluteFile()));

三、JSON

1.json理解和样式

JSON：JavaScript 对象表示法(JavaScriptObject Notation）, 一种轻量级的数据交换格式,
易于人阅读和编写, 也易于机器解析和生成。

JSON 是存储和交换文本信息的语法，类似 XML。

//基本类型  
{ 
 "name": "张三", 
"age": 18, 
"sex": true
} 	 
//数组类型 
[  	{ 
 "name": "张三", 
 "age": 18, 
 "sex": true 
}, 
{ 
 "name": "李四", 
 "age": 19, 
 "sex": false 
} ]
//对象嵌套 
{
 	"name": "teacher", 
    "computer": { 
     "CPU": "intel7", 
     "disk": "512G" 
    }, 
    "students": [ 
     { 
      "name": "张三", 
      "age": 18, 
      "sex": true 
     }, 
     { 
      "name": "李四", 
      "age": 19, 
      "sex": false 
     } 
    } 	]

2.json格式

a)、对象:“名称/值”对的集合(A collection
of name/value pairs) 不同的语言中，它被理解为对象（object），记录（record），结构(struct)，字典 (dictionary)，哈希表（hash table），有键列表(keyedlist)，或者关联数组(associative array)black;

b)、数组:值的有序列表(An ordered list of values) 在大多数语言中，它被理解为数组(array)、矢量(vector), 列表(list)或者序列 (sequence)。

具体形式

Json 以 key－value 的形式存储数据

Key 的取值为 String 类型;

Value 的取值为 String,boolean,Number,数组,Object,null;

Json串以{开始,以}结尾;

Json 串中数组是以[开始,以]结尾;

Json 串中Object是以{开始,以}结尾;

四、JSON解析

1.gson解析

Gson 是一个 Google 提供的一个 Java 库,可用于将 Java 对象转换为JSON 表示

/**
	 * 将Java对象（JavaBean、List、Map）转换成JSON格式的字符串
	 */
	@Test
	public void testJavaToJson() {
		
		// 得到gson对象
		Gson gson = new Gson();
		
		/**
		 
		 {
		 	"userId":1,
		 	"uname":"张三",
		 	"upwd":"123456"
		 }
		 
		 */
		// 创建JavaBean对象
		User user = new User(1,"张三","123456");
		// 将对象转换成字符串
		String json = gson.toJson(user);
		System.out.println(json);
		
		/**
		 	[
		 		aa,
		 		bb,
		 		cc
		 	]
		 */
		// 创建List
		List<String> list = new ArrayList<>();
		list.add("aa");
		list.add("bb");
		list.add("cc");
		// 将集合转换成字符串
		String json2 = gson.toJson(list);
		System.out.println(json2);	
		
		// 创建List
		List<User> userList = new ArrayList<>();
		User user2 = new User(2,"lisi","123321");
		User user3 = new User(3,"wangwu","111222");
		userList.add(user);
		userList.add(user2);
		userList.add(user3);
		// 将集合转换成字符串
		String json3 = gson.toJson(userList);
		System.out.println(json3);

		// 创建Map
		Map<String,Object> map = new HashMap<>();
		map.put("name", "admin");
		map.put("user", user);
		map.put("userList", userList);
		// 将map对象转换成字符串
		String json4 = gson.toJson(map);
		System.out.println(json4);
	}

/**
	 * 将json格式的字符串转换成指定的java对象
	 
	 	json解析成java对象
	 * */
	@Test
	public void testJsonToJava(){
		//准备json格式的字符串
		String json1="{\"userId\":1,\"uname\":\"张三\",\"upwd\":\"123456\"}";
		String json2 = "[\"aa\",\"bb\",\"cc\"]";
		String json3 = "[{\"userId\":1,\"uname\":\"张三\",\"upwd\":\"123456\"},{\"userId\":2,\"uname\":\"lisi\",\"upwd\":\"123321\"},{\"userId\":3,\"uname\":\"wangwu\",\"upwd\":\"111222\"}]";
		String json4="{\"userList\":[{\"userId\":2,\"uname\":\"lisi\",\"upwd\":\"123\"},{\"userId\":3,\"uname\":\"wangwu\",\"upwd\":\"1234\"},{\"userId\":1,\"uname\":\"张三\",\"upwd\":\"123456\"}],\"name\":\"admin\",\"user\":{\"userId\":1,\"uname\":\"张三\",\"upwd\":\"123456\"}}";
		//将字符串转换成java对象
		User user=new Gson().fromJson(json1, User.class);
		System.out.println(user.getUname());
        
		List<String> list=new Gson().fromJson(json2, new TypeToken<List<String>>(){}.getType());
		System.out.println(list);
        
		List<User> userList=new Gson().fromJson(json3,new TypeToken<List<User>>(){}.getType());
		System.out.println(userList.get(0).getUserId());
        
		/**
		 * Map<String,Student> 	map 	= 	gson.fromJson(json, 
		   TypeToken<Map<String,Student>>() 
		   {}.getType()); 
		 * */
		Map<String,Object> map=new Gson().fromJson(json4, new TypeToken<Map<String,Object>>(){}.getType());
		System.out.println(map);
	}

/**
	 * GSON的节点解析
	 * 	1、得到解析器
	 * 	2、通过解析器将字符串转换成JsonElement对象
	 * 	3、根据文档结构将JsonElement对象转换成具体的对象（JsonObject对象或JsonArray对象）
	 * 	4、得到对象中的节点对象
	 * 		flag，基本数据类型的类型
	 * 		将基本数据的对象转换成具体的数据类型
	 	{
			"flag": true,
			"data": {
				"userId":1
				"uname":"张三",
				"upwd":"123456"
		 	}
	 	}
	 */
	@Test
	public void jsonParse(){
		//准备要解析的字符串
		String json = "{\"flag\": true,\"data\": {\"userId\":1,\"uname\":\"张三\",\"upwd\":\"123456\"}}";
		//得到解析器
		JsonParser parser=new JsonParser();
		//通过解析器将字符串转换成JsonElement对象
		JsonElement element=parser.parse(json);
		//根据文档结构将JsonElement对象转换成具体的对象（JsonObject对象或JsonArray对象）
		JsonObject root=element.getAsJsonObject();
		//得到对象中的节点对象
		//解析flag 返回的基本数据类型 JsonPrimitive对象
		JsonPrimitive primitive=root.getAsJsonPrimitive("flag");
		//基本数据类型转换成具体的数据
		boolean flag=primitive.getAsBoolean();
		System.out.println(flag);
		//解析data 返回对象类型 JsonObject
		JsonObject object=root.getAsJsonObject("data");
		//将json对象转换成java对象
		User user=new Gson().fromJson(object, User.class);
		System.out.println(user.getUname());
		
	}
	
	@Test
	public void test2(){
		//准备要解析的字符串
		String json="{\"flag\": true,\"data\": {\"userId\":1,\"uname\":\"张三\",\"upwd\":\"123456\"}}";
		//将json对象转换成java对象
		JsonDeml jsonDem1=new Gson().fromJson(json,JsonDeml.class);
		System.out.println(jsonDem1.isFlag());
	}

2.fastJson解析

阿里巴巴 fastJson 是一个 Json 处理工具包，包括“序列化”和“反序列化”两部分，

它具备如下特征：速度最快，测试表明，fastjson 具有极快的性能，超越其他的 Java Json parser。包括自称最快的 JackJson；功能强大，完全支持 Java Bean、集合、Map、日期、Enum，支持范型，支持自省；无依赖。

Fastjson 是一个 Java 语言编写的高性能功能完善的 JSON 库

//toJSONString()  java对象转换成json格式
	@Test
	public void testJavaToJson() {
		
		// 创建JavaBean对象
		User user = new User(1,"张三","123456");
		System.out.println(JSON.toJSONString(user));
		
		
		// 创建List
		List<String> list = new ArrayList<>();
		list.add("aa");
		list.add("bb");
		list.add("cc");
		System.out.println(JSON.toJSONString(list));
		
		
		// 创建List
		List<User> userList = new ArrayList<>();
		User user2 = new User(2,"lisi","123321");
		User user3 = new User(3,"wangwu","111222");
		userList.add(user);
		userList.add(user2);
		userList.add(user3);
		System.out.println(JSON.toJSONString(userList));
		
		
		// 创建Map
		Map<String,Object> map = new HashMap<>();
		map.put("name", "admin");
		map.put("user", user);
		map.put("userList", userList);
		System.out.println(JSON.toJSONString(map));
		
	}

/**
	 * 将json字符串转换|解析成java对象
	 */
	@Test
	public void testJsonToJava() {
		// 准备JSON格式的字符串
		String json1 = "{\"userId\":1,\"uname\":\"张三\",\"upwd\":\"123456\"}";
		String json2 = "[\"aa\",\"bb\",\"cc\"]";
		String json3 = "[{\"userId\":1,\"uname\":\"张三\",\"upwd\":\"123456\"},{\"userId\":2,\"uname\":\"lisi\",\"upwd\":\"123321\"},{\"userId\":3,\"uname\":\"wangwu\",\"upwd\":\"111222\"}]";
		String json4="{\"userList\":[{\"userId\":2,\"uname\":\"lisi\",\"upwd\":\"123\"},{\"userId\":3,\"uname\":\"wangwu\",\"upwd\":\"1234\"},{\"userId\":1,\"uname\":\"张三\",\"upwd\":\"123456\"}],\"name\":\"admin\",\"user\":{\"userId\":1,\"uname\":\"张三\",\"upwd\":\"123456\"}}";
		User user = JSON.parseObject(json1,User.class);
		
		List<String> list = JSON.parseArray(json2,String.class);
		
		List<User> userList = JSON.parseArray(json3,User.class);
		
		System.out.println(user.getUname());
		System.out.println(list.get(0));
		System.out.println(userList.get(0).getUname());
		/**
		 * List<Map> : List<Map> listMap = JSON.parseObject(jsonString, new TypeReference<List<Map>>(){}); 
		 * */
		//映射
		Map<String,Object> map=JSON.parseObject(json4, new TypeReference<Map<String,Object>>(){});
		System.out.println(map);
	}