2. 程式人生 > >org.w3c.dom 解析XML檔案 可以解析出節點屬性

org.w3c.dom 解析XML檔案 可以解析出節點屬性

阿新 • • 發佈：2019-02-10

xml檔案如下：

  1. <smilxmlns="http://www.w3.org/2000/SMIL20/CR/Language">
  2. <head>
  3. <layout>
  4. <root-layoutheight="100%"width="100%"/>
  5. <regionid="Image"top="0"left="0"height="80%"width="100%"/>
  6. <regionid="Text"top="80%"left="0"height="20%"width="100%"/>
  7. </layout>
  8. </head>
  9. <body>
  10. <pardur
     = "5000ms">
  11. <imgregion="Image"src="/contentlib/32/35/92/52.jpg"/>
  12. <audiosrc="/contentlib/32/36/58.wav"/>
  13. <textregion="Text"src="/contentlib/1/3/29/12.txt"/>
  14. </par>
  15. </body>
  16. </smil>

要解析出xml檔案節點屬性，比如 要得出 節點<img region="Image" src="/contentlib/32/35/92/52.jpg"/> 屬性src的值（/contentlib/32/35/92/52.jpg）。

下面是原始碼，可以直接解析xml檔案 ，和檔案流。

可以得到節點值，節點屬性值，（如果存在多個<img  下面程式碼還存在問題）

  1. import java.io.InputStream;
  2. import java.io.IOException;
  3. import java.util.ArrayList;
  4. import javax.xml.parsers.DocumentBuilderFactory;
  5. import javax.xml.parsers.DocumentBuilder;
  6. import javax.xml.parsers.ParserConfigurationException;
  7. import javax.xml.parsers.FactoryConfigurationError;
  8. import org.w3c.dom.Document;
  9. import org.w3c.dom.Element;
  10. import org.w3c.dom.NamedNodeMap;
  11. import org.w3c.dom.NodeList;
  12. import org.w3c.dom.Node;
  13. import org.xml.sax.SAXException;
  14. /**
  15.  * <p>Description:  xml解析類</p>
  16.  *
  17.  */
  18. publicclass XmlParser
  19. {
  20. privatestatic DocumentBuilderFactory factory;
  21. privatestatic DocumentBuilder builder;
  22. private Document doc;
  23. private Element root;
  24. private String fileName;
  25. private InputStream inputstream;
  26. /**
  27.      * 解析檔案xml
  28.      * @param file String
  29.      */
  30. public XmlParser(String file)
  31.     {
  32. if (file == null)
  33.         {
  34. return;
  35.         }
  36. this.fileName = file;
  37. try
  38.         {
  39.             load();
  40.         }
  41. catch (IOException ex)
  42.         {
  43.             ex.printStackTrace();
  44. return;
  45.         }
  46.     }
  47. /**
  48.      * 解析輸入流xml
  49.      * @param input InputStream
  50.      */
  51. public XmlParser(InputStream input)
  52.     {
  53. if (input == null)
  54.         {
  55. return;
  56.         }
  57.         inputstream = input;
  58. try
  59.         {
  60.             loadStream();
  61.         }
  62. catch (IOException ex)
  63.         {
  64.             ex.printStackTrace();
  65. return;
  66.         }
  67.     }
  68. /**
  69.      * 獲取XML檔案中指定標籤所對應的節點集合
  70.      * @param key String 標籤名字
  71.      * @return ArrayList 指定標籤對應的節點集
  72.      */
  73. public ArrayList findNodes(String key)
  74.     {
  75.         NodeList nodes = root.getElementsByTagName(key);
  76.         ArrayList nodeList = new ArrayList();
  77. for (int i = 0; i < nodes.getLength(); i++)
  78.         {
  79.             nodeList.add(i, (Node) nodes.item(i));
  80.         }
  81. return nodeList;
  82.     }
  83. /**
  84.      * 初始化XML
  85.      * @throws IOException
  86.      */
  87. publicvoid loadStream()
  88. throws IOException
  89.     {
  90. try
  91.         {
  92.             loadXMLParser();
  93.             doc = builder.parse(inputstream);
  94.             root = doc.getDocumentElement();
  95.         }
  96. catch (IOException ex)
  97.         {
  98.             ex.printStackTrace();
  99.         }
  100. catch (SAXException ex)
  101.         {
  102.             ex.printStackTrace();
  103.         }
  104. finally
  105.         {
  106.             inputstream.close();
  107.         }
  108.     }
  109. /**
  110.      * 初始化XML
  111.      * @throws IOException
  112.      */
  113. publicvoid load()
  114. throws IOException
  115.     {
  116. try
  117.         {
  118.             loadXMLParser();
  119.             doc = builder.parse(fileName);
  120.             root = doc.getDocumentElement();
  121.         }
  122. catch (SAXException SaxEx)
  123.         {
  124.             SaxEx.printStackTrace();
  125. thrownew IOException(SaxEx.getMessage() + "XML file parse error:"
  126.                                   + SaxEx.getException());
  127.         }
  128. catch (IOException IoEx)
  129.         {
  130.             IoEx.printStackTrace();
  131. thrownew IOException(IoEx.getMessage() + "XML file parse error:");
  132.         }
  133. catch (Exception ex)
  134.         {
  135.             ex.printStackTrace();
  136. thrownew IOException(ex.getMessage() + "XML file parse error:");
  137.         }
  138.     }
  139. /**
  140.      * 初始化XML
  141.      * @throws IOException
  142.      */
  143. privatevoid loadXMLParser()
  144. throws IOException
  145.     {
  146. if (builder == null)
  147.         {
  148. try
  149.             {
  150.                 factory = DocumentBuilderFactory.newInstance();
  151.                 builder = factory.newDocumentBuilder();
  152.             }
  153. catch (ParserConfigurationException ex)
  154.             {
  155. thrownew IOException("XML Parser load error:"
  156.                                       + ex.getLocalizedMessage());
  157.             }
  158. catch (FactoryConfigurationError ConfErrEx)
  159.             {
  160. thrownew IOException("XML Parser load error:"
  161.                                       + ConfErrEx.getLocalizedMessage());
  162.             }
  163. catch (Exception Ex)
  164.             {
  165. thrownew IOException("XML Parser load error:"
  166.                                       + Ex.getLocalizedMessage());
  167.             }
  168.         }
  169.     }
  170. /**
  171.      * 獲取XML檔案中某級節點下一級元素的值
  172.      * @param node 節點物件
  173.      * @param subTagName subTagName元素的標籤名
  174.      * @return String 該標記元素的的內容
  175.      */
  176. publicstatic String getSubTagValue(Node node, String subTagName)
  177.     {
  178.         String returnString = "";
  179. if ((node != null) && (subTagName != null))
  180.         {
  181.             NodeList children = node.getChildNodes();
  182. for (int innerLoop = 0; innerLoop < children.getLength(); innerLoop++)
  183.             {
  184.                 Node child = children.item(innerLoop);
  185. if ((child != null) && (child.getNodeName() != null)
  186.                     && (child.getNodeName().equals(subTagName)))
  187.                 {
  188.                     Node grandChild = child.getFirstChild();
  189. if (grandChild != null)
  190.                     {
  191. return grandChild.getNodeValue();
  192.                     }
  193.                 }
  194.             }
  195.         }
  196. return returnString;
  197.     }
  198. /**
  199.      * 獲取XML檔案中某單一值
  200.      * @param node 節點物件
  201.      * @param subTagName subTagName元素的標籤名
  202.      * @return String 該標記元素的的內容
  203.      */
  204. public String getresult(String name)
  205.     {
  206.         String result = "";
  207.         ArrayList resultlist = findNodes(name);
  208. if ((resultlist != null) && (resultlist.size() > 0))
  209.         {
  210. for (int i = 0; i < resultlist.size(); i++)
  211.             {
  212.                 Node node = (Node) resultlist.get(i);
  213. if (node instanceof Element)
  214.                 {
  215. if ((node != null) && (node.getNodeName() != null)
  216.                         && (node.getNodeName().equals(name)))
  217.                     {
  218.                         Node grandChild = node.getFirstChild();
  219. if (grandChild != null)
  220.                         {
  221.                             result = grandChild.getNodeValue();
  222.                         }
  223.                     }
  224.                 }
  225.             }
  226.         }
  227. return result;
  228.     }
  229. //
  230. public String getAttr(String name,String attrName)
  231.     {
  232.         String result = "";
  233.         ArrayList resultlist = findNodes(name);
  234. if ((resultlist != null) && (resultlist.size() > 0))
  235.         {
  236. for (int i = 0; i < resultlist.size(); i++)
  237.             {
  238.                 Node node = (Node) resultlist.get(i);
  239. if (node instanceof Element)
  240.                 {
  241. if ((node != null) && (node.getNodeName() != null)
  242.                         && (node.getNodeName().equals(name)))
  243.                     {
  244. //遍歷整個xml某節點指定的屬性
  245.                         NamedNodeMap attrs=node.getAttributes();
  246. if(attrs.getLength()>0 && attrs!=null)
  247.                         {
  248.                             Node attr=attrs.getNamedItem(attrName);
  249.                             result=attr.getNodeValue();
  250.                         }
  251.                     }
  252.                 }
  253.             }
  254.         }
  255. return result;
  256.     }
  257. publicstaticvoid main(String[] args)
  258.     {
  259.         String file="D://common//Tomcat60//smil.smil";
  260.         XmlParser xml =new XmlParser(file);
  261.         System.out.println(xml.getAttr("text","src"));
  262.     }
  263. }

解決多個節點問題，，比如下面的xml檔案

  1. <smil xmlns="http://www.w3.org/2000/SMIL20/CR/Language">
  2. <head>
  3. <layout>
  4. <root-layout height="100%" width="100%" />
  5. <region id="Image" top="0" left="0" height="80%" width="100%"/>
  6. <region id="Text" top="80%" left="0" height="20%" width="100%"/>
  7. </layout>
  8. </head>
  9. <body>
  10. <par dur = "5000ms">
  11. <img region="Image" src="/contentlib/5/6/95/0.jpg"/>
  12. <audio src="/contentlib/5/6/95/0.wav"/>
  13. <text region="Text" src="/contentlib/5/6/95/0.txt"/>
  14. </par>
  15. <par dur = "5000ms">
  16. <img region="Image" src="/contentlib/5/6/95/1.gif"/>
  17. <audio src="/contentlib/5/6/95/1.wav"/>
  18. <text region="Text" src="/contentlib/5/6/95/1.txt"/>
  19. </par>
  20. <par dur = "5000ms">
  21. <img region="Image" src="/contentlib/5/6/95/2.gif"/>
  22. <audio src="/contentlib/5/6/95/2.wav"/>
  23. <text region="Text" src="/contentlib/5/6/95/2.txt"/>
  24. </par>
  25. </body>
  26. </smil>

要得出所有的src值，下面程式碼可以實現

  1. import java.io.InputStream;
  2. import java.io.IOException;
  3. import java.util.ArrayList;
  4. import java.util.LinkedList;
  5. import java.util.List;
  6. import javax.xml.parsers.DocumentBuilderFactory;
  7. import javax.xml.parsers.DocumentBuilder;
  8. import javax.xml.parsers.ParserConfigurationException;
  9. import javax.xml.parsers.FactoryConfigurationError;
  10. import org.w3c.dom.Document;
  11. import org.w3c.dom.Element;
  12. import org.w3c.dom.NamedNodeMap;
  13. import org.w3c.dom.NodeList;
  14. import org.w3c.dom.Node;
  15. import org.xml.sax.SAXException;
  16. /**
  17.  * Description:  xml解析類
  18.  * @author wayfoon
  19.  * @version 
  20.  */
  21. publicclass XmlParser
  22. {
  23. privatestatic DocumentBuilderFactory factory;
  24. privatestatic DocumentBuilder builder;
  25. private Document doc;
  26. private Element root;
  27. private String fileName;
  28. private InputStream inputstream;
  29. /**
  30.      * 解析檔案xml
  31.      * @param file
  32.      *            String
  33.      */
  34. public XmlParser(String file)
  35.     {
  36. if (file == null)
  37.         {
  38. return;
  39.         }
  40. this.fileName = file;
  41. try
  42.         {
  43.             load();
  44.         }
  45. catch (IOException ex)
  46.         {
  47.             ex.printStackTrace();
  48. return;
  49.         }
  50.     }
  51. /**
  52.      * 解析輸入流xml
  53.      * 
  54.      * @param input
  55.      *            InputStream
  56.      */
  57. public XmlParser(InputStream input)
  58.     {
  59. if (input == null)
  60.         {
  61. return;
  62.         }
  63.         inputstream = input;
  64. try
  65.         {
  66.             loadStream();
  67.         }
  68. catch (IOException ex)
  69.         {
  70.             ex.printStackTrace();
  71. return;
  72.         }
  73.     }
  74. /**
  75.      * 獲取XML檔案中指定標籤所對應的節點集合
  76.      * 
  77.      * @param key
  78.      *            String 標籤名字
  79.      * @return ArrayList 指定標籤對應的節點集
  80.      */
  81. public ArrayList findNodes(String key)
  82.     {
  83.         NodeList nodes = root.getElementsByTagName(key);
  84.         ArrayList nodeList = new ArrayList();
  85. for (int i = 0; i < nodes.getLength(); i++)
  86.         {
  87.             nodeList.add(i, (Node) nodes.item(i));
  88.         }
  89. return nodeList;
  90.     }
  91. /**
  92.      * 初始化XML
  93.      * 
  94.      * @throws IOException
  95.      */
  96. publicvoid loadStream() throws IOException
  97.     {
  98. try
  99.         {
  100.             loadXMLParser();
  101.             doc = builder.parse(inputstream);
  102.             root = doc.getDocumentElement();
  103.         }
  104. catch (IOException ex)
  105.         {
  106.             ex.printStackTrace();
  107.         }
  108. catch (SAXException ex)
  109.         {
  110.             ex.printStackTrace();
  111.         }
  112. finally
  113.         {
  114.             inputstream.close();
  115.         }
  116.     }
  117. /**
  118.      * 初始化XML
  119.      * 
  120.      * @throws IOException
  121.      */
  122. publicvoid load() throws IOException
  123.     {
  124. try
  125.         {
  126.             loadXMLParser();
  127.             doc = builder.parse(fileName);
  128.             root = doc.getDocumentElement();
  129.         }
  130. catch (SAXException SaxEx)
  131.         {
  132.             SaxEx.printStackTrace();
  133. thrownew IOException(SaxEx.getMessage() + "XML file parse error:"
  134.                     + SaxEx.getException());
  135.         }
  136. catch (IOException IoEx)
  137.         {
  138.             IoEx.printStackTrace();
  139. thrownew IOException(IoEx.getMessage() + "XML file parse error:");
  140.         }
  141. catch (Exception ex)
  142.         {
  143.             ex.printStackTrace();
  144. thrownew IOException(ex.getMessage() + "XML file parse error:");
  145.         }
  146.     }
  147. /**
  148.      * 初始化XML
  149.      * 
  150.      * @throws IOException
  151.      */
  152. privatevoid loadXMLParser() throws IOException
  153.     {
  154. if (builder == null)
  155.         {
  156. try
  157.             {
  158.                 factory = DocumentBuilderFactory.newInstance();
  159.                 builder = factory.newDocumentBuilder();
  160.             }
  161. catch (ParserConfigurationException ex)
  162.             {
  163. thrownew IOException("XML Parser load error:"
  164.                         + ex.getLocalizedMessage());
  165.             }
  166. catch (FactoryConfigurationError ConfErrEx)
  167.             {
  168. thrownew IOException("XML Parser load error:"
  169.                         + ConfErrEx.getLocalizedMessage());
  170.             }
  171. catch (Exception Ex)
  172.             {
  173. thrownew IOException("XML Parser load error:"
  174.                         + Ex.getLocalizedMessage());
  175.             }
  176.         }
  177.     }
  178. /**
  179.      * 獲取XML檔案中某級節點下一級元素的值
  180.      * 
  181.      * @param node
  182.      *            節點物件
  183.      * @param subTagName
  184.      *            subTagName元素的標籤名
  185.      * @return String 該標記元素的的內容
  186.      */
  187. publicstatic String getSubTagValue(Node node, String subTagName)
  188.     {
  189.         String returnString = "";
  190. if ((node != null) && (subTagName != null))
  191.         {
  192.             NodeList children = node.getChildNodes();
  193. for (int innerLoop = 0; innerLoop < children.getLength(); innerLoop++)
  194.             {
  195.                 Node child = children.item(innerLoop);
  196. if ((child != null) && (child.getNodeName() != null)
  197.                         && (child.getNodeName().equals(subTagName)))
  198.                 {
  199.                     Node grandChild = child.getFirstChild();
  200. if (grandChild != null)
  201.                     {
  202. return grandChild.getNodeValue();
  203.                     }
  204.                 }
  205.             }
  206.         }
  207. return returnString;
  208.     }
  209. /**
  210.      * 獲取XML檔案中某單一值
  211.      * 
  212.      * @param node
  213.      *            節點物件
  214.      * @param subTagName
  215.      *            subTagName元素的標籤名
  216.      * @return String 該標記元素的的內容
  217.      */
  218. public String getresult(String name)
  219.     {
  220.         String result = "";
  221.         ArrayList resultlist = findNodes(name);
  222. if ((resultlist != null) && (resultlist.size() > 0))
  223.         {
  224. for (int i = 0; i < resultlist.size(); i++)
  225.             {
  226.                 Node node = (Node) resultlist.get(i);
  227. if (node instanceof Element)
  228.                 {
  229. if ((node != null) && (node.getNodeName() != null)
  230.                             && (node.getNodeName().equals(name)))
  231.                     {
  232.                         Node grandChild = node.getFirstChild();
  233. if (grandChild != null)
  234.                         {
  235.                             result = grandChild.getNodeValue();
  236.                         }
  237.                     }
  238.                 }
  239.             }
  240.         }
  241. return result;
  242.     }
  243. /**
  244.      * 得到某一節點指定屬性的值
  245.      * @param node
  246.      * @param name
  247.      * @param attrName
  248.      * @return
  249.      */
  250. public String getAttrByNode(Node node, String name, String attrName)
  251.     {
  252.         NodeList list = node.getChildNodes();
  253. // System.out.println("---"+list.getLength());
  254.         String result = "";
  255.         Node child = null;
  256. for (int innerLoop = 0; innerLoop < list.getLength(); innerLoop++)
  257.         {
  258.             child = list.item(innerLoop);
  259. if (child instanceof Element)
  260.             {
  261. if ((child != null) && (child.getNodeName() != null)
  262.                         && (child.getNodeName().equals(name)))
  263.                 {
  264. // 遍歷整個xml某節點指定的屬性
  265.                     NamedNodeMap attrs = child.getAttributes();
  266. if (attrs.getLength() > 0 && attrs != null)
  267.                     {
  268.                         Node attr = attrs.getNamedItem(attrName);
  269.                         result = attr.getNodeValue();
  270.                     }
  271.                 }
  272.             }
  273.         }
  274. return result;
  275.     }
  276. /**
  277.      * 得到節點屬性值，節點可能存在多個，返回的是個陣列
  278.      * 
  279.      * @param name
  280.      * @param attrName
  281.      * @return
  282.      */
  283. public String[] getAttr(String name, String attrName)
  284.     {
  285. int len = 0;
  286.         String result[] = new String[] {};
  287.         ArrayList resultlist = findNodes(name);
  288. if ((resultlist != null) && (resultlist.size() > 0))
  289.         {
  290.             result = new String[resultlist.size() * 3];
  291. for (int i = 0; i < resultlist.size(); i++)
  292.             {
  293.                 Node node = (Node) resultlist.get(i);
  294. if (node instanceof Element)
  295.                 {
  296. if ((node != null) && (node.getNodeName() != null)
  297.                             && (node.getNodeName().equals(name)))
  298.                     {
  299.                         String img = getAttrByNode(node, "img", "src");
  300.                         String audio = getAttrByNode(node, "audio", "src");
  301.                         String text = getAttrByNode(node, "text", "src");
  302. if (!"".equals(img) && img != null)
  303.                         {
  304.                             result[len++] = img;
  305.                         }
  306. else
  307.                         {
  308.                             result[len++] = "";
  309.                         }
  310. if (!"".equals(audio) && audio != null)
  311.                         {
  312.                             result[len++] = audio;
  313.                         }
  314. else
  315.                         {
  316.                             result[len++] = "";
  317.                         }
  318. if (!"".equals(text) && text != null)
  319.                         {
  320.                             result[len++] = text;
  321.                         }
  322. else
  323.                         {
  324.                             result[len++] = "";
  325.                         }
  326. // System.out.println(result[len]);
  327.                     }
  328.                 }
  329.             }
  330.         }
  331. //System.out.println(result.length);
  332. return result;
  333.     }
  334. publicstaticvoid main(String[] args)
  335.     {
  336.         String file = "D://**//smil.smil";
  337.         XmlParser xml = new XmlParser(file);
  338. // XmlParser xml1 =new XmlParser(file1);
  339.         String[] strings = xml.getAttr("par", "dur");
  340. for (int i = 0; i < strings.length; i++)
  341.         {
  342.             System.out.println(strings[i]);
  343.         }
  344.     }
  345. }

輸入結果：就是我們想得到的

相關推薦

使用org.w3c.dom.*進行XML檔案的解析和建立（包括Cdata的解析）

最近在專案中使用org.w3c.dom對xml檔案進行解析，該包對於較小的xml檔案的操作非常簡便，推薦大家在使用。 首先，對於org.w3c.dom.*的包，我們不需要額外去進行引用，在jdk1.6自帶的rt.jar中就包涵該包。 public viod getXMLNo

org.w3c.dom 解析XML檔案 可以解析出節點屬性

xml檔案如下： <smilxmlns="http://www.w3.org/2000/SMIL20/CR/Language"> <head> <layout> <root-layoutheight="100%"width="100%

Java解析HTML到org.w3c.dom.Document，再把Document輸出到檔案。

Document doc = parser.parseHtml(url, httpBody, entryPageUrl, docType); try {

Java:簡單的解析XML檔案之使用DOM解析

XML簡介 要理解XML，HTML等格式，先來理解文件物件模型DOM 　　 根據 DOM，HTML 文件中的每個成分都是一個節點，這些節點組成了一棵樹。DOM 是這樣規定的：整個文件是一個文件節點每個 HTML 標籤是一個元素節點包含在 HTML 元素中的文字是文字節點每一個 HTML 屬性是一個屬性節

java w3c解析xml檔案，獲取指定節點內容，讀取外部配置檔案。

原始碼： package com.ys.adage.utils; import com.ys.adage.message.CodeObjectResult; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.

Java中使用DOM方法解析XML檔案

Java中使用DOM方法解析XML檔案 1、簡介 XML現在已經成為一種通用的資料交換格式，平臺的無關性使得很多場合都需要用到XML，本部落格將介紹用DOM方法解析XML檔案的方法，DOM解析是將XML檔案全部載入到記憶體，組裝成一顆DOM樹，然後通過節點以及節點之間的關係來解析XM

Java眼中的XML---檔案讀取（一）DOM解析XML檔案

目錄 （一）什麼是XML？ （二）XML的作用 （三）DOM解析XML檔案的準備工作 （四）使用DOM解析XML檔案的屬性名和屬性值 （五）使用DOM解析XML檔案的節點名和節點值 （一）什麼是XML？ XML 指可

Java 應用DOM方式解析XML檔案

引入 java為啥需要解析XML的方法？ xml的優勢： 它可以用來標記資料、定義資料型別，是一種允許使用者對自己的標記語言進行定義的源語言。 它非常適合全球資訊網傳輸，提供統一的方法來描述和交換獨立於應用程式或供應商的結構化資料。是Internet環境中

java中解析xml檔案的五種常見方法：DOM4J，dom，pull，SAX，Jdom

package com.zhidi.dom4jtest; import java.io.File; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import or

xml檔案解析—DOM方式

1：xml檔案<?xml version="1.0" encoding="UTF-8"?> <bookstore> <book id="1"> <name>豬1戒</name>

Python解析XML檔案 xml.dom.minidom demo

前情提要: 需要對底層的引數檔案（xml格式）進行讀取，並將前端下發的資料覆蓋原資料，並儲存。 XML樁(01.xml)： <?xml version="1.0" ?> <try> <name>SJH</name> </try

用DOM解析XML檔案並存入mysql資料庫

對於一個數據量大、複雜的xml檔案，要進行解析並且存入資料庫。首先要對xml檔案的dom結構有所瞭解，並進行分析，然後獲取自己想要的資料，之後進行資料的儲存。 接下來說明一下具體的步驟和方法。

XML：使用DOM技術解析xML檔案中的城市，實現select級聯選擇

<?xml version="1.0" encoding="utf-8"?> <china> <province name="北京"> <city>東城區</city> <city>

java中DOM解析xml檔案

本文介紹瞭如何利用DOM(即Document Object Model文件物件模型)解析xml檔案。 首先有一個xml檔案： <?xml version=\"1.0\" encoding=\"UTF-8\" ?> <User> <city

解析xml檔案時，錯誤資訊org.xml.sax.SAXParseException:Parser has reached the entity expansion limit "64,000" set by the Application.的解決辦法

最近一個處理非常大的XML的程式遭遇瞭如下的異常：org.xml.sax.SAXParseException:Parser has reached the entity expansion limit "64,000" set by the Application. (org

用JDK自帶的包來解析XML檔案（DOM＋xpath）

DOM程式設計不要其它的依賴包，因為JDK裡自帶的JDK裡含有的上面提到的org.w3c.dom、org.xml.sax 和javax.xml.parsers包就可以滿意條件了。 （1）org.w3c.dom　W3C推薦的用於XML標準規劃文件物件模型的介面。 （2）

Java上傳且後臺解析XML檔案

後臺程式碼： import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.InputStream; import java.io.InputStreamReader; import javax.

利用dom4j-1.6.1解析xml檔案

1.先看xml的文件裡面的格式 2.main裡面，就是一個按鈕新增點選事件，然後通過工具類來解析 3.工具類裡面的程式碼，這裡我在xml中去掉了部分屬性，你可以自己設定一下，然後重新設定就好了 4.最後在activity中就可以自己查看了，我這裡是直接返回了一

java後臺解析XML檔案

解析XML檔案分為兩種： 1、DOM(Document Object Model) 2、SAX(Simple API for XML) DOM是基於XML文件樹結構的解析，SAX是基於事件流的解析。 我用到的是SAX解析>> 一、XML檔案 <?xml

用JDOM解析XML檔案時如何解決中文問題？如何解析？

1 import javax.xml.parsers.DocumentBuilder; 2 import javax.xml.parsers.DocumentBuilderFactory; 3 import javax.xml.transform.OutputKeys; 4 import jav