java解析xml的几种方式

第⼀种：DOM。

DOM的全称是Document Object Model，也即⽂档对象模型。在应⽤程序中，基于DOM的XML分析器将⼀个XML⽂档转换成⼀个对象模型的集合（通常称DOM树），应⽤程序正是通过 对这个对象模型的操作，来实现对XML⽂档数据的操作。通过DOM接⼝，应⽤程序可以在任何时候访问XML⽂档中的任何⼀部分数据，因此，这种利⽤DOM 接⼝的机制也被称作随机访问机制。

DOM接⼝提供了⼀种通过分层对象模型来访问XML⽂档信息的⽅式，这些分层对象模型依据XML的⽂档 结构形成了⼀棵节点树。⽆论XML⽂档中所描述的是什么类型的信息，即便是制表数据、项⽬列表或⼀个⽂档，利⽤DOM所⽣成的模型都是节点树的形式。也就 是说，DOM强制使⽤树模型来访问XML⽂档中的信息。由于XML本质上就是⼀种分层结构，所以这种描述⽅法是相当有效的。

DOM树所提 供的随机访问⽅式给应⽤程序的开发带来了很⼤的灵活性，它可以任意地控制整个XML⽂档中的内容。然⽽，由于DOM分析器把整个XML⽂档转化成DOM树 放在了内存中，因此，当⽂档⽐较⼤或者结构⽐较复杂时，对内存的需求就⽐较⾼。⽽且，对于结构复杂的树的遍历也是⼀项耗时的操作。所以，DOM分析器对机 器性能的要求⽐较⾼，实现效率不⼗分理想。不过，由于DOM分析器所采⽤的树结构的思想与XML⽂档的结构相吻合，同时鉴于随机访问所带来的⽅便，因此，DOM分析器还是有很⼴泛的使⽤价值的。

Java代码

1. import java.io.File; 2.

3. import javax.xml.parsers.DocumentBuilder;

4. import javax.xml.parsers.DocumentBuilderFactory; 5.

6. import org.w3c.dom.Document; 7. import org.w3c.dom.Element; 8. import org.w3c.dom.NodeList; 9.

10. public class DomTest1 11. {

12. public static void main(String[] args) throws Exception 13. {

14. // step 1: 获得dom解析器⼯⼚（⼯作的作⽤是⽤于创建具体的解析器） 15. DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); 16.

17. // System.out.println(\"class name: \" + dbf.getClass().getName()); 18.

19. // step 2:获得具体的dom解析器

20. DocumentBuilder db = dbf.newDocumentBuilder(); 21.

22. // System.out.println(\"class name: \" + db.getClass().getName()); 23.

24. // step3: 解析⼀个xml⽂档，获得Document对象（根结点） 25. Document document = db.parse(new File(\"candidate.xml\")); 26.

27. NodeList list = document.getElementsByTagName(\"PERSON\"); 28.

29. for(int i = 0; i < list.getLength(); i++) 30. {

31. Element element = (Element)list.item(i); 32.

33. String content = element.getElementsByTagName(\"NAME\").item(0).getFirstChild().getNodeValue(); 34.

35. System.out.println(\"name:\" + content); 36.

37. content = element.getElementsByTagName(\"ADDRESS\").item(0).getFirstChild().getNodeValue(); 38.

39. System.out.println(\"address:\" + content); 40.

41. content = element.getElementsByTagName(\"TEL\").item(0).getFirstChild().getNodeValue(); 42.

43. System.out.println(\"tel:\" + content); 44.

45. content = element.getElementsByTagName(\"FAX\").item(0).getFirstChild().getNodeValue(); 46.

47. System.out.println(\"fax:\" + content); 48.

49. content = element.getElementsByTagName(\"EMAIL\").item(0).getFirstChild().getNodeValue(); 50.

51. System.out.println(\"email:\" + content); 52.

53. System.out.println(\"--------------------------------------\"); 54. } 55. } 56. }

Java代码

1. import java.io.File; 2.

3. import javax.xml.parsers.DocumentBuilder;

4. import javax.xml.parsers.DocumentBuilderFactory; 5.

6. import org.w3c.dom.Attr;

7. import org.w3c.dom.Comment; 8. import org.w3c.dom.Document; 9. import org.w3c.dom.Element;

10. import org.w3c.dom.NamedNodeMap; 11. import org.w3c.dom.Node; 12. import org.w3c.dom.NodeList; 13. 14. /**

15. * 使⽤递归解析给定的任意⼀个xml⽂档并且将其内容输出到命令⾏上 16. * @author zhanglong 17. * 18. */

19. public class DomTest3 20. {

21. public static void main(String[] args) throws Exception 22. {

23. DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); 24. DocumentBuilder db = dbf.newDocumentBuilder(); 25.

26. Document doc = db.parse(new File(\"student.xml\")); 27. //获得根元素结点

28. Element root = doc.getDocumentElement(); 29.

30. parseElement(root); 31. } 32.

33. private static void parseElement(Element element) 34. {

35. String tagName = element.getNodeName(); 36.

37. NodeList children = element.getChildNodes(); 38.

39. System.out.print(\"<\" + tagName); 40.

41. //element元素的所有属性所构成的NamedNodeMap对象，需要对其进⾏判断 42. NamedNodeMap map = element.getAttributes(); 43.

44. //如果该元素存在属性 45. if(null != map) 46. {

47. for(int i = 0; i < map.getLength(); i++) 48. {

49. //获得该元素的每⼀个属性 50. Attr attr = (Attr)map.item(i); 51.

52. String attrName = attr.getName(); 53. String attrValue = attr.getValue();

54.

55. System.out.print(\" \" + attrName + \"=\\\"\" + attrValue + \"\\\"\"); 56. } 57. } 58.

59. System.out.print(\">\"); 60.

61. for(int i = 0; i < children.getLength(); i++) 62. {

63. Node node = children.item(i); 64. //获得结点的类型

65. short nodeType = node.getNodeType(); 66.

67. if(nodeType == Node.ELEMENT_NODE) 68. {

69. //是元素，继续递归

70. parseElement((Element)node); 71. }

72. else if(nodeType == Node.TEXT_NODE) 73. {

74. //递归出⼝

75. System.out.print(node.getNodeValue()); 76. }

77. else if(nodeType == Node.COMMENT_NODE) 78. {

79. System.out.print(\"\"); 89. } 90. } 91.

92. System.out.print(\"\"); 93. } 94. }

sax：SAX的全称是Simple APIs for XML，也即XML简单应⽤程序接⼝。与DOM不同，SAX提供的访问模式是⼀种顺序模式，这是⼀种快速读写XML数据的⽅式。当使⽤SAX分析器对 XML⽂档进⾏分析时，会触发⼀系列事件，并激活相应的事件处理函数，应⽤程序通过这些事件处理函数实现对XML⽂档的访问，因⽽SAX接⼝也被称作事件 驱动接⼝。

Java代码

1. import java.io.File; 2.

3. import javax.xml.parsers.SAXParser;

4. import javax.xml.parsers.SAXParserFactory; 5.

6. import org.xml.sax.Attributes;

7. import org.xml.sax.SAXException;

8. import org.xml.sax.helpers.DefaultHandler; 9.

10. public class SaxTest1 11. {

12. public static void main(String[] args) throws Exception 13. {

14. //step1： 获得SAX解析器⼯⼚实例

15. SAXParserFactory factory = SAXParserFactory.newInstance(); 16.

17. //step2: 获得SAX解析器实例

18. SAXParser parser = factory.newSAXParser(); 19.

20. //step3: 开始进⾏解析

21. parser.parse(new File(\"student.xml\"), new MyHandler()); 22. 23. } 24. } 25.

26. class MyHandler extends DefaultHandler 27. {

28. @Override

29. public void startDocument() throws SAXException 30. {

31. System.out.println(\"parse began\"); 32. } 33.

34. @Override

35. public void endDocument() throws SAXException 36. {

37. System.out.println(\"parse finished\"); 38. } 39.

40. @Override

41. public void startElement(String uri, String localName, String qName, 42. Attributes attributes) throws SAXException 43. {

44. System.out.println(\"start element\"); 45. } 46.

47. @Override

48. public void endElement(String uri, String localName, String qName) 49. throws SAXException 50. {

51. System.out.println(\"finish element\"); 52. } 53. }

Java代码

1. import java.io.File; 2. import java.util.Stack; 3.

4. import javax.xml.parsers.SAXParser;

5. import javax.xml.parsers.SAXParserFactory; 6.

7. import org.xml.sax.Attributes;

8. import org.xml.sax.SAXException;

9. import org.xml.sax.helpers.DefaultHandler; 10.

11. public class SaxTest2 12. {

13. public static void main(String[] args) throws Exception 14. {

15. SAXParserFactory factory = SAXParserFactory.newInstance(); 16.

17. SAXParser parser = factory.newSAXParser(); 18.

19. parser.parse(new File(\"student.xml\"), new MyHandler2()); 20. }

21. } 22.

23. class MyHandler2 extends DefaultHandler 24. {

25. private Stack stack = new Stack(); 26.

27. private String name; 28.

29. private String gender; 30.

31. private String age; 32.

33. @Override

34. public void startElement(String uri, String localName, String qName, 35. Attributes attributes) throws SAXException 36. {

37. stack.push(qName); 38.

39. for(int i = 0; i < attributes.getLength(); i++) 40. {

41. String attrName = attributes.getQName(i); 42. String attrValue = attributes.getValue(i); 43.

44. System.out.println(attrName + \"=\" + attrValue); 45. } 46. } 47.

48. @Override

49. public void characters(char[] ch, int start, int length) 50. throws SAXException 51. {

52. String tag = stack.peek(); 53.

54. if(\"姓名\".equals(tag)) 55. {

56. name = new String(ch, start,length); 57. }

58. else if(\"性别\".equals(tag)) 59. {

60. gender = new String(ch, start, length); 61. }

62. else if(\"年龄\".equals(tag)) 63. {

64. age = new String(ch, start, length); 65. } 66. } 67.

68. @Override

69. public void endElement(String uri, String localName, String qName) 70. throws SAXException 71. {

72. stack.pop(); //表⽰该元素已经解析完毕，需要从栈中弹出 73.

74. if(\"学⽣\".equals(qName)) 75. {

76. System.out.println(\"姓名：\" + name); 77. System.out.println(\"性别：\" + gender); 78. System.out.println(\"年龄：\" + age); 79.

80. System.out.println(); 81. } 82. 83. } 84. } JDOM:

•JDOM 直接为JAVA编程服务。它利⽤更为强有⼒的JAVA语⾔的诸多特性（⽅法重载、集合概念等），把SAX和DOM的功能有效地结合起来。

•JDOM是⽤Java语⾔读、写、操作XML的新API函数。在直接、简单和⾼效的前提下，这些API函数被最⼤限度的优化。

jdom创建xml

Java代码

1. import java.io.FileWriter; 2.

3. import org.jdom.Attribute; 4. import org.jdom.Comment; 5. import org.jdom.Document; 6. import org.jdom.Element;

7. import org.jdom.output.Format;

8. import org.jdom.output.XMLOutputter; 9.

10. public class JDomTest1 11. {

12. public static void main(String[] args) throws Exception 13. {

14. Document document = new Document(); 15.

16. Element root = new Element(\"root\"); 17.

18. document.addContent(root); 19.

20. Comment comment = new Comment(\"This is my comments\"); 21.

22. root.addContent(comment); 23.

24. Element e = new Element(\"hello\"); 25.

26. e.setAttribute(\"sohu\27.

28. root.addContent(e); 29.

30. Element e2 = new Element(\"world\"); 31.

32. Attribute attr = new Attribute(\"test\33.

34. e2.setAttribute(attr); 35.

36. e.addContent(e2); 37.

38. e2.addContent(new Element(\"aaa\").setAttribute(\"a\

39. .setAttribute(\"x\40. 41.

42. Format format = Format.getPrettyFormat(); 43.

44. format.setIndent(\" \");

45. // format.setEncoding(\"gbk\"); 46.

47. XMLOutputter out = new XMLOutputter(format); 48.

49. out.output(document, new FileWriter(\"jdom.xml\")); 50. 51. } 52. }

JDOM解析xml

Java代码

1. import java.io.File;

2. import java.io.FileOutputStream; 3. import java.util.List; 4.

5. import org.jdom.Attribute; 6. import org.jdom.Document; 7. import org.jdom.Element;

8. import org.jdom.input.SAXBuilder; 9. import org.jdom.output.Format;

10. import org.jdom.output.XMLOutputter; 11.

12. public class JDomTest2 13. {

14. public static void main(String[] args) throws Exception 15. {

16. SAXBuilder builder = new SAXBuilder(); 17.

18. Document doc = builder.build(new File(\"jdom.xml\")); 19.

20. Element element = doc.getRootElement(); 21.

22. System.out.println(element.getName()); 23.

24. Element hello = element.getChild(\"hello\"); 25.

26. System.out.println(hello.getText()); 27.

28. List list = hello.getAttributes(); 29.

30. for(int i = 0 ;i < list.size(); i++) 31. {

32. Attribute attr = (Attribute)list.get(i); 33.

34. String attrName = attr.getName(); 35. String attrValue = attr.getValue(); 36.

37. System.out.println(attrName + \"=\" + attrValue); 38. } 39.

40. hello.removeChild(\"world\"); 41.

42. XMLOutputter out = new XMLOutputter(Format.getPrettyFormat().setIndent(\" \")); 43. 44.

45. out.output(doc, new FileOutputStream(\"jdom2.xml\")); 46. 47. } 48. } Dom4j

Java代码

1. import java.io.FileOutputStream;

2. import java.io.FileWriter; 3.

4. import org.dom4j.Document;

5. import org.dom4j.DocumentHelper; 6. import org.dom4j.Element;

7. import org.dom4j.io.OutputFormat; 8. import org.dom4j.io.XMLWriter; 9.

10. public class Test1 11. {

12. public static void main(String[] args) throws Exception 13. {

14. // 创建⽂档并设置⽂档的根元素节点 ：第⼀种⽅式

15. // Document document = DocumentHelper.createDocument(); 16. //

17. // Element root = DocumentHelper.createElement(\"student\"); 18. //

19. // document.setRootElement(root); 20.

21. // 创建⽂档并设置⽂档的根元素节点 ：第⼆种⽅式

22. Element root = DocumentHelper.createElement(\"student\");

23. Document document = DocumentHelper.createDocument(root); 24.

25. root.addAttribute(\"name\26.

27. Element helloElement = root.addElement(\"hello\"); 28. Element worldElement = root.addElement(\"world\"); 29.

30. helloElement.setText(\"hello\"); 31. worldElement.setText(\"world\"); 32.

33. helloElement.addAttribute(\"age\34.

35. XMLWriter xmlWriter = new XMLWriter(); 36. xmlWriter.write(document); 37.

38. OutputFormat format = new OutputFormat(\" \39.

40. XMLWriter xmlWriter2 = new XMLWriter(new FileOutputStream(\"student2.xml\"), format); 41. xmlWriter2.write(document); 42.

43. XMLWriter xmlWriter3 = new XMLWriter(new FileWriter(\"student3.xml\"), format); 44.

45. xmlWriter3.write(document); 46. xmlWriter3.close(); 47. 48. } 49. }

Java代码

1. import java.io.File; 2. import java.util.Iterator; 3. import java.util.List; 4.

5. import javax.xml.parsers.DocumentBuilder;

6. import javax.xml.parsers.DocumentBuilderFactory; 7.

8. import org.dom4j.Document; 9. import org.dom4j.Element;

10. import org.dom4j.io.DOMReader; 11. import org.dom4j.io.SAXReader; 12.

13. public class Test2 14. {

15. public static void main(String[] args) throws Exception 16. {

17. SAXReader saxReader = new SAXReader(); 18.

19. Document doc = saxReader.read(new File(\"student2.xml\")); 20.

21. Element root = doc.getRootElement(); 22.

23. System.out.println(\"root element: \" + root.getName()); 24.

25. List childList = root.elements(); 26.

27. System.out.println(childList.size()); 28.

29. List childList2 = root.elements(\"hello\"); 30.

31. System.out.println(childList2.size()); 32.

33. Element first = root.element(\"hello\"); 34.

35. System.out.println(first.attributeValue(\"age\")); 36.

37. for(Iterator iter = root.elementIterator(); iter.hasNext();) 38. {

39. Element e = (Element)iter.next(); 40.

41. System.out.println(e.attributeValue(\"age\")); 42. } 43.

44. System.out.println(\"---------------------------\"); 45.

46. DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); 47. DocumentBuilder db = dbf.newDocumentBuilder();

48. org.w3c.dom.Document document = db.parse(new File(\"student2.xml\")); 49.

50. DOMReader domReader = new DOMReader(); 51.

52. //将JAXP的Document转换为dom4j的Document 53. Document d = domReader.read(document); 54.

55. Element rootElement = d.getRootElement(); 56.

57. System.out.println(rootElement.getName()); 58. 59. } 60. }

Java代码

1. import java.io.FileWriter; 2.

3. import org.jdom.Attribute; 4. import org.jdom.Document; 5. import org.jdom.Element;

6. import org.jdom.output.Format;

7. import org.jdom.output.XMLOutputter; 8.

9. public class Test3 10. {

11. public static void main(String[] args) throws Exception 12. {

13. Document document = new Document(); 14.

15. Element root = new Element(\"联系⼈列表\").setAttribute(new Attribute(\"公司\16. \"A集团\"));

17.

18. document.addContent(root); 19.

20. Element contactPerson = new Element(\"联系⼈\"); 21.

22. root.addContent(contactPerson); 23.

24. contactPerson

25. .addContent(new Element(\"姓名\").setText(\"张三\")) 26. .addContent(new Element(\"公司\").setText(\"A公司\"))

27. .addContent(new Element(\"电话\").setText(\"021-55556666\")) 28. .addContent(

29. new Element(\"地址\")

30. .addContent(new Element(\"街道\").setText(\"5街\")) 31. .addContent(new Element(\"城市\").setText(\"上海\")) 32. .addContent(new Element(\"省份\").setText(\"上海市\"))); 33.

34. XMLOutputter output = new XMLOutputter(Format.getPrettyFormat() 35. .setIndent(\" \").setEncoding(\"gbk\")); 36.

37. output.output(document, new FileWriter(\"contact.xml\")); 38. 39. } 40. }