java 解析xml文件

最新推荐文章于 2024-08-12 23:01:19 发布

11爱学习的程序员11

最新推荐文章于 2024-08-12 23:01:19 发布

阅读量511

点赞数

分类专栏： java基础文章标签： java xml文件解析

本文链接：https://blog.csdn.net/zhang1314fudao/article/details/80794025

版权

java基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一、SAX：基于事件流的解析

优点：不用事先调入整个文档，占用资源少；SAX解析器代码比DOM解析器代码小，适于Applet，下载。

缺点：不是持久的；事件过后，若没保存数据，那么数据就丢了；无状态性；从事件中只能得到文本，但不知该文本属于哪个元素；

使用场合：Applet;只需XML文档的少量内容，很少回头访问；机器内存少；

步骤：

1、获取解析工厂

2、获取解析器

3、加载文档Document 注册处理器

package xmlParse.sax;

import java.io.IOException;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.SAXException;

/**
* @author:zhangfd
* @version:1.0 
* @date:2017年10月11日 下午11:02:57
* @description:sax解析xml文件
*/
public class XmlParse01 {

	public static void main(String[] args) throws Exception {
		
		//1、获取解析工厂
		SAXParserFactory  factory = SAXParserFactory.newInstance();
 
		//2、获取解析器
		 SAXParser  saxParser = factory.newSAXParser();
		 //3、编写自定义的处理器，需要继承DefaultHandler
		 PersonHandler handler  = new PersonHandler();
		 //4、加载文档Document 注册处理器
		 saxParser.parse(Thread.currentThread().getContextClassLoader().getResourceAsStream("\\xmlParse\\sax\\person.xml"), 
				 handler);
		 for (Person person : handler.getPersons()) {
			 System.out.println(person.getName()+"--->"+person.getAge());
		}
		 
	}
	
}

package xmlParse.sax;
/**
* @author:zhangfd
* @version:1.0 
* @date:2017年10月11日 下午11:00:21
* @description:
*/
public class Person {

	private String name ;  
	
	private String age;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getAge() {
		return age;
	}

	public void setAge(String age) {
		this.age = age;
	}
	
	
	
}

package xmlParse.sax;

import java.util.ArrayList;
import java.util.List;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

/**
* @author:zhangfd
* @version:1.0 
* @date:2017年10月11日 下午11:10:45
* @description: 实现DefaultHandler 类的5个方法，依次为startDocument、startElement、characters、endElement、endDocument
*/
public class PersonHandler extends DefaultHandler{

	private List<Person> persons ;
	
	private Person person;
	
	private String tag = null;
	
	@Override
	public void startDocument() throws SAXException {
		//System.out.println("开始处理文档");
		persons = new ArrayList<Person>();
	}

	

	@Override
	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
		System.out.println("开始处理元素"+qName);
		tag = qName;
		if("person".equals(qName)){
			person = new Person();
		}
		
		
		
	}
	
	@Override
	public void characters(char[] ch, int start, int length) throws SAXException {
		String s = new String(ch, start, length);
		if("name".equals(tag)){
			person.setName(s);
		}else if("age".equals(tag)){
		    person.setAge(s);
		}
	}
	

	@Override
	public void endElement(String uri, String localName, String qName) throws SAXException {
		System.out.println("结束处理元素"+qName);
		
		if("person".equals(qName)){
			persons.add(person);
			
		}
		tag = null;
	}

	
	@Override
	public void endDocument() throws SAXException {
		System.out.println("结束处理文档");
	}



	public List<Person> getPersons() {
		return persons;
	}



	public void setPersons(List<Person> persons) {
		this.persons = persons;
	}

}

<?xml version="1.0" encoding="UTF-8"?>
<persons>

	<person>
		<name>zhangsan</name>
		<age>100</age>
	</person>

	<person>
		<name>lisi</name>
		<age>25</age>
	</person>

</persons>

二、DOM：基于XML文档树结构的解析

解析器读入整个文档，然后构建一个驻留内存的树结构，然后代码就可以使用 DOM 接口来操作这个树结构。

优点：整个文档树在内存中，便于操作；支持删除、修改、重新排列等多种功能；

缺点：将整个文档调入内存（包括无用的节点），浪费时间和空间；

使用场合：一旦解析了文档还需多次访问这些数据；硬件资源充足（内存、CPU）。

步骤：

1、获得解析工厂

2、获得解析器

3、获取Document，根据节点名，解析xml文档

package xmlParse.dom;

import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 * @author:zhangfd
 * @version:1.0
 * @date:2017年10月15日 下午1:14:21
 * @description: dom解析xml文件
 */
public class Xmlparse02 {

	public static void main(String[] args) throws Exception {
		//1、获取document工厂
		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
		//2、创建构造器
		DocumentBuilder docBuilder = factory.newDocumentBuilder();
	    //3、创建document
		Document document = docBuilder.parse(Thread.currentThread().getContextClassLoader().getResourceAsStream("\\xmlParse\\dom\\person.xml"));
		
		//Element  root = document.getDocumentElement();
		 NodeList personList =  document.getElementsByTagName("person");
		 List<Person> pList = new ArrayList<Person>();
		 for (int i =0;i<personList.getLength();i++){
			 Person p = new Person();
			 Element person = (Element) personList.item(i);
			 String nameValue = person.getElementsByTagName("name").item(0).getTextContent();
			 String ageValue = person.getElementsByTagName("age").item(0).getTextContent();
			 p.setAge(ageValue);
			 p.setName(nameValue);
			 pList.add(p);
		 }
		 for (Person person : pList) {
			System.out.println(person.getAge()+"------"+person.getName());
		}
	

	}
}

Person类和person.xml文件和上类相同。

下面抽象出一个DOM解析的通用类:

package xmlParse;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.apache.commons.lang.StringUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

import xmlParse.dom.Person;

/**
* @author:zhangfd
* @version:1.0 
* @date:2017年10月15日 下午2:45:30
* @description: DOM解析xml文件通用类, 返回Document对象
*/
public class DomParseXmlUtil {

	private DocumentBuilder docBuilder;
	
	private Document document;
	
	private static String CHARSET = "utf-8";
	
	public DomParseXmlUtil() {
		init();
	}
	
	/**
	 * 
	 * @param xmlContent 需要解析的xml内容
	 * @param charset    解析使用的编码
	 */
	public DomParseXmlUtil(String xmlContent, String charset) {
		this();
		if(StringUtils.isNotBlank(charset))
		DomParseXmlUtil.CHARSET = charset;
		
        if(null != docBuilder){
			try {
				this.document = docBuilder.parse(new ByteArrayInputStream(xmlContent.getBytes(charset)));
			} catch (Exception e) {
				e.printStackTrace();
			} 
		}
		
	}

	/**
	 *  默认采用utf-8编码格式
	 * @param xmlContent 需要解析的xml文件
	 */
	public DomParseXmlUtil(String xmlContent){
		this(xmlContent,CHARSET);
	}


	private void init(){
		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
		try {
			docBuilder = factory.newDocumentBuilder();
		} catch (ParserConfigurationException e) {
			docBuilder = null;
		}
	}

	
	public static void main(String[] args) throws Exception {
		InputStream ins = Thread.currentThread().getContextClassLoader().getResourceAsStream("\\xmlParse\\dom\\person.xml");
		
		String xmlContent = covertionInputStreamToString(ins,null);
		DomParseXmlUtil domParseXmlUtil = new DomParseXmlUtil(xmlContent);
		Document document = domParseXmlUtil.getDocument();
		
		if(null != document){
			NodeList personList =  document.getElementsByTagName("person");
			 List<Person> pList = new ArrayList<Person>();
			 for (int i =0;i<personList.getLength();i++){
				 Person p = new Person();
				 Element person = (Element) personList.item(i);
				 String nameValue = person.getElementsByTagName("name").item(0).getTextContent();
				 String ageValue = person.getElementsByTagName("age").item(0).getTextContent();
				 p.setAge(ageValue);
				 p.setName(nameValue);
				 pList.add(p);
			 }
			 for (Person person : pList) {
				System.out.println(person.getAge()+"------"+person.getName());
			}
		}
		 
	}
	
	/**
	 * 输入流转化为字符串 默认使用utf-8编码
	 * @param ins 输入流
	 * @return 
	 */
	public static String covertionInputStreamToString(InputStream ins,String chaeSet){
        try {
        	if(StringUtils.isNotEmpty(chaeSet)){
        		DomParseXmlUtil.CHARSET = chaeSet;
        	}
			BufferedReader bf = new BufferedReader(new InputStreamReader(ins,CHARSET ));
			String line = null;
			StringBuilder sb = new StringBuilder();
			while(null != (line=bf.readLine())){
				sb.append(line+"\n");
			}
			return sb.toString();
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		} 
	}




	public Document getDocument() {
		return document;
	}


	public void setDocument(Document document) {
		this.document = document;
	}



	
	
}

以上两种为java自带的xml文件解析，下面介绍两种关于解析xml比较优秀的框架

三、DOM4J生成和解析XML文档

package xmlParse.dom4j;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Iterator;

import org.apache.commons.lang.StringUtils;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;

/**
* @author:zhangfd
* @version:1.0 
* @date:2017年10月15日 下午4:50:03
* @description:
*/
public class Dom4jReaderXml {

	public static void main(String[] args) {
		
		//存放xml文档
		String xmlContent="";
		//1、定义解析器
		 SAXReader saxReader = new SAXReader();
		 try {
			    InputStream ins = Thread.currentThread().getContextClassLoader().getResourceAsStream("\\xmlParse\\dom4j\\person.xml");
			    xmlContent = covInputStreamToString(ins);
			    //2、读取xml内容，存放在document对象中
			    org.dom4j.Document document = saxReader.read(new ByteArrayInputStream(xmlContent.getBytes("utf-8")));
			    //3、获取根节点信息
			    org.dom4j.Element rootElement = document.getRootElement();
			    //获取子节点名和对应的值
	            getChildNodes(rootElement);
	           
	        } catch (Exception e) {
	            System.out.println(e.getMessage());
	        }
	}
	//获取节点名和对应的值
	public static void getChildNodes(Element element){
		 for (Iterator<?> j = element.elementIterator(); j.hasNext();) {
             Element node = (Element) j.next();
             if(StringUtils.isNotBlank(node.getText()))
             System.out.println(node.getName() + ":" + node.getText());
             getChildNodes(node);
         }
    }

	
	public static String covInputStreamToString(InputStream ins){
        try {
			BufferedReader bf = new BufferedReader(new InputStreamReader(ins, "utf-8"));
			String line = null;
			StringBuilder sb = new StringBuilder();
			while(null != (line=bf.readLine())){
				sb.append(line+"\n");
			}
			return sb.toString();
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		} 
	}
}

<?xml version="1.0" encoding="UTF-8"?>
<persons>
	<person>
		<name>zhangsan</name>
		<age>100</age>
		<wo>
		  <per>wodn</per>
		</wo>
	</person>
	<person>
		<name>lisi</name>
		<age>25</age>
	</person>
</persons>

11爱学习的程序员11

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
java 解析xml文件

一、SAX：基于事件流的解析优点：不用事先调入整个文档，占用资源少；SAX解析器代码比DOM解析器代码小，适于Applet，下载。缺点：不是持久的；事件过后，若没保存数据，那么数据就丢了；无状态性；从事件中只能得到文本，但不知该文本属于哪个元素；使用场合：Applet;只需XML文档的少量内容，很少回头访问；机器内存少；步骤：1、获取解析工厂2、获取解析器3、加载文档Document 注册处理器...
复制链接

扫一扫

专栏目录