一、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><</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); }
