精华内容
下载资源
问答
  • 解析XML的4种方式

    2015-03-02 18:45:41
    ========================================== xml文件 <?xml version="1.0" encoding="GB2312"?>       <NO>A1234   四川省XX县XX镇XX路X段XX号       <NO>B1
    ==========================================
    xml文件
    <?xml version="1.0" encoding="GB2312"?> 
    <RESULT> 
    <VALUE> 
       <NO>A1234</NO> 
       <ADDR>四川省XX县XX镇XX路X段XX号</ADDR> 
    </VALUE> 
    <VALUE> 
       <NO>B1234</NO> 
       <ADDR>四川省XX市XX乡XX村XX组</ADDR> 
    </VALUE> 
    </RESULT> 
    需要什么包自己到网上找下吧?
    ==========================================
    1)DOM(JAXP Crimson解析器)

        DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构,然后才能做任何工作。由于它是基于信息层次的,因而DOM被认为是基于树或基于对象的。DOM以及广义的基于树的处理具有几个优点。首先,由于树在内存中是持久的,因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航,而不是像SAX那样是一次性的处理。DOM使用起来也要简单得多。

    import java.io.*; 
    import java.util.*; 
    import org.w3c.dom.*; 
    import javax.xml.parsers.*; 

    public class MyXMLReader{ 
     public static void main(String arge[]){ 

      long lasting =System.currentTimeMillis(); 
      try{ 
       File f=new File("data_10k.xml"); 
       DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance(); 
       DocumentBuilder builder=factory.newDocumentBuilder(); 
       Document doc = builder.parse(f); 
       NodeList nl = doc.getElementsByTagName("VALUE"); 
       for (int i=0;i<nl.getLength();i++){ 
        System.out.print("车牌号码:" + doc.getElementsByTagName("NO").item(i).getFirstChild().getNodeValue()); 
        System.out.println("车主地址:" + doc.getElementsByTagName("ADDR").item(i).getFirstChild().getNodeValue()); 
       } 
      }catch(Exception e){ 
       e.printStackTrace(); 

    ==========================================
    2)SAX

        SAX处理的优点非常类似于流媒体的优点。分析能够立即开始,而不是等待所有的数据被处理。而且,由于应用程序只是在读取数据时检查数据,因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上,应用程序甚至不必解析整个文档;它可以在某个条件得到满足时停止解析。一般来说,SAX还比它的替代者DOM快许多。

        选择DOM还是选择SAX? 对于需要自己编写代码来处理XML文档的开发人员来说, 选择DOM还是SAX解析模型是一个非常重要的设计决策。 DOM采用建立树形结构的方式访问XML文档,而SAX采用的事件模型。

        DOM解析器把XML文档转化为一个包含其内容的树,并可以对树进行遍历。用DOM解析模型的优点是编程容易,开发人员只需要调用建树的指令,然后利用navigation APIs访问所需的树节点来完成任务。可以很容易的添加和修改树中的元素。然而由于使用DOM解析器的时候需要处理整个XML文档,所以对性能和内存的要求比较高,尤其是遇到很大的XML文件的时候。由于它的遍历能力,DOM解析器常用于XML文档需要频繁的改变的服务中。

        SAX解析器采用了基于事件的模型,它在解析XML文档的时候可以触发一系列的事件,当发现给定的tag的时候,它可以激活一个回调方法,告诉该方法制定的标签已经找到。SAX对内存的要求通常会比较低,因为它让开发人员自己来决定所要处理的tag.特别是当开发人员只需要处理文档中所包含的部分数据时,SAX这种扩展能力得到了更好的体现。但用SAX解析器的时候编码工作会比较困难,而且很难同时访问同一个文档中的多处不同数据。

    import org.xml.sax.*; 
    import org.xml.sax.helpers.*; 
    import javax.xml.parsers.*; 

    public class MyXMLReader extends DefaultHandler { 

     java.util.Stack tags = new java.util.Stack(); 
     public MyXMLReader() { 
      super(); 


     public static void main(String args[]) { 
      long lasting = System.currentTimeMillis(); 
      try { 
       SAXParserFactory sf = SAXParserFactory.newInstance(); 
       SAXParser sp = sf.newSAXParser(); 
       MyXMLReader reader = new MyXMLReader(); 
       sp.parse(new InputSource("data_10k.xml"), reader); 
      } catch (Exception e) { 
       e.printStackTrace(); 
      } 

      System.out.println("运行时间:" + (System.currentTimeMillis() - lasting) + "毫秒");} 
      public void characters(char ch[], int start, int length) throws SAXException { 
      String tag = (String) tags.peek(); 
      if (tag.equals("NO")) { 
       System.out.print("车牌号码:" + new String(ch, start, length)); 

    if (tag.equals("ADDR")) { 
      System.out.println("地址:" + new String(ch, start, length)); 



      public void startElement(String uri,String localName,String qName,Attributes attrs) { 
      tags.push(qName);} 


    ==========================================
    3)JDOM http://www.jdom.org

        JDOM的目的是成为Java特定文档模型,它简化与XML的交互并且比使用DOM实现更快。由于是第一个Java特定模型,JDOM一直得到大力推广和促进。正在考虑通过“Java规范请求JSR-102”将它最终用作“Java标准扩展”。从2000年初就已经开始了JDOM开发。

        JDOM与DOM主要有两方面不同。首先,JDOM仅使用具体类而不使用接口。这在某些方面简化了API,但是也限制了灵活性。第二,API大量使用了Collections类,简化了那些已经熟悉这些类的Java开发者的使用。

        JDOM文档声明其目的是“使用20%(或更少)的精力解决80%(或更多)Java/XML问题”(根据学习曲线假定为20%)。JDOM对于大多数Java/XML应用程序来说当然是有用的,并且大多数开发者发现API比DOM容易理解得多。JDOM还包括对程序行为的相当广泛检查以防止用户做任何在XML中无意义的事。然而,它仍需要您充分理解XML以便做一些超出基本的工作(或者甚至理解某些情况下的错误)。这也许是比学习DOM或JDOM接口都更有意义的工作。

        JDOM自身不包含解析器。它通常使用SAX2解析器来解析和验证输入XML文档(尽管它还可以将以前构造的DOM表示作为输入)。它包含一些转换器以将JDOM表示输出成SAX2事件流、DOM模型或XML文本文档。JDOM是在Apache许可证变体下发布的开放源码。

    import java.io.*; 
    import java.util.*; 
    import org.jdom.*; 
    import org.jdom.input.*; 

    public class MyXMLReader { 

     public static void main(String arge[]) { 
      long lasting = System.currentTimeMillis(); 
      try { 
       SAXBuilder builder = new SAXBuilder(); 
       Document doc = builder.build(new File("data_10k.xml")); 
       Element foo = doc.getRootElement(); 
       List allChildren = foo.getChildren(); 
       for(int i=0;i<allChildren.size();i++) { 
        System.out.print("车牌号码:" + ((Element)allChildren.get(i)).getChild("NO").getText()); 
        System.out.println("车主地址:" + ((Element)allChildren.get(i)).getChild("ADDR").getText()); 
       } 
      } catch (Exception e) { 
       e.printStackTrace(); 




    ==========================================

    4)DOM4J http://dom4j.sourceforge.net

        虽然DOM4J代表了完全独立的开发结果,但最初,它是JDOM的一种智能分支。它合并了许多超出基本XML文档表示的功能,包括集成的XPath支持、XML Schema支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项,它通过DOM4J API和标准DOM接口具有并行访问功能。从2000下半年开始,它就一直处于开发之中。

        为支持所有这些功能,DOM4J使用接口和抽象基本类方法。DOM4J大量使用了API中的Collections类,但是在许多情况下,它还提供一些替代方法以允许更好的性能或更直接的编码方法。直接好处是,虽然DOM4J付出了更复杂的API的代价,但是它提供了比JDOM大得多的灵活性。

        在添加灵活性、XPath集成和对大文档处理的目标时,DOM4J的目标与JDOM是一样的:针对Java开发者的易用性和直观操作。它还致力于成为比JDOM更完整的解决方案,实现在本质上处理所有Java/XML问题的目标。在完成该目标时,它比JDOM更少强调防止不正确的应用程序行为。

        DOM4J是一个非常非常优秀的Java XML API,具有性能优异、功能强大和极端易用使用的特点,同时它也是一个开放源代码的软件。如今你可以看到越来越多的Java软件都在使用DOM4J来读写XML,特别值得一提的是连Sun的JAXM也在用DOM4J.

        2…… 比较

        1)DOM4J性能最好,连Sun的JAXM也在用DOM4J.目前许多开源项目中大量采用DOM4J,例如大名鼎鼎的Hibernate也用DOM4J来读取XML配置文件。如果不考虑可移植性,那就采用DOM4J.

        2)JDOM和DOM在性能测试时表现不佳,在测试10M文档时内存溢出。在小文档情况下还值得考虑使用DOM和JDOM.虽然JDOM的开发者已经说明他们期望在正式发行版前专注性能问题,但是从性能观点来看,它确实没有值得推荐之处。另外,DOM仍是一个非常好的选择。DOM实现广泛应用于多种编程语言。它还是许多其它与XML相关的标准的基础,因为它正式获得W3C推荐(与基于非标准的Java模型相对),所以在某些类型的项目中可能也需要它(如在JavaScript中使用DOM)。

        3)SAX表现较好,这要依赖于它特定的解析方式-事件驱动。一个SAX检测即将到来的XML流,但并没有载入到内存(当然当XML流被读入时,会有部分文档暂时隐藏在内存中)。

    import java.io.*; 
    import java.util.*; 
    import org.dom4j.*; 
    import org.dom4j.io.*; 

    public class MyXMLReader { 

     public static void main(String arge[]) { 
      long lasting = System.currentTimeMillis(); 
      try { 
       File f = new File("data_10k.xml"); 
       SAXReader reader = new SAXReader(); 
       Document doc = reader.read(f); 
       Element root = doc.getRootElement(); 
       Element foo; 
       for (Iterator i = root.elementIterator("VALUE"); i.hasNext() { 
        foo = (Element) i.next(); 
        System.out.print("车牌号码:" + foo.elementText("NO")); 
        System.out.println("车主地址:" + foo.elementText("ADDR")); 
       } 
      } catch (Exception e) { 
       e.printStackTrace(); 
    展开全文
  • 主要介绍了java解析xml的4种方式的优缺点对比及实现详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • XML的解析方式主要有四:1、DOM解析;2、SAX解析;3、JDOM解析4、DOM4J解析。其中前两属于基础方法,是官方提供的平台无关的解析方式;后两属于扩展方法,它们是在基础的方法上扩展出来的,只适用于java平台...

    XML的解析方式主要有四种:1、DOM解析;2、SAX解析;3、JDOM解析;4、DOM4J解析。其中前两种属于基础方法,是官方提供的平台无关的解析方式;后两种属于扩展方法,它们是在基础的方法上扩展出来的,只适用于java平台。

    这个是我们本次讲解解析的xml文件parse.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <demo>
        <game id="1" tip="LOL" des="撸啊撸">
            <name>英雄联盟</name>
            <issuedDate>20110922</issuedDate>
            <remark>LOL,开炮,开炮,开炮。</remark>
        </game>
        <color id="2">
            <name>黄色</name>
            <desc>从前的从前,黄色还是一种颜色</desc>
        </color>
        <game id="3" tip="CS">
            <name>反恐精英</name>
            <issuedDate>19990619</issuedDate>
            <remark>Fire in the hole, go, go go...</remark>
        </game>
    </demo>
    

    DOM解析

    DOM的全称是Document Object Model,也即文档对象模型。在应用程序中,基于DOM的XML分析器将一个XML文档转换成一个对象模型的集合(通常称DOM树),应用程序正是通过对这个对象模型的操作,来实现对XML文档数据的操作。通过DOM接口,应用程序可以在任何时候访问XML文档中的任何一部分数据,因此,这种利用DOM接口的机制也被称作随机访问机制。
    在解析XML过程中,DOM会一次性将整个XML文件转换成Document对象存储在内存中,当XML文件较大的时候,有可能出现内存溢出。

    优点:
    1、形成了树结构,有助于更好的理解、掌握,且代码容易编写。
    2、解析过程中,树结构保存在内存中,方便修改。

    缺点:
    1、由于文件是一次性读取,所以对内存的耗费比较大。
    2、如果XML文件比较大,容易影响解析性能且可能会造成内存溢出。

    适用场景:需要修改XML文档的应用程序或XSLT应用程序(不可用于只读XML的应用程序)

    下面是DOM解析过程:

    public class DomToParseXML {
    	public static void main(String[] args) {
    		//1.创建一个DocumentBuilderFactory的对象
    		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    		
    		try {
    			//2.创建DocumentBuilder对象
    			DocumentBuilder db = dbf.newDocumentBuilder();
    			
    			//3.创建xml的io流对象
    			FileInputStream fis = new FileInputStream(new File(DomToParseXML.class.getProtectionDomain().getCodeSource().getLocation().getPath()+"config/parse.xml"));
    			
    			//4.读取xml,将xml转换成document对象
    			Document document = db.parse(fis);
    			
    			//5.1 获取xml文件根节点
    			NodeList root = document.getElementsByTagName("demo");
    			for(int i=0;i<root.getLength();i++) {
    				//5.2 根节点demo
    				Node demo = root.item(i);
    				System.out.println("根节点:"+demo.getNodeName()+"\n");//demo
    				
    				//6.1 获取获取demo节点的子节点
    				NodeList nodelist1 = demo.getChildNodes();
    				for(int j=0;j<nodelist1.getLength();j++) {
    					//6.2 demo节点的子节点
    					Node node1 = nodelist1.item(j);
    					
    					//判断节点类型,只需取element类型的节点
    					if(node1.getNodeType() == Node.ELEMENT_NODE) {
    						System.out.print("demo子节点:"+node1.getNodeName()+",属性:");
    						//7.1 获取节点的所有属性集合
    						NamedNodeMap attrs = node1.getAttributes();
    						for(int k=0;k<attrs.getLength();k++) {
    							//7.2 节点的属性
    							Node attr = attrs.item(k);
    							if(k!=0)System.out.print(", ");
    							System.out.print(attr.getNodeName()+"="+attr.getNodeValue());
    						}
    						System.out.println("");
    						
    						//8.1 获取第二层节点
    						NodeList nodelist2 = node1.getChildNodes();
    						for(int l=0;l<nodelist2.getLength();l++) {
    							//8.2 第二层节点的子节点
    							Node node2 = nodelist2.item(l);
    							if(node2.getNodeType() == Node.ELEMENT_NODE) {
    								//9.获取节点内容
    								String content = node2.getFirstChild().getNodeValue();
    								System.out.print(node1.getNodeName()+"子节点:"+node2.getNodeName());
    								System.out.println(", 值:"+content);
    							}
    						}
    						System.out.println("");
    					}
    				}
    			}
    		}catch(Exception e) {
    			System.out.println("解析xml出错。");
    		}
    	}
    }
    

    SAX解析

    SAX的全称是Simple APIs for XML,也即XML简单应用程序接口。与DOM不同,SAX提供的访问模式是一种顺序模式,这是一种快速读写XML数据的方式。当使用SAX分析器对XML文档进行分析时,会触发一系列事件,并激活相应的事件处理函数,应用程序通过这些事件处理函数实现对XML文档的访问,因而SAX接口也被称作事件驱动接口。

    优点:
    1、采用事件驱动模式,对内存耗费比较小。
    2、适用于只处理XML文件中的数据时。

    缺点:
    1、编码比较麻烦。
    2、很难同时访问XML文件中的多处不同数据。

    适用场景:只从XML读取数据的应用程序(不可用于操作或修改XML文档)

    下面是SAX解析过程:

    1. 先准备好两个实体类接收xml中的对应标签内容:
    public class Game {
    	private String name;
    	private String issuedDate;
    	private String remark;
    	/** 存储元素的全部属性 **/
    	private Map<String, Object> attributesMap;
    	
    	//此处省略了get/set/toString方法...
    }
    
    public class Color{
    	private String name;
    	private String desc;
    	/** 存储元素的全部属性 **/
    	private Map<String, Object> attributesMap;
    	
    	//此处省略了get/set/toString方法...
    }
    
    1. 准备SAX解析xml的处理类,SAX默认使用DefaultHandler去解析xml。我们需要继承DefaultHandler,编写一个自己的处理类SAXParserHandler来实现xml解析。
    public class SAXParserHandler extends DefaultHandler {
    	/** 用来标记当前元素是什么 */
    	private String element;
    	/** game标签对象集合 */
    	private List<Game> gameList;
    	/** game标签对应对象 */
    	private Game game;
    	/** Color标签对象集合 */
    	private List<Color> colorList;
    	/** 标签对应对象 */
    	private Color color;
    	/** 属性集合 */
    	private Map<String, Object> attributesMap;
    	
    	/**
    	 * 文档解析开始时调用,该方法只会调用一次
    	 */
    	@Override
    	public void startDocument() throws SAXException {
    		System.out.println("开始解析xml...");
    		super.startDocument();
    		//初始化list
    		gameList = new ArrayList<Game>();
    		colorList = new ArrayList<Color>();
    		attributesMap = new HashMap<String, Object>();
    	}
    	
    	/**
    	 * 文档解析结束后调用,该方法只会调用一次
    	 */
    	@Override
    	public void endDocument() throws SAXException {
    		super.endDocument();
    		System.out.println("xml解析完成...");
    	}
    
    	/**
    	 * 标签(节点)解析开始时调用
    	 * uri:xml文档的命名空间
    	 * localName:标签的名字
    	 * qName:带命名空间的标签的名字
    	 * attributes:标签的属性集
    	 */
    	@Override
    	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
    		System.out.println("开始解析标签:"+qName);
    		super.startElement(uri, localName, qName, attributes);
    		//根据标签名判断是什么对象
    		if("game".equals(qName)) {
    			game = new Game();
    			//遍历属性
    			for(int i=0;i<attributes.getLength();i++) {
    				attributesMap.put(attributes.getQName(i), attributes.getValue(i));
    			}
    			//深度复制Map,后面清空map不会受影响
    			//深拷贝说明地址:https://blog.csdn.net/frankyhome/article/details/103200315
    			Map<String, Object> cloneMap = CloneUtils.cloneMap(attributesMap);
    			game.setAttributesMap(cloneMap);
    		}else if("color".equals(qName)) {
    			color = new Color();
    			//遍历属性
    			for(int i=0;i<attributes.getLength();i++) {
    				attributesMap.put(attributes.getQName(i), attributes.getValue(i));
    			}
    			//深度复制Map,后面清空map不会受影响
    			Map<String, Object> cloneMap = CloneUtils.cloneMap(attributesMap);
    			color.setAttributesMap(cloneMap);
    		}
    		//将当前元素保存为element,方便后面解析内容时判断对象
    		element = qName;
    	}
    	
    	/**
    	 * 标签(节点)解析结束后调用
    	 * uri:xml文档的命名空间
    	 * localName:标签的名字
    	 * qName:带命名空间的标签的名字
    	 */
    	@Override
    	public void endElement(String uri, String localName, String qName) throws SAXException {
    		super.endElement(uri, localName, qName);
    		//将解析出的对象加入到对应list集合, 并置空
    		if("game".equals(qName)) {
    			gameList.add(game);
    			game = null;
    		}else if("color".equals(qName)) {
    			colorList.add(color);
    			color = null;
    		}
    		//解析完成置空
    		element = "";
    		attributesMap.clear();
    		System.out.println("解析标签结束:"+qName+"\n");
    	}
    	
    	/**
    	 * 解析标签的内容的时候调用
    	 * ch:当前读取到的TextNode(文本节点)的字节数组
    	 * start:字节开始的位置,为0则读取全部
    	 * length:当前TextNode的长度
    	 */
    	@Override
    	public void characters(char[] ch, int start, int length) throws SAXException {
    		super.characters(ch, start, length);
    		String string = new String(ch, start, length);
    		//判断当前内容,属于哪一个元素。
            if ("name".equals(element)) {
            	//由于name在两个对象同时存在,需要根据对象是否为空判断当前是哪个对象
            	if(game!=null) {
            		game.setName(string);
            	}else if(color!=null) {
            		color.setName(string);
            	}
            }else if ("issuedDate".equals(element)) {
                game.setIssuedDate(string);
            }else if ("remark".equals(element)) {
                game.setRemark(string);
            }else if ("desc".equals(element)) {
                color.setDesc(string);
            }
    	}
    
    	//此处省略了get/set方法,后面sax解析主类需要使用get方法获取解析结果
    }
    
    1. SAX解析主类:
    public class SaxToParseXML {
    	public static void main(String[] args) {
    		//1.创建SAXParserFactory对象
    		SAXParserFactory spf = SAXParserFactory.newInstance();
    		try {
    			//2.创建SAXParser对象
    			SAXParser saxparser = spf.newSAXParser();
    			//3.获取xml文件io流
    			FileInputStream fis = new FileInputStream(new File(SaxToParseXML.class.getProtectionDomain().getCodeSource().getLocation().getPath()+"config/parse.xml"));
    			//4.新建SAX解析处理类
    			SAXParserHandler handler = new SAXParserHandler();
    			//5.解析xml
    			saxparser.parse(fis, handler);
    			//6.查看解析结果
    			List<Game> gameList = handler.getGameList();
    			System.out.println("gameList:"+gameList.toString());
    			List<Color> colorList = handler.getColorList();
    			System.out.println("colorList:"+colorList.toString());
    			//7.关闭资源
    			fis.close();
    		}catch(Exception e) {
    			System.out.println("解析xml出错。");
    		}
    	}
    }
    

    JDOM解析

    JDOM是一个在基于内存的XML模型,它用于读写创建修改XML文档。JDOM和DOM相似因为他们都提供了内存XML文档模型,但是JDOM只是被设计用来处理Java。因为这个原因JDOM不遵循w3c标准规范。JDOM不是一个XML解析器但是它可以使用SAX,STAX或者DOM解析器用来构建一个JDOM文档。

    优点:
    1、是基于树的处理XML的Java API,把树加载在内存中
    2、没有向下兼容的限制,因此比DOM简单
    3、速度快,缺陷少
    4、具有SAX的JAVA规则

    缺点:
    1、不能处理大于内存的文档
    2、JDOM表示XML文档逻辑模型。不能保证每个字节真正变换。
    3、针对实例文档不提供DTD与模式的任何实际模型。
    4、不支持与DOM中相应遍历包

    适用场景:JDOM具有树的便利,也有SAX的JAVA规则。在需要平衡时使用

    下面是JDOM解析过程:

    public class JdomToParseXML {
    	public static void main(String[] args) {
    		//引入org.jdom.jdom2-2.0.6.jar
    		//1.新建SAXBuilder对象
    		SAXBuilder builder = new SAXBuilder();
    		try {
    			//2.获取xml文件io流
    			FileInputStream fis = new FileInputStream(new File(JdomToParseXML.class.getProtectionDomain().getCodeSource().getLocation().getPath()+"config/parse.xml"));
    			//3.获取Document对象
    			Document document = builder.build(fis);
    			//4.获取根节点
    			Element root = document.getRootElement();
    			System.out.println("根节点:"+root.getName());
    			//5.获取root的所有子元素集合
    			List<Element> list1 = root.getChildren();
    			//6.遍历第一层元素集合
    			for(Element element1 : list1) {
    				System.out.print("第一层元素:"+element1.getName());
    				//7.获取第一层元素属性
    				if (element1.hasAttributes()) {
    					List<Attribute> attrList = element1.getAttributes();
    					for(Attribute attr : attrList) {
    						System.out.print("  属性:"+attr.getName()+"="+attr.getValue());
    					}
    				}
    				System.out.println(""); 
    				//8.遍历第二层元素
    				List<Element> list2 = element1.getChildren();
    				for(Element element2 : list2) {
    					System.out.println("第二层元素:"+element2.getName()+"  值:"+element2.getValue());
    				}
    				System.out.println("");
    			}
    		} catch (Exception e) {
    			System.out.println("解析xml出错。");
    		}
    	}
    }
    

    DOM4J解析

    DOM4J的全称是Document Object Model for Java。DOM4J 是一个非常非常优秀的Java XML API,具有性能优异、功能强大和极端易用使用的特点,同时它也是一个开放源代码的软件。

    优点:
    1、JDOM的分支,大量使用了Java集合类。
    2、开源,支持XPath。
    3、性能优异、灵活性好、功能强大和极端易用。

    缺点:
    1、大量使用了接口,API较为复杂。

    使用场景:如果不考虑可移植性, 首先考虑使用DOM4J。

    下面是DOM4J解析过程:

    public class Dom4jToParseXML {
    	public static void main(String[] args) {
    		//引入org.dom4j.dom4j-2.1.1.jar
    		//1.创建SAXReader对象
    		SAXReader saxReader = new SAXReader();
    		try {
    			//2.获取xml文件io流
    			FileInputStream fis = new FileInputStream(new File(JdomToParseXML.class.getProtectionDomain().getCodeSource().getLocation().getPath()+"config/parse.xml"));
    			//3.获取Document对象
    			Document document = saxReader.read(fis);
    			//4.获取根节点
    			Element root = document.getRootElement();
    			System.out.println("根节点:"+root.getName());
    			//5.获取root的所有子元素集合
    			List<Element> list1 = root.elements();
    			//6.遍历第一层元素集合
    			for(Element element1 : list1) {
    				System.out.print("第一层元素:"+element1.getName());
    				//7.获取第一层元素属性
    				if (element1.attributes() != null) {
    					List<Attribute> attrList = element1.attributes();
    					for(Attribute attr : attrList) {
    						System.out.print("  属性:"+attr.getName()+"="+attr.getValue());
    					}
    				}
    				System.out.println(""); 
    				//8.遍历第二层元素
    				List<Element> list2 = element1.elements();
    				for(Element element2 : list2) {
    					System.out.println("第二层元素:"+element2.getName()+"  值:"+element2.getStringValue());
    				}
    				System.out.println("");
    			}
    		} catch (Exception e) {
    			System.out.println("解析xml出错。");
    		}
    	}
    }
    

    总结

    1. DOM4J性能最好,连Sun的JAXM也在用DOM4J。目前许多开源项目中大量采用DOM4J,例如大名鼎鼎的Hibernate也用DOM4J来读取XML配置文件。如果不考虑可移植性,那就采用DOM4J。
    2. JDOM和DOM在性能测试时表现不佳,在测试10M文档时内存溢出。在小文档情况下还值得考虑使用DOM和JDOM。虽然JDOM的开发者已经说明他们期望在正式发行版前专注性能问题,但是从性能观点来看,它确实没有值得推荐之处。另外,DOM仍是一个非常好的选择。DOM实现广泛应用于多种编程语言。它还是许多其它与XML相关的标准的基础,因为它正式获得W3C推荐(与基于非标准的Java模型相对),所以在某些类型的项目中可能也需要它(如在JavaScript中使用DOM)。
    3. SAX表现较好,这要依赖于它特定的解析方式-事件驱动。一个SAX检测即将到来的XML流,但并没有载入到内存(当然当XML流被读入时,会有部分文档暂时隐藏在内存中)。
    展开全文
  • 文章摘要:  解析方式有 DOM / SAX / JDOM / DOM4J,其中前两者是官方提供基础方式,后两者是仅限 java 平台扩展方法。目前应用最多是 DOM4J。 转载于:https://www.cnblogs.com/mexding/p/9401366.html...


    参考链接:https://www.cnblogs.com/longqingyang/p/5577937.html

    文章摘要:
      解析方式有 DOM / SAX / JDOM / DOM4J,其中前两者是官方提供的基础方式,后两者是仅限 java 平台的扩展方法。目前应用最多的是 DOM4J。

    转载于:https://www.cnblogs.com/mexding/p/9401366.html

    展开全文
  • java解析XML的4种方式

    2012-09-25 19:46:18
    XML现在已经成为一通用数据交换格式,它平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大方便。对于XML本身语法知 识与技术细节,需要阅读相关技术文献,这里面包括内容有DOM(Document ...
    XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便。对于XML本身的语法知 识与技术细节,需要阅读相关的技术文献,这里面包括的内容有DOM(Document Object Model),DTD(Document Type Definition),SAX(Simple API for XML),XSD(Xml Schema Definition),XSLT(Extensible Stylesheet Language Transformations),具体可参阅w3c官方网站文档http://www.w3.org获取更多信息。 
    	 XML在不同的语言里解析方式都是一样的,只不过实现的语法不同而已。基本的解析方式有两种,一种叫SAX,另一种叫DOM。SAX是基于事件流的解析,DOM是基于XML文档树结构的解析。假设我们XML的内容和结构如下: 
    	 <?xml version="1.0" encoding="UTF-8"?> 
    	 <employees> 
    	 <employee> 
    	 <name>ddviplinux</name> 
    	 <sex>m</sex> 
    	 <age>30</age> 
    	 </employee> 
    	 </employees>
    	 本文使用JAVA语言来实现DOM与SAX的XML文档生成与解析。 
    	 首先定义一个操作XML文档的接口XmlDocument 它定义了XML文档的建立与解析的接口。 
    	 package com.alisoft.facepay.framework.bean; 
    	 /** 
    	 * 
    	 * @author hongliang.dinghl 
    	 * 定义XML文档建立与解析的接口 
    	 */ 
    	 public interface XmlDocument { 
    	 /** 
    	 * 建立XML文档 
    	 * @param fileName 文件全路径名称 
    	 */ 
    	 public void createXml(String fileName); 
    	 /** 
    	 * 解析XML文档 
    	 * @param fileName 文件全路径名称 
    	 */ 
    	 public void parserXml(String fileName); 
    	 } 
    	 1.DOM生成和解析XML文档
    	/* 为 XML 文档的已解析版本定义了一组接口。解析器读入整个文档,然后构建
    	 一个驻留内存的树结构,然后代码就可以使用 DOM 接口来操作这个树结构。
    	 优点:整个文档树在内存中,便于操作;支持删除、修改、重新排列等多种功能;
    	 缺点:将整个文档调入内存(包括无用的节点),浪费时 间和空间;
    	 使用场合:一旦解析了文档还需多次访问这些数据;硬件资源充足(内存、CPU)。 
    	 */
    	 package com.alisoft.facepay.framework.bean; 
    	 import java.io.FileInputStream; 
    	 import java.io.FileNotFoundException; 
    	 import java.io.FileOutputStream; 
    	 import java.io.IOException; 
    	 import java.io.InputStream; 
    	 import java.io.PrintWriter; 
    	 import javax.xml.parsers.DocumentBuilder; 
    	 import javax.xml.parsers.DocumentBuilderFactory; 
    	 import javax.xml.parsers.ParserConfigurationException; 
    	 import javax.xml.transform.OutputKeys; 
    	 import javax.xml.transform.Transformer; 
    	 import javax.xml.transform.TransformerConfigurationException; 
    	 import javax.xml.transform.TransformerException; 
    	 import javax.xml.transform.TransformerFactory; 
    	 import javax.xml.transform.dom.DOMSource; 
    	 import javax.xml.transform.stream.StreamResult; 
    	 import org.w3c.dom.Document; 
    	 import org.w3c.dom.Element; 
    	 import org.w3c.dom.Node; 
    	 import org.w3c.dom.NodeList; 
    	 import org.xml.sax.SAXException; 
    	 /** 
    	 * 
    	 * @author hongliang.dinghl 
    	 * DOM生成与解析XML文档 
    	 */ 
    	 public class DomDemo implements XmlDocument { 
    	 private Document document; 
    	 private String fileName; 
    	 public void init() { 
    		 try { 
    			 DocumentBuilderFactory factory = DocumentBuilderFactory 
    			 	.newInstance(); 
    			 DocumentBuilder builder = factory.newDocumentBuilder(); 
    			 this.document = builder.newDocument(); 
    		 } catch (ParserConfigurationException e) { 
    			 System.out.println(e.getMessage()); 
    	     } 
    	 } 
    	 public void createXml(String fileName) { 
    		 //生成节点
    		 Element root = this.document.createElement("employees"); 
    		 this.document.appendChild(root); 
    		 Element employee = this.document.createElement("employee"); 
    		 Element name = this.document.createElement("name"); 
    		 name.appendChild(this.document.createTextNode("丁宏亮")); //添加节点内容
    		 employee.appendChild(name); //节点嵌套
    		 Element sex = this.document.createElement("sex"); 
    		 sex.appendChild(this.document.createTextNode("m")); 
    		 employee.appendChild(sex); 
    		 Element age = this.document.createElement("age"); 
    		 age.appendChild(this.document.createTextNode("30")); 
    		 employee.appendChild(age); 
    		 root.appendChild(employee);
    		 //TransformerFactory 实例可用于创建 Transformer 和 Templates 对象。 
    		 TransformerFactory tf = TransformerFactory.newInstance(); 
    		 try { 
    		 //可以通过 TransformerFactory.newTransformer 方法获取此类的实例。
    	     //然后此实例可以用于处理来自不同源的 XML,并将转换输出写入各种接收器。
    	     //在多线程同时运行时不能使用此类的对象。不同线程可以同时使用不同Transformers。
    		 Transformer transformer = tf.newTransformer(); 
    		 //以 Document Object Model(DOM)树的形式充当转换 Source 树的持有者。
    		 DOMSource source = new DOMSource(document); 
    		 transformer.setOutputProperty(OutputKeys.ENCODING, "gb2312"); 
    		 transformer.setOutputProperty(OutputKeys.INDENT, "yes"); 
    		 PrintWriter pw = new PrintWriter(new FileOutputStream(fileName)); 
    		 //充当转换结果的持有者,可以为 XML、纯文本、HTML 或某些其他格式的标记。
    		 StreamResult result = new StreamResult(pw); 
    		 //transform(Source xmlSource, Result outputTarget) 将 XML Source 转换为 Result。
    		 transformer.transform(source, result); 
    		 System.out.println("生成XML文件成功!"); 
    		 } catch (TransformerConfigurationException e) { 
    		 System.out.println(e.getMessage()); 
    		 } catch (IllegalArgumentException e) { 
    		 System.out.println(e.getMessage()); 
    		 } catch (FileNotFoundException e) { 
    		 System.out.println(e.getMessage()); 
    		 } catch (TransformerException e) { 
    		 System.out.println(e.getMessage()); 
    		 } 
    	 } 
    	 public void parserXml(String fileName) { 
    		 try { 
    			 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); 
    			 DocumentBuilder db = dbf.newDocumentBuilder(); 
    			 Document document = db.parse(fileName); 
    			 NodeList employees = document.getChildNodes(); 
    			 for (int i = 0; i < employees.getLength(); i++) { 
    				 Node employee = employees.item(i); 
    				 NodeList employeeInfo = employee.getChildNodes(); 
    				 for (int j = 0; j < employeeInfo.getLength(); j++) { 
    					 Node node = employeeInfo.item(j); 
    					 NodeList employeeMeta = node.getChildNodes(); 
    					 for (int k = 0; k < employeeMeta.getLength(); k++) { 
    						 System.out.println(employeeMeta.item(k).getNodeName() 
    						 + ":" + employeeMeta.item(k).getTextContent()); 
    					 } 
    				 } 
    			 } 
    			 System.out.println("解析完毕"); 
    		 } catch (FileNotFoundException e) { 
    		 System.out.println(e.getMessage()); 
    		 } catch (ParserConfigurationException e) { 
    		 System.out.println(e.getMessage()); 
    		 } catch (SAXException e) { 
    		 System.out.println(e.getMessage()); 
    		 } catch (IOException e) { 
    		 System.out.println(e.getMessage()); 
    		 } 
    		 } 
    	 } 
    	 2.SAX生成和解析XML文档 
    	 /*为解决DOM的问题,出现了SAX。SAX ,事件驱动。当解析器发现元素开始、 元素结束、文本、文档的开始或结束等时,发送事件,程序员编写响应这些事件的代码,保存数据。
    	 优点:不用事先调入整个 文档,占用资源少;SAX解析器代码比DOM解析器代码小,适于Applet,下载。
    	 缺点:不是持久的;事件过后,若没保存数据,那么数据就丢了;无状态 性;从事件中只能得到文本,但不知该文本属于哪个元素;
    	 使用场合:Applet;只需XML文档的少量内容,很少回头访问;机器内存少; 
    	 */
    	 Java代码
    	 package com.alisoft.facepay.framework.bean;   
    	 import java.io.FileInputStream;   
    	 import java.io.FileNotFoundException;   
    	 import java.io.IOException;   
    	 import java.io.InputStream;   
    
    	 import javax.xml.parsers.ParserConfigurationException;   
    	 import javax.xml.parsers.SAXParser;   
    	 import javax.xml.parsers.SAXParserFactory;   
    
    	 import org.xml.sax.Attributes;   
    	 import org.xml.sax.SAXException;   
    	 import org.xml.sax.helpers.DefaultHandler;   
    	 /**  
    	 *   
    	 * @author hongliang.dinghl  
    	 * SAX文档解析  
    	 */  
    	 public class SaxDemo implements XmlDocument {   
    		 
    		 public void createXml(String fileName) {   
    		 System.out.println("<<"+filename+">>");   
    		 }   
    	
    		 public void parserXml(String fileName) {   
    			 SAXParserFactory saxfac = SAXParserFactory.newInstance();   
    			 try {   
    				 SAXParser saxparser = saxfac.newSAXParser();   
    				 InputStream is = new FileInputStream(fileName);   
    				 saxparser.parse(is, new MySAXHandler());   
    			 } catch (ParserConfigurationException e) {   
    				 e.printStackTrace();   
    			 } catch (SAXException e) {   
    				 e.printStackTrace();   
    			 } catch (FileNotFoundException e) {   
    				 e.printStackTrace();   
    			 } catch (IOException e) {   
    				 e.printStackTrace();   
    			 }   
    		}   
    	}   
    
    	 class MySAXHandler extends DefaultHandler {   
    		 boolean hasAttribute = false;   
    		 Attributes attributes = null;  
    		 
    		 public void startDocument() throws SAXException {   
    			 System.out.println("文档开始打印了");   
    		 }   
    		 public void endDocument() throws SAXException {   
    			 System.out.println("文档打印结束了");   
    		 }   
    		 public void startElement(String uri, String localName, String qName,   
    		 Attributes attributes) throws SAXException {   
    			 if (qName.equals("employees")) {   
    				 return;   
    			 }   
    			 if (qName.equals("employee")) {   
    				 System.out.println(qName);   
    			 }   
    			 if (attributes.getLength() > 0) {   
    				 this.attributes = attributes;   
    				 this.hasAttribute = true;   
    			 }   
    		 }   
    	
    		 public void endElement(String uri, String localName, String qName)   
    		 throws SAXException {   
    			 if (hasAttribute && (attributes != null)) {   
    				 for (int i = 0; i < attributes.getLength(); i++) {   
    					 System.out.println(attributes.getQName(0)   
    					 + attributes.getValue(0));   
    				 }   
    			 }   
    		 }   
    	
    		 public void characters(char[] ch, int start, int length)   
    		 throws SAXException {   
    			 System.out.println(new String(ch, start, length));   
    		 }   
    	 }  
    	 
    	 写xml:
    	 package xml;
    
    	 import java.io.FileNotFoundException;
    	 import java.io.FileOutputStream;
    	 import java.io.IOException;
    	 import java.io.OutputStream;
    	 import java.util.HashMap;
    	 import java.util.Iterator;
    	 import java.util.Set;
    	 import javax.xml.transform.OutputKeys;
    	 import javax.xml.transform.Result;
    	 import javax.xml.transform.Transformer;
    	 import javax.xml.transform.TransformerConfigurationException;
    	 import javax.xml.transform.sax.SAXTransformerFactory;
    	 import javax.xml.transform.sax.TransformerHandler;
    	 import javax.xml.transform.stream.StreamResult;
    
    	 import org.xml.sax.SAXException;
    	 import org.xml.sax.helpers.AttributesImpl;
    
    	 public class WriteXml {
    	 /*此类扩展了 TransformerFactory 以提供特定于 SAX 的工厂方法。它提供两种类型的 ContentHandlers,
    	         一种用于创建 Transformers,另一种用于创建 Templates 对象。
    	 */
    	  SAXTransformerFactory fac = (SAXTransformerFactory) SAXTransformerFactory
    	    .newInstance();
    	  //侦听 SAX ContentHandler 解析事件,并将它们转换为 Result 的 TransformerHandler。 
    	  private TransformerHandler handler = null;
    	  private OutputStream outStream = null;
    	  private String fileName;
    	  private AttributesImpl atts;	  
    	  private String rootElement;
    
    	  public WriteXml(String fileName, String rootElement) {
    	   this.fileName = fileName;
    	   this.rootElement = rootElement;
    	   init();
    	  }
    
    	  public void init() {
    	   try {
    		     handler = fac.newTransformerHandler();
    		     Transformer transformer = handler.getTransformer();
    		     transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");//
    		    // 设置输出采用的编码方式
    		     transformer.setOutputProperty(OutputKeys.INDENT, "yes");// 是否自动添加额外的空白
    		     transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION,"no");// 是否忽略xml声明
    	
    		     outStream = new FileOutputStream(fileName);
    		     //实现此接口的对象包含构建转换结果树所需的信息。所有已知实现类: 
    		     //DOMResult, SAXResult, StreamResult 
    		     Result resultxml = new StreamResult(outStream);
    		     handler.setResult(resultxml);
    	
    		     atts = new AttributesImpl();
    		    
    		     start();
    		     
    	   } catch (TransformerConfigurationException e) {
    		   	e.printStackTrace();
    	   } catch (FileNotFoundException e) {
    		   	e.printStackTrace();
    	   }
    	  }
    
    	  private void start() {
    	   try {
    		    handler.startDocument();
    		    handler.startElement("", "", rootElement, atts);
    	   } catch (SAXException e) {
    		   e.printStackTrace();
    	   }
    	  }
    
    	  public void write(HashMap<String, String> map, String objectElement)
    	    throws SAXException {
    		   Set<String> keys = map.keySet();
    		   Iterator it = keys.iterator();
    		   if (objectElement != null) {
    			   handler.startElement("", "", objectElement, atts);
    		   }
    		   while (it.hasNext()) {
    			    String key = (String) it.next();
    			    String value = map.get(key);
    			    handler.startElement("", "", key, atts);
    			    handler.characters(value.toCharArray(), 0, value.length());
    			    handler.endElement("", "", key);
    		   }
    		   if (objectElement != null) {
    			   handler.endElement("", "", objectElement);
    		   }
    	  }
    
    	  public void end() {
    	   try {
    		    handler.endElement("", "", rootElement);
    		    handler.endDocument();// 文档结束,同步到磁盘
    		    outStream.close();
    	   } catch (SAXException e) {
    		   e.printStackTrace();
    	   } catch (IOException e) {
    		   e.printStackTrace();
    	   }
    	  }
    
    	  public static void main(String[] args) {
    	   WriteXml xml = new WriteXml("c:/student.xml", "students");
    	   try {
    	    HashMap<String, String> map = new HashMap<String, String>();
    	    map.put("id", "20050505");
    	    map.put("name", "zhaobenshan");
    	    map.put("age", "21");
    	    map.put("classes", "Act051");
    
    	    xml.write(map, "student");
    	    
    	    map = new HashMap<String, String>();
    	    map.put("id", "20050506");
    	    map.put("name", "songdandan");
    	    map.put("age", "20");
    	    map.put("classes", "Act052");
    	    
    	    xml.write(map, "student");
    	    
    	    map = new HashMap<String, String>();
    	    map.put("id", "20050507");
    	    map.put("name", "fanchushi");
    	    map.put("age", "21");
    	    map.put("classes", "Act051");
    	    
    	    xml.write(map, "student");
    	    
    	    xml.end();
    	   } catch (SAXException e) {
    	    e.printStackTrace();
    	   }
    	  }
    	 }
    
    
    	 生成的students.xml
    
    	 <?xml version="1.0" encoding="UTF-8" ?>
    	 <students>
    	  <student>
    	   <id>20050505</id>
    	   <name>zhaobenshan</name>
    	   <age>21</age>
    	   <desc>
    	    <class>Act051</class>
    	    <major>Art</major>
    	   </desc>
    	  </student>
    
    	  <student>
    	   <id>20050506</id>
    	   <name>songdandan</name>
    	   <age>20</age>
    	   <desc>
    	    <class>Act052</class>
    	    <major>Art</major>
    	   </desc>
    	  </student>
    
    	  <student>
    	   <id>20050507</id>
    	   <name>fanchushi</name>
    	   <age>21</age>
    	   <desc>
    	    <class>Act053</class>
    	    <major>Art</major>
    	   </desc>
    	  </student>
    	 </students>
    
    
    
    	 3.DOM4J生成和解析XML文档 
    	/* DOM4J 是一个非常非常优秀的Java XML API,具有性能优异、功能强大和极端易用使用的特点,
    	 同时它也是一个开放源代码的软件。如今你可以看到越来越多的 Java 软件都在使用 DOM4J 来读写 XML,
    	 特别值得一提的是连 Sun 的 JAXM 也在用 DOM4J。
    	 */ 
    	 Java代码 
    	 package com.alisoft.facepay.framework.bean;   
    	 import java.io.File;   
    	 import java.io.FileWriter;   
    	 import java.io.IOException;   
    	 import java.io.Writer;   
    	 import java.util.Iterator;   
    
    	 import org.dom4j.Document;   
    	 import org.dom4j.DocumentException;   
    	 import org.dom4j.DocumentHelper;   
    	 import org.dom4j.Element;   
    	 import org.dom4j.io.SAXReader;   
    	 import org.dom4j.io.XMLWriter;   
    	 /**  
    	 *   
    	 * @author hongliang.dinghl  
    	 * Dom4j 生成XML文档与解析XML文档  
    	 */  
    	 public class Dom4jDemo implements XmlDocument {   
    
    	 public void createXml(String fileName) {   
    		 Document document = DocumentHelper.createDocument();   
    		 Element employees=document.addElement("employees");   
    		 Element employee=employees.addElement("employee");   
    		 Element name= employee.addElement("name"); //不想DOM用appendChild  createElement  createTextNode 
    		 name.setText("ddvip");   
    		 Element sex=employee.addElement("sex");   
    		 sex.setText("m");   
    		 Element age=employee.addElement("age");   
    		 age.setText("29");   
    		 try {   
    			 Writer fileWriter=new FileWriter(fileName);   
    			 XMLWriter xmlWriter=new XMLWriter(fileWriter);   
    			 xmlWriter.write(document);   
    			 xmlWriter.close();   
    		 } catch (IOException e) {   
    			 System.out.println(e.getMessage());   
    		 }   
    	 }   
    
    	 //有点像DOM
    	 public void parserXml(String fileName) {   
    		 File inputXml=new File(fileName);   
    		 SAXReader saxReader = new SAXReader(); //使用的是SAXReader  
    		 try {   
    			 Document document = saxReader.read(inputXml);   
    			 Element employees=document.getRootElement();   
    			 for(Iterator i = employees.elementIterator(); i.hasNext();){   
    				 Element employee = (Element) i.next();   
    				 for(Iterator j = employee.elementIterator(); j.hasNext();){   
    					 Element node=(Element) j.next();   
    					 System.out.println(node.getName()+":"+node.getText());   
    				 }   
    			 }   
    		 } catch (DocumentException e) {   
    		 System.out.println(e.getMessage());   
    		 }   
    		 System.out.println("dom4j parserXml");   
    		 }   
    	 }   
    	 4.JDOM生成和解析XML   
    	 //为减少DOM、SAX的编码量,出现了JDOM;优点:20-80原则,极大减少了代码量。
    	 //使用场合:要实现的功能简单,如解析、创建等,但在底层,JDOM还是使用SAX(最常用)、DOM、Xanan文档。 
    	    
    
    	 package com.alisoft.facepay.framework.bean;   
    
    	 import java.io.FileNotFoundException;   
    	 import java.io.FileOutputStream;   
    	 import java.io.IOException;   
    	 import java.util.List;   
    	 import org.jdom.Document;   
    	 import org.jdom.Element;   
    	 import org.jdom.JDOMException;   
    	 import org.jdom.input.SAXBuilder;   
    	 import org.jdom.output.XMLOutputter;   
    	 /**  
    	 *   
    	 * @author hongliang.dinghl  
    	 * JDOM 生成与解析XML文档  
    	 *   
    	 */  
    	 public class JDomDemo implements XmlDocument {   
    
    	 public void createXml(String fileName) {   
    		 Document document;   
    		 Element  root;   
    		 root=new Element("employees");   
    		 document=new Document(root);   
    		 Element employee=new Element("employee");   
    		 root.addContent(employee);   
    		 Element name=new Element("name");   
    		 name.setText("ddvip");   
    		 employee.addContent(name);   
    		 Element sex=new Element("sex");   
    		 sex.setText("m");   
    		 employee.addContent(sex);   
    		 Element age=new Element("age");   
    		 age.setText("23");   
    		 employee.addContent(age);   
    		 XMLOutputter XMLOut = new XMLOutputter();   
    		 try {   
    			 XMLOut.output(document, new FileOutputStream(fileName));   
    		 } catch (FileNotFoundException e) {   
    			 e.printStackTrace();   
    		 } catch (IOException e) {   
    			 e.printStackTrace();   
    		 }   
    
    	 }   
    
    	 public void parserXml(String fileName) {   
    		 SAXBuilder builder=new SAXBuilder(false);    
    		 try {   
    			 Document document=builder.build(fileName);   
    			 Element employees=document.getRootElement();    
    			 List employeeList=employees.getChildren("employee");   
    			 for(int i=0;i
    				 Element employee=(Element)employeeList.get(i);   
    				 List employeeInfo=employee.getChildren();   
    				 for(int j=0;j
    				 	System.out.println(((Element)employeeInfo.get(j)).getName()+":"
    				 			+((Element)employeeInfo.get(j)).getValue());   
    				 }   
    			 }   
    		 } catch (JDOMException e) {   
    	
    		 e.printStackTrace();   
    		 } catch (IOException e) {   
    	
    		 e.printStackTrace();   
    		 }    
    	
    		 }   
    	 }   
    	   
    
    

    展开全文
  • dom, sax是解析xml的底层接口 而jdom和dom4j则是基于底层api的更高级封装 dom是通用的,而jdom和dom4j则是面向java语言的 (方法一). DOM解析说明:为XML文档的已解析版本定义了一组接口。解析器读入整个文档...
  • 第一:DOM。 ...DOM全称是Document ...在应用程序中,基于DOM的XML分析器将一个XML文档转换成一个对象模型集合(通常称DOM树),应用程序正是通过对这个对象模型操作,来实现对XML文档数据操作。通过DO
  • 主要介绍了Java 解析XML数据的4种方式,帮助大家更好的用Java处理数据,感兴趣的朋友可以了解下
  • 4种最主流、最全面、最详细的生成和解析xml的4种方式,包括Dom,Dom4j,Sax,JDom,读懂了绝对好用xml,非常好的入门项目,而且精心排版,逻辑清晰
  • java解析xml的种方式

    2013-05-21 10:05:57
    java解析xml的种方式(包括dom4j解析和jdom解析,以及示例代码)
  • 解析xml的种方式

    2019-03-13 23:39:14
    XML的解析方式分为四: DOM解析; SAX解析; JDOM解析; DOM4J解析。 其中前两属于基础方法,是官方提供的平台无关的解析方式; 后两属于扩展方法,它们是在基础的方法上扩展出来的,只适用...
  • 源于XML的4种解析方式,怎么在servlet中将xml文档解析出来....
  • 解析XML的种方式

    2020-05-06 21:08:49
    概述 XML文档是我们平时项目中最常用配置方式...这里,就来介绍以下XML文档种解析方式: Dom SAX JDOM dom4j 1、【dom】 DOM全称是Document Object Model,也即文档对象模型。在应用程序中,基于DOM的XML...
  • xml解析的4种方式

    2017-12-20 15:05:19
    关键字:Java解析xml、解析xml四种方法...目前在Java中用于解析XML的技术很多,主流的有DOM、SAX、JDOM、DOM4j,下文主要介绍这4种解析XML文档技术的使用、优缺点及性能测试。 一、【基础知识——扫盲】 sax、do...
  • 以下具体举例使用4种方式来实现对一个.xml文件进行解析: 有命名为dome.xml的文件, java教程 89 英文 2005 php教程 65 中文 2011 c语言 33 中文 2015 1.使用dom4j的方式来...
  • XML的结构1,XML的声明2,标签3,元素4,根元素5,属性DOM解析XML文档DOM4J解析XML文档 了解XML 什么是XML?        XML是Extensibe Markup Language的缩写,即可扩展标记语言,...
  • 解析XML的种方式

    2019-05-28 01:04:41
    dom4j是第三方公司封装,dom、sax和stax是jdk提供。...所以sax和stax在解析大文件的XML时比较有效率。 若要对XML文档进行修改操作时可以选择dom4j和dom。 1. dom4j方法: 引入依赖: <depen...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,835
精华内容 734
关键字:

解析xml的4种方式