本文实例讲述了Java基于正则表达式实现xml文件的解析功能。分享给大家供大家参考，具体如下：
这是我通过正则表达式实现的xml文件解析工具，有些XHTML文件中包含特殊符号，暂时还无法正常使用。
设计思路：常见的xml文件都是单根树结构，工具的目的是通过递归的方式将整个文档树装载进一个Node对象。xml文档树上的每一个节点都能看做一个Node对象，它拥有title、attribute和text三个自身变量以及一个childrenNode集合用来存放子节点，使用正则表达式完整装载。
一、编写Node类
Node对象是文档解析的基础，最终可以通过对象的不同属性实现对文档信息的访问。
Node.java：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
import java.io.Serializable;import java.util.HashMap;import java.util.Iterator;import java.util.LinkedList;import java.util.List;import java.util.Map;import java.util.Map.Entry;public class Node implements Serializable { // 可以对Node对象持久化保存 private static final long serialVersionUID = 1L; private int id; // 节点类型 private String title; // 节点内容 private String text; // 节点属性集合 private Map<String, String> attributes = new HashMap<String, String>(); // 子节点集合 private List<Node> childNodes = new LinkedList<Node>(); public int getId() { return id; } public void setId(int id) { this.id = id; } public String getTitle() { return title; } public void setTitle(String title) { this.title = title; } public Map<String, String> getAttribute() { return attributes; } public void setAttribute(Map<String, String> attribute) { this.attributes = attribute; } public String getText() { return text; } public void setText(String text) { this.text = text; } public List<Node> getChildNode() { return childNodes; } public void setChildNode(List<Node> childNode) { this.childNodes = childNode; } // 将属性集合转换成一条完整的字符串 private String attrToString() { if (attributes.isEmpty()) { return ""; } Iterator<Entry<String, String>> its = attributes.entrySet().iterator(); StringBuffer buff = new StringBuffer(); while (its.hasNext()) { Entry<String, String> entry = its.next(); buff.append(entry.getKey() + "=\"" + entry.getValue() + "\" "); } return " " + buff.toString().trim(); } // 输出完整的节点字符串也用到了递归 @Override public String toString() { String attr = attrToString(); if (childNodes.isEmpty() && text == null) { return "<" + title + attr + "/>\n"; } else if (childNodes.isEmpty() && text != null) { return "<" + title + attr + ">\n" + text + "\n" + "</" + title + ">\n"; } else { StringBuffer buff = new StringBuffer(); buff.append("<" + title + attr + ">\n"); if (!text.isEmpty()) { buff.append(text + "\n"); } for (Node n : childNodes) { buff.append(n.toString()); } buff.append("</" + title + ">\n"); return buff.toString(); } }} |
二、创建接口
把文档的读取和分析抽象成接口方便今后替换实现。
过滤器：读取文档的字符流并删除注释的部分。这些信息通常是提供给人阅读的，程序分析直接忽略。
XmlFilter.java：
|
1
2
3
4
5
6
7
8
9
|
/* * 过滤器的作用是删除xml文件中不重要的部分。 * 通常都是一些注释性文字，不需要被机器解析。 */public interface XmlFilter { String filter(); // 提供自定义正则表达式，识别符合过滤条件的字符串 String filter(String[] regex);} |
解析器：将一个父节点解析成多条子节点的字符串。如果返回值为null，代表当前节点下不存在可以继续解析的对象。
XmlParser.java：
|
1
2
3
4
5
6
7
8
9
|
import java.util.List;/* * 解析器可以对一段完整的父节点字符串提供解析服务。 * 将一条父节点的字符串解析成为多条子节点字符串 */public interface XmlParser { // 解析一段父节点，返回子节点字符串 List<String> parser(String str);} |
三、根据接口编写实现类
回车、换行、制表符以及各种注释部分的内容都被删除，简化字符输出。
SimpleXmlFilter.java：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
import java.io.BufferedReader;import java.io.File;import java.io.FileNotFoundException;import java.io.FileReader;import java.io.IOException;public class SimpleXmlFilter implements XmlFilter { private String text; // 常用的过滤正则表达式 public final static String[] REG = { "\t", "<\\?.*?\\?>", "<!.*?>", "<%.*?%>", "\\s{2,}" }; // 读取xml文档返回字符串 public SimpleXmlFilter(File file) throws IOException { BufferedReader in = new BufferedReader(new FileReader(file)); StringBuffer buff = new StringBuffer(); String temp = null; while ((temp = in.readLine()) != null) { buff.append(temp); } in.close(); text = buff.toString().trim(); } @Override public String filter() { return filter(REG); } @Override public String filter(String[] regex) { String result = text; for (String reg : regex) { result = result.replaceAll(reg, ""); } return result; }} |
主要是通过正则表达式区分一个节点内部的子节点，考虑到节点的类型我将它们分为自闭合与非自闭合两种类型。<title attributes .../>这样的节点属于自闭合类型，它们不包含子节点和text属性，它们属于文档树的叶子节点。<title attributes ...>text ...</title>这样的节点属于非自闭合类型，它们属于文档树的分支节点。
SimpleXmlParser.java：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
import java.util.ArrayList;import java.util.List;import java.util.regex.Matcher;import java.util.regex.Pattern;public class SimpleXmlParser implements XmlParser { @Override public List<String> parser(String text) { List<String> childrenDocs = new ArrayList<String>(); // 捕获根节点中间的文本 Pattern p = Pattern.compile("<.*?>(.*)</.*?>"); Matcher m = p.matcher(text); if (m.matches()) { String inner = m.group(1); // 匹配节点字符串 p = Pattern.compile("<(.*?)>"); m = p.matcher(inner); while (m.find()) { String s1 = m.group(1); // 如果节点以/结尾，代表此节点不包含子节点 if (s1.endsWith("/")) { childrenDocs.add(m.group()); // 如果节点既不以/开头，也不以/结尾则表示需要查找对应的闭合节点 } else if (!s1.startsWith("/") && !s1.endsWith("/")) { // 计算起始字符数 int start = m.end() - m.group().length(); // 如果捕获到未闭合节点则index++，如果捕获到闭合节点则index-- int index = 1; while (m.find()) { String s2 = m.group(1); if (!s2.startsWith("/") && !s2.endsWith("/")) { index++; } else if (s2.startsWith("/")) { index--; } // 找到符合条件的闭合节点则循环终止 if (index == 0) { break; } } // 计算结束字符数 int end = m.end(); // 截取对应字符串 childrenDocs.add(inner.substring(start, end)); } } } return childrenDocs; }} |
四、编写NodeBuilder类
根据过滤器和解析器获取Node节点各属性的值。
NodeBuilder.java：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
|
import java.io.File;import java.io.IOException;import java.util.List;import java.util.regex.Matcher;import java.util.regex.Pattern;// 生成Nodepublic class NodeBuilder { private Node root = new Node(); private XmlParser parser; private XmlFilter filter; // 提供合适的过滤器和解析器 public NodeBuilder(XmlParser parser, XmlFilter filter) { this.parser = parser; this.filter = filter; } public Node getRoot(String... regex) { String str = null; if (regex.length == 0) { str = filter.filter(); } else { str = filter.filter(regex); } buildNodeTree(str, root); return root; } // 设置节点类型 private void buildNodeTitle(String str, Node n) { Pattern p = Pattern.compile("<.*?>"); Matcher m = p.matcher(str); if (m.find()) { String temp = m.group(); String s = temp.substring(1, temp.length() - 1).split(" ")[0]; if (s.endsWith("/")) { n.setTitle(s.substring(0, s.length() - 1)); } else { n.setTitle(s.split(" ")[0]); } } } // 设置节点属性集合 private void buildNodeAttribute(String str, Node n) { Pattern p = Pattern.compile("<.*?>"); Matcher m = p.matcher(str); if (m.find()) { String temp = m.group(); String s = temp.substring(1, temp.length() - 1); // 匹配字符串 p = Pattern.compile("(\\S*)=\"(.*?)\""); m = p.matcher(s); while (m.find()) { String key = m.group(1).trim(); String value = m.group(2).trim(); n.getAttribute().put(key, value); } // 匹配数字 p = Pattern.compile("(\\S*)=(-?\\d+(\\.\\d+)?)"); m = p.matcher(s); while (m.find()) { String key = m.group(1).trim(); String value = m.group(2).trim(); n.getAttribute().put(key, value); } } } // 设置节点内容,节点的内容是删除了所有子节点字符串以后剩下的部分 private void buildNodeText(String str, Node n) { Pattern p = Pattern.compile("<.*?>(.*)</.*?>"); Matcher m = p.matcher(str); List<String> childrenDocs = parser.parser(str); if (m.find()) { String temp = m.group(1); for (String s : childrenDocs) { temp = temp.replaceAll(s, ""); } n.setText(temp.trim()); } } // 通过递归生成完整节点树 private void buildNodeTree(String str, Node n) { buildNodeTitle(str, n); buildNodeAttribute(str, n); buildNodeText(str, n); // 如果存在子节点则继续下面的操作 if (!parser.parser(str).isEmpty()) { // 对每一个子节点都应该继续调用直到递归结束 for (String temp : parser.parser(str)) { Node child = new Node(); buildNodeTitle(temp, child); buildNodeAttribute(temp, child); buildNodeText(temp, child); n.getChildNode().add(child); buildNodeTree(temp, child); } } }} |
五、测试
编写xml测试文件
测试文件：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
<package> <!-- 这里是注释1 --> package message before! <class id="exp1" path="www.sina.com"/> <class id="exp2"> <class id="inner"> class message inner. </class> </class> package message middle! <!-- 这里是注释2 --> <class id="exp3"> <method id="md" name="setter" order=1> <!-- 这里是注释3 --> <!-- 这里是注释4 --> <para ref="String"/> <para ref="exp1"> method message inner! </para> </method> </class> package message after!</package> |
编写测试类
Demo.java：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
import java.io.File;import java.io.IOException;public class Demo { public static void main(String[] args) { File f = new File("xxx"); XmlFilter filter = null; try { filter = new SimpleXmlFilter(f); } catch (IOException e) { e.printStackTrace(); } XmlParser parser = new SimpleXmlParser(); NodeBuilder builder = new NodeBuilder(parser, filter); Node node = builder.getRoot(); System.out.println(node); }} |
输出：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
<package>package message before!package message middle!package message after!<class path="www.sina.com" id="exp1"/><class id="exp2"><class id="inner">class message inner.</class></class><class id="exp3"><method name="setter" id="md" order="1"><para ref="String"/><para ref="exp1">method message inner!</para></method></class></package> |
希望本文所述对大家java程序设计有所帮助。
原文链接：http://www.cnblogs.com/learnhow/p/5217450.html
