Java -> XML文档、设计模式（工厂、装饰）

本文主要是介绍Java -> XML文档、设计模式（工厂、装饰），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

初识XML文件：

XML文档约束之DTD文档约束：

XML文档约束之schema约束：

XML文档解析：Dom4J:

dom4j的jar包下载：

使用Dom4J把一个XML文件的数据进行解析：

官网下载Dom4J框架
在项目中新建一个文件夹：lib
将dom4j - 2.1.1.jar文件复制到lib文件夹
在jar文件夹上点右键，选择Add as Library
在类中导包使用

Contacts.xml文件内容：

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <contacatList>
 3     <contact id="1" vip="true">
 4         <name>    赵妍    </name>
 5         <gender>女</gender>
 6         <email>zhaoyan@qq.com</email>
 7     </contact>
 8 
 9     <contact id="2" vip="false">
10         <name>    李明    </name>
11         <gender>男</gender>
12         <email>liming@163.com</email>
13     </contact>
14 
15     <contact id="3" vip="true">
16         <name>    杨烁    </name>
17         <gender>男</gender>
18         <email>yangshuo@qq.com</email>
19     </contact>
20 
21     <user>
22 
23     </user>
24 
25 </contacatList>

 1 import org.dom4j.Attribute;
 2 import org.dom4j.Document;
 3 import org.dom4j.Element;
 4 import org.dom4j.io.SAXReader;
 5 import org.junit.Test;
 6 
 7 import java.io.File;
 8 import java.io.InputStream;
 9 import java.util.List;
10 
11 /**
12  * 使用dom4j解析XML文件中的数据
13  * 1、导入dom4j框架
14  * 2、准备一个xml文件
15  * */
16 
17 public class Dom4JHelloWorldDemo1 {
18     @Test
19     public void parseXMLData() throws Exception{
20         //1、创建do4j的解析器对象
21         SAXReader saxReader = new SAXReader();
22         //2、把XML文件加载到内存中成为Document文档对象
23         //Document document = saxReader.read(new File("xml-app\\src\\Contacts.xml")); //需要通过模块名定位
24         //注意：/ 表示是直接到src下寻找文件
25         InputStream inputStream  = Dom4JHelloWorldDemo1.class.getResourceAsStream("/Contacts.xml");
26         Document document = saxReader.read(inputStream);
27         //3、获取根元素对象
28         Element rootElement = document.getRootElement();
29         System.out.println("获取根元素对象：" + rootElement.getName());
30 
31         //4、获取根元素下的全部子元素【父拿子】
32         System.out.println("获取根元素下的所有子元素：");
33         List<Element> allSonElements = rootElement.elements();
34         for (Element sonElement : allSonElements) {
35             System.out.println(sonElement.getName());
36         }
37         //5、拿某个子元素
38         System.out.println("拿某个子元素:");
39         Element userElement = rootElement.element("user");
40         System.out.println(userElement.getName());
41 
42         System.out.println("拿某个子元素【如果有很多，默认拿第一个】:");
43         Element contactElement = rootElement.element("contact");
44         System.out.println(contactElement.getName());
45         System.out.println("contact中name属性的文本内容：" + contactElement.elementText("name"));
46         System.out.println("contact中name属性的文本内容【去掉前后空格】：" + contactElement.elementTextTrim("name"));
47         Attribute attribute = contactElement.attribute("id");
48         System.out.println("根据元素获取属性值【getName:属性名、getValue:属性值】：" + attribute.getName() + " ==> " + attribute.getValue());
49         //也可以直接通过属性获取属性值
50         System.out.println("直接通过属性获取属性值：" + contactElement.attributeValue("id"));
51 
52         //获取当前元素下的子元素对象【有多个同名返回第一个】
53         Element emailElement = contactElement.element("email");
54         System.out.println("email标签中的文本内容：" + emailElement.getText());
55 
56     }
57 }

需要：XML解析案例
需求：利用Dom4j的知识，将Contactsxml文件中的联系人数据封装成List集合，其中每个元素是实体类Contact。打印输出list中的每个元素

 1 import org.dom4j.Document;
 2 import org.dom4j.Element;
 3 import org.dom4j.io.SAXReader;
 4 import org.junit.Test;
 5 
 6 import java.util.ArrayList;
 7 import java.util.List;
 8 
 9 public class Dom4jTest2 {
10         //需求：解析xml文件中的数据成为List集合对象
11         @Test
12         public void parseToList() throws Exception{
13             //1、导入框架【已完成】
14             //2、创建SaxReader对象
15             SAXReader saxReader = new SAXReader();
16             //3、加载xml文件成为Document对象
17             Document document = saxReader.read(Dom4jTest2.class.getResourceAsStream("/Contacts.xml"));
18             //4、先拿根元素
19             Element rootElement = document.getRootElement();
20             //5、提取contact子元素
21             List<Element> contactElements = rootElement.elements("contact");
22             //6、准备ArrayList集合封装联系人数据
23             ArrayList<Contact> contacts = new ArrayList<>();
24             //7、遍历contact子元素
25             for (Element contactElement : contactElements) {
26                 //8、每一个子元素都是一个联系人对象
27                 Contact contact = new Contact();
28                 contact.setId(Integer.valueOf(contactElement.attributeValue("id")));
29                 contact.setVip(Boolean.valueOf(contactElement.attributeValue("vip")));
30                 contact.setName(contactElement.elementTextTrim("name"));
31                 //保证取到的只有一个字符
32                 contact.setGender(Character.valueOf(contactElement.elementTextTrim("gender").charAt(0)));
33                 contact.setEmail(contactElement.elementTextTrim("email"));
34                 contacts.add(contact);
35             }
36             //遍历集合
37             for (Contact contact : contacts) {
38                 System.out.println(contact);
39             }
40         }
41 }

XML的检索技术：Xpath

使用Dom4j把一个XML文件的数据进行解析：

分析：

导入jar包（dom4j 和 jaxen - 1.1.2.jar），Xpath技术依赖Dom4j技术
通过dom4j的SAXReader获取Documnet对象
利用XPath提供的API ，结合XPath的语法完成选取XML文档元素节点进行解析操作

在Contacts.xml中加入一个user标签并在其中添加内容：

 1 import org.dom4j.Attribute;
 2 import org.dom4j.Document;
 3 import org.dom4j.Element;
 4 import org.dom4j.Node;
 5 import org.dom4j.io.SAXReader;
 6 import org.junit.Test;
 7 
 8 import java.util.List;
 9 
10 public class XPathDemo {
11     @Test
12     public void parse01() throws Exception{
13         //创建解析器对象
14         SAXReader saxReader = new SAXReader();
15         //把xml加载成Document文档对象
16         Document document = saxReader.read(XPathDemo.class.getResourceAsStream("/Contacts.xml"));
17         //检索全部的名称
18         //定位到所有contactList标签下的contact下的name标签，
19         List<Node> nodes = document.selectNodes("/contacatList/contact/name");
20         for (Node node : nodes) {
21             Element nameElement = (Element) node; //父类的节点转成子类的元素
22             System.out.println(nameElement.getTextTrim());
23         }
24         System.out.println("-----------parse01_end------------");
25     }
26 
27     //相对路径：./子元素/子元素 (.代表当前子元素)
28     @Test
29     public void parse02() throws Exception{
30         //创建解析器对象
31         SAXReader saxReader = new SAXReader();
32         //把xml加载成Document文档对象
33         Document document = saxReader.read(XPathDemo.class.getResourceAsStream("/Contacts.xml"));
34         Element rootElement = document.getRootElement();
35         //检索全部的名称
36         //定位到所有contactList标签下的contact下的name标签，
37         List<Node> nodes = rootElement.selectNodes("./contact/name");
38         for (Node node : nodes) {
39             Element nameElement = (Element) node; //父类的节点转成子类的元素
40             System.out.println(nameElement.getTextTrim());
41         }
42         System.out.println("-----------parse02_end------------");
43     }
44 
45     //3、全文检索：
46     /**
47      * //元素：在全文找这个元素
48      * //元素1/元素2/ 在全文找元素1下面的元素2
49      * //元素1/元素2 在全文找元素1下面的全部元素2
50      */
51 
52     @Test
53     public void parse03() throws Exception{
54         //创建解析器对象
55         SAXReader saxReader = new SAXReader();
56         //把xml文件加载成Document文档对象
57         Document document = saxReader.read(XPathDemo.class.getResourceAsStream("/Contacts.xml"));
58         //检索数据
59         //List<Node> nameNodes = document.selectNodes("//name"); //所有包含name标签的元素 【所有名字】
60         //List<Node> nameNodes = document.selectNodes("//contact/name"); //所有contact标签下的name标签的元素【除去无天】
61         List<Node> nameNodes = document.selectNodes("//contact//name"); //所有contact标签下的所有name标签的元素【所有名字】
62         for (Node nameNode : nameNodes) {
63             Element nameElement = (Element) nameNode; //转换成Element元素对象
64             System.out.println(nameElement.getTextTrim());
65         }
66         System.out.println("-----------parse03_end------------");
67     }
68 
69     //4、属性查找
70     /**
71      * @属性名称 ： 在全文中检索属性对象 【定位属性 ~ 】
72      * 元素[@属性名称] 在全文中检索包含改属性的元素对象
73      * 元素[@属性名称=值] 在全文中检索该属名等于该值的元素对象
74      */
75     @Test
76     public void parse04() throws Exception{
77         //创建解析器对象
78         SAXReader saxReader = new SAXReader();
79         //把xml文件加载成Document文档对象
80         Document document = saxReader.read(XPathDemo.class.getResourceAsStream("/Contacts.xml"));
81         //检索数据
82         List<Node> idNodes = document.selectNodes("//@id");
83         for (Node idNode : idNodes) {
84             //idNode为属性
85             //此处说明属性也实现了节点 ： public interface Attribute extends Node{ }
86             Attribute attribute = (Attribute) idNode;
87             System.out.println("属性名：" + attribute.getName() + ",属性值" + attribute.getValue());
88         }
89         //name中包含id属性的
90         //Node node = document.selectSingleNode("//name[@id]"); //【无天】
91         //name属性中id值为5的
92         Node node = document.selectSingleNode("//name[@id=5]"); //【无天】
93         Element element = (Element) node;
94         System.out.println(element.getTextTrim());
95      }
96 }

设计模式之工厂模式

设计模式之装饰类：

步骤：

定义父类
定义原始类，继承父类，定义功能
定义装饰类，继承父类，包装原始类，增强功能

模拟io流中的InputStream、FileInputStream、BufferedInputStream.

1 //1、定义父类
2 public abstract class MyInputStream {
3     public abstract int read();
4     public abstract int read(byte[] bytes);
5 }

 1 import java.util.Arrays;
 2 
 3 //2、原始类 : 继承父类、定义功能
 4 public class MyFileInputStream extends MyInputStream {
 5     @Override
 6     public int read() {
 7         System.out.println("以低性能的方式读取了一个字节a");
 8         return 'a';
 9     }
10 
11     @Override
12     public int read(byte[] bytes) {
13         byte[] buffer = new byte[3];
14         buffer[0] = 97;
15         buffer[1] = 98;
16         buffer[2] = 99;
17         System.out.println("以低性能的方式读取了一个字节数组" + Arrays.toString(buffer));
18         return 3;
19     }
20 }

 1 //3、装饰类 : 继承父类，拓展原始类的功能
 2 public class MyBufferedInputStream extends MyInputStream{
 3     private MyInputStream myInputStream;
 4     public MyBufferedInputStream(MyInputStream myInputStream){
 5         this.myInputStream = myInputStream;
 6     }
 7 
 8     //在调用功能时,最终还是调用原始类的功能
 9     @Override
10     public int read() {
11         byte[] bytes = new byte[8*1024];
12         System.out.println("提供8KB的缓冲区，提高读写性能");
13         return myInputStream.read();
14     }
15 
16     @Override
17     public int read(byte[] bytes) {
18         byte[] bytes2 = new byte[8*1024];
19         System.out.println("提供8KB的缓冲区，提高读写性能");
20         return myInputStream.read(bytes2);
21     }
22 }

1 public class DecorateDemo {
2     public static void main(String[] args) {
3         MyInputStream myInputStream = new MyBufferedInputStream(new MyFileInputStream());//创建换从字符输入流包装低级流
4         System.out.println(myInputStream.read());
5         System.out.println(myInputStream.read(new byte[3]));
6     }
7 }

这篇关于Java -> XML文档、设计模式（工厂、装饰）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

Java -> XML文档、设计模式（工厂、装饰）

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯