Xml解析之Sax解析（传入xml即可得到实体类集合）

最新推荐文章于 2022-04-01 16:44:39 发布
最新推荐文章于 2022-04-01 16:44:39 发布
阅读量4.5k 收藏 7
点赞数
分类专栏： Java Xml 文章标签： xml xml解析 Sax解析 数据转换
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zml_2015/article/details/69915402
版权
Java 同时被 2 个专栏收录
18 篇文章 0 订阅
订阅专栏
Xml
7 篇文章 1 订阅
订阅专栏

文章目录


之前想写一个JAXB解析xml与实体类转换的，但是发现JAXB有一定的局限性，有时，在解析非标准xml中的属性值时，不能够获取到其中的值，很奇怪的是，JAXB是jdk中自带的API，竟然在AndroidStudio环境中竟然不能使用，引入jar包也会报错，后索性改为用SAX解析，并对其进行了一定的封装，只需要传入几个简单的参数即可得到想要的实体类。

如果你的需求是根据解析xml返回一个简单对象集合，那么来这就对了。

何为简单对象，即这个对象的成员类型属于基本数据类型，当然了Date也可以，你只需要添加相关注解将字符串转换成date就行了；不含有自定义类

1. 简单介绍SAX

SAX(Simple API for XML)解析器是一种基于事件的解析器，它的核心是事件处理模式，主要是围绕着事件源以及事件处理器来工作的。当事件源产生事件后，调用事件处理器相应的处理方法，一个事件就可以得到处理。在事件源调用事件处理器中特定方法的时候，还要传递给事件处理器相应事件的状态信息，这样事件处理器才能够根据提供的事件信息来决定自己的行为。
SAX解析器的优点是解析速度快，占用内存少。非常适合在Android移动设备中使用

2. 列出要解析的数据（数据来源：http://wcf.open.cnblogs.com/news/hot/10）

<feed xmlns="http://www.w3.org/2005/Atom">
<title type="text">博客园新闻频道</title>
<id>uuid:400dd255-fe1f-4cc3-bebd-bbe2e47f2c0f;id=49744</id>
<updated>2017-04-09T10:13:38Z</updated>
<link href="http://news.cnblogs.com/" />
<entry>
<id>566495</id>
<title type="text">老外两张漫画实力黑Linux版SQL Server</title>
<summary type="text">
Linux 版 SQL Server（一）在 Linux 内核之中，大家正在静静的等待进程的创建。每个创建的进程会被分配一个进程 ID （PID）。在那个 Apache 进程高高兴兴的走出去之后，下一位却被要求创建 Linux 版的 SQL Server，这简直让人气的跳...
</summary>
<published>2017-04-06T09:22:33+08:00</published>
<updated>2017-04-09T10:13:38Z</updated>
<link rel="alternate" href="http://news.cnblogs.com/n/566495/" />
<diggs>16</diggs>
<views>4542</views>
<comments>20</comments>
<topic />
<topicIcon>http://images0.cnblogs.com/news_topic///images0.cnblogs.com/news_topic/sqlserver.gif</topicIcon>
<sourceName>linux.cn</sourceName>
</entry>
<entry>
<id>566335</id>
<title type="text">IBM都叫停SOHO办公了！创业公司还要犯这大忌？</title>
<summary type="text">
SOHO 办公一度是个十分流行的概念。据美国民意调查机构 Gallup poll 统计，美国每四个人中就有一个人选择 SOHO 办公。中国创业者最崇拜的就是自由式、咖啡厅式的谷歌办公环境。但现在，即使是一些以创新和开放著称的大公司，也开始逐渐召回自己的 SOHO 员工，让他们...
</summary>
<published>2017-04-04T16:50:41+08:00</published>
<updated>2017-04-09T10:13:38Z</updated>
<link rel="alternate" href="http://news.cnblogs.com/n/566335/" />
<diggs>6</diggs>
<views>3866</views>
<comments>11</comments>
<topic />
<topicIcon>http://images0.cnblogs.com/news_topic///images0.cnblogs.com/news_topic/ibm.gif</topicIcon>
<sourceName>虎嗅网</sourceName>
</entry>
</feed>

3. 从上面数据我们可以看出，主要是要entry中的值，所以根据entry内容，我们得到以下实体类：

/**
 * Created by zml2015 on 2017/4/8 20:16.
 */

public class BKYNews {

    private String id;

    private String title;

    /**
     * 总结，新闻概述
     */
    private String summary;

    /**
     * 发布时间
     */
    private String published;

    /**
     * 更新时间
     */
    private String updated;

    private String link_href;
    /**
     * 推荐次数（点赞次数）
     */
    private String diggs;
    /**
     * 浏览量
     */
    private String views;

    /**
     * 评论数
     */
    private String comments;

    /**
     * 话题图标，这里的网址有问题，这里的网址有一部分是重复的，只需要截取“///”之后的内容然后前篇拼接“http://”即可
     */
    private String topicIcon;

    /**
     * 新闻来源
     */
    private String sourceName;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getSummary() {
        return summary;
    }

    public void setSummary(String summary) {
        this.summary = summary;
    }

    public String getPublished() {
        return published;
    }

    public void setPublished(String published) {
        this.published = published;
    }

    public String getUpdated() {
        return updated;
    }

    public void setUpdated(String updated) {
        this.updated = updated;
    }


    public String getDiggs() {
        return diggs;
    }

    public void setDiggs(String diggs) {
        this.diggs = diggs;
    }

    public String getViews() {
        return views;
    }

    public void setViews(String views) {
        this.views = views;
    }

    public String getComments() {
        return comments;
    }

    public void setComments(String comments) {
        this.comments = comments;
    }

    public String getTopicIcon() {
        return topicIcon;
    }

    public void setTopicIcon(String topicIcon) {
        this.topicIcon = topicIcon;
    }

    public String getSourceName() {
        return sourceName;
    }

    public void setSourceName(String sourceName) {
        this.sourceName = sourceName;
    }

    public String getLink_href() {
		return link_href;
	}

	public void setLink_href(String link_href) {
		this.link_href = link_href;
	}

	@Override
    public String toString() {
        return "BKYNews{" +
                "id='" + id + '\'' +
                ", title='" + title + '\'' +
                ", summary='" + summary + '\'' +
                ", published='" + published + '\'' +
                ", updated='" + updated + '\'' +
                ", link='" + link_href + '\'' +
                ", diggs='" + diggs + '\'' +
                ", views='" + views + '\'' +
                ", comments='" + comments + '\'' +
                ", topicIcon='" + topicIcon + '\'' +
                ", sourceName='" + sourceName + '\'' +
                '}';
    }
}

4. 给出的实体类的规则是：

* 属性名与要解析的xml的标签名一致
* 如果要解析标签中的属性值，则命名规则为：标签名+下划线+ 属性名
> 如上面给出的实体类中一个属性名叫`link_href`，即是xml中link标签中的href属性

* 暂只支持标签2层`（要解析的数据有两层，而不是要解析的数据在整个xml数据中有多少层）`嵌套，不支持标签多层嵌套，（如entry标签中有author,author标签中有name），稍后我会尝试写一个，如有大神解救，甚是欢喜
* 实体类名称与要解析的标签名称不一致没有关系，因为需要将要解析的根标签传入，如，我们要解析的数据是entry标签中的内容，所以要传入entry

5. 给出SAX最最重要的解析过程，这个是个工具类中的内容，可直接拷贝，无须修改

/**
 * @author zml2015
 * @Email zhengmingliang911@gmail.com
 * @Time 2017年4月9日 下午2:58:36
 * @Description <p>用于解析xml为实体类的处理器  </P>
 * @version 1.0  
 */
class XMlHandler<T> extends DefaultHandler{
	String rootElemntName;
	Map<String, String> dataMap;
	StringBuilder stringBuilder;
	List<T> dataList;
	T data;
	Class<T> clz;
	private Map<String,Class> attrs;
	
	/**
	 * @author zml2015
	 * @Email zhengmingliang911@gmail.com
	 * @Time 2017年4月9日 下午3:13:43
	 * @Description <p> 当前标签名称 </P>
	 * @version 1.0  
	 */
	private String currentTag;
	/**
	 * 要解析的单个实体的根元素名称
	 * @param rootElemntName
	 * @throws IllegalAccessException 
	 * @throws InstantiationException 
	 */
	XMlHandler(String rootElemntName,Class<T> clz,Map<String,Class> attrsMap) {
		this.rootElemntName = rootElemntName;
		this.clz = clz;
		this.attrs = attrsMap;
	}
	
	@Override
	public void startDocument() throws SAXException {
		super.startDocument();
		dataMap = new HashMap<String, String>();
		stringBuilder = new StringBuilder();
		dataList = new ArrayList<>();
	}
	
	@Override
	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
		// TODO Auto-generated method stub
		super.startElement(uri, localName, qName, attributes);
		//赋值给当前标签名称
		currentTag = qName;
		if (rootElemntName.equals(qName)) {
			try {
				data = clz.newInstance();
				
			} catch (InstantiationException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
		//每次对一个标签解析前，都先置为空
		stringBuilder.setLength(0);
		//如果某个标签中有属性，则将其保存到map中，保存规则：key = “标签名称_属性名称” value = “属性值”
		if(attributes != null && dataMap != null){
			for (int i = 0; i < attributes.getLength(); i++) {
				dataMap.put(qName+"_"+attributes.getQName(i), attributes.getValue(i));
			}
			
		}
		
		
	}
	
	@Override
	public void characters(char[] ch, int start, int len) throws SAXException {
		// TODO Auto-generated method stub
		super.characters(ch, start, len);
		stringBuilder.append(ch,start,len);
		Field[] fields = clz.getDeclaredFields();
		try {
			if (StringUtils.isNotEmpty(currentTag) && data != null) {
				for (Field field : fields) {
					String name = field.getName();
					if (currentTag.equals(name)) {
						name = name.substring(0,1).toUpperCase() + name.substring(1);
						
						Method method = data.getClass().getMethod("set"+name, field.getType());
						method.invoke(data, stringBuilder.toString());
					}
				}
			}
		
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}

	@Override
	public void endElement(String uri, String localName, String qName) throws SAXException {
        super.endElement(uri, localName, qName);
        if (rootElemntName.equals(qName)) {
        	try {
				if (attrs != null) {
					
					for (String attrName : attrs.keySet()) {
						String methodName = "set"+attrName.substring(0,1).toUpperCase()+attrName.substring(1);
						Method method = data.getClass().getMethod(methodName,attrs.get(attrName));
						method.invoke(data, dataMap.get(attrName));
					}
				}
			} catch (NoSuchMethodException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (SecurityException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IllegalArgumentException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
        	
			dataList.add(data);
		}
        
	}

	@Override
	public void endDocument() throws SAXException {
	System.out.println("解析结束："+dataList);
		super.endDocument();
	}


	public List<T> getDataList(){
		return dataList;
	}
	
	public T getData(){
		return data;
	}
}

6. 工具类：主要看工具类的最后一个方法：parseXml2Bean，前面方法均是JAXB对xml与对象转换的方法

import java.io.ByteArrayInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.io.StringWriter;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

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

import top.wys.developerclub.model.SysUser;
import top.wys.developerclub.test.BKYAticle;

public class XmlUtils {


	/**
	 * @author zml2015
	 * @Time 2017年4月1日19:04:50
	 * @Description <p>
	 *              将实体类直接转换成xml
	 *              </p>
	 * @param t
	 *            要转换成xml的对象
	 * @return xml字符串
	 */
	public static <T> String createXmlFromBean(T t) {
		String xml = "";
		if (t == null) {
			return xml;
		} else {
			try (StringWriter write = new StringWriter()) {
				JAXBContext context = JAXBContext.newInstance(t.getClass());
				Marshaller marshaller = context.createMarshaller();
				marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
				marshaller.marshal(t, write);
				xml = write.toString();
			} catch (JAXBException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			return xml;
		}
	}
	/**
	 * @author zml2015
	 * @Time 2017年4月1日19:04:50
	 * @Description <p>
	 *              将实体类直接转换成xml，要转换的类必需加油@XmlRootElement注解
	 *              </p>
	 * @param t
	 *            要转换成xml的对象
	 * @param format 是否格式化输出，{@code true}格式化输出，{@code false} 不进行格式化
	 * @return xml字符串
	 */
	public static <T> String createXmlFromBean(T t,boolean format) {
		String xml = "";
		if (t == null) {
			return xml;
		} else {
			try (StringWriter write = new StringWriter()) {
				// 利用jdk中自带的转换类实现
				JAXBContext context = JAXBContext.newInstance(t.getClass());
				Marshaller marshaller = context.createMarshaller();
				// 格式化xml输出的格式 
				marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, format);
				// 将对象转换成xml写入到StringWriter中
				marshaller.marshal(t, write);
				xml = write.toString();
			} catch (JAXBException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			return xml;
		}
	}
	/**
	 * @author zml2015
	 * @Time 2017年4月1日19:04:50
	 * @Description <p>
	 *              将实体类直接转换成xml，要转换的类必需加油@XmlRootElement注解
	 *              </p>
	 * @param t	要转换成xml的对象
	 *            
	 * @param filePath 要保存到的文件路径
	 * @return xml字符串
	 */
	public static <T> void createXmlToFile(T t,String filePath) {
			try (FileWriter write = new FileWriter(filePath)) {
				// 利用jdk中自带的转换类实现
				JAXBContext context = JAXBContext.newInstance(t.getClass());
				Marshaller marshaller = context.createMarshaller();
				// 格式化xml输出的格式 
				marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
				// 将对象转换成xml写入到StringWriter中
				marshaller.marshal(t, write);
			} catch (JAXBException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
	}

	@SuppressWarnings("unchecked")
	public static <T> T getBeanFromXml(String xml, Class<T> clz) {
		T t = null;
		try (StringReader reader = new StringReader(xml);) {
			JAXBContext context = JAXBContext.newInstance(clz);
			Unmarshaller unmarshal = context.createUnmarshaller();
			t = (T) unmarshal.unmarshal(reader);
		} catch (JAXBException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return t;
	}
	
	@SuppressWarnings("unchecked")
	public static <T> T getBeanFromXml(InputStream is, Class<T> clz) {
		T t = null;
		try{
			JAXBContext context = JAXBContext.newInstance(SysUser.class);
			Unmarshaller unmarshal = context.createUnmarshaller();
			t = (T) unmarshal.unmarshal(is);
		} catch (JAXBException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return t;
	}
    /**
	 * @author zml2015
	 * @Email zhengmingliang911@gmail.com
	 * @Time 2017年4月9日 下午6:32:02
	 * @Description <p> 将xml转换为指定对象 </P>
	 * @param xml  要解析的xml数据
	 * @param rootElemntName  要解析的内容的根标签名称
	 * @param clz 要转换成的实体类，
	 * @param attrs key值为要解析的xml标签中的属性值， value 值为属性值类型 
	 * @return
	 */
	public <T> List<T> parseXml2Bean(String xml,String rootElemntName,Class<T> clz,Map<String, Class> attrs){
		
		XMlHandler<T> handler = null;
		try(ByteArrayInputStream stream = new ByteArrayInputStream(xml.getBytes());) {
			handler = new XMlHandler<>(rootElemntName, clz, attrs);
			SAXParserFactory factory = SAXParserFactory.newInstance();
			SAXParser parser = factory.newSAXParser();
			parser.parse(stream, handler);
			System.out.println(handler.getDataList());
		} catch (ParserConfigurationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SAXException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return handler.getDataList();
	}
}

7. 测试类：

@Test
	public void testXML2Model1() throws IOException {
		String xml = HttpUtils.getHttpData("http://wcf.open.cnblogs.com/news/hot/10");
		Map<String,Class> map = new HashMap<>();
		map.put("link_href", String.class);
		List<BKYAticle> list = parseXml2Bean(xml,"entry", BKYAticle.class,map);

	}

8. 效果图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LLCMqTvk-1612149272748)(http://oexaoy5pt.bkt.clouddn.com/17-4-9/493522-file_1491736635077_1814a.png)]
点次查看完整大图（一定要找到中间那条线，然后在上面放大查看哦）

文章首次发布于个人博客：吾勇士的博客，点击查看原文

zml_2015
关注
专栏目录
使用sax解析xml文件，并自动根据实体类class得到映射后的实体类list集合
sujudz的专栏
06-10 5977
java中的javax.xml.parsers.SAXParser类用于解析xml文件，他是基于事件流形式解析的，其他解析xml的类和jar包还有很多，比如DOM是基于XML文档树结构的解析（代表有dom4j。sax的解析特点，决定其不是很占用太大内存，当然也有弊端，这里只是学习一下sax如何解析xml。 sax解析的一般步骤： //从流中解析xml文件 public List pars
xml解析为实体类方法
weixin_30636089的博客
06-21 116
public static List<SheetDetail> parse(String xml) { try { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = fa...
解析xml利用反射机制解析到对应实体类实现方式之一
BF的博客
05-21 569
根据业务需要，需要对获取xml里数据，下面是利用SAXParser进行实现的，代码实现如下： package tjs.utils.base.util; import lombok.Data; import org.xml.sax.Attributes; import org.xml.sax.SAXException; import org.xml.sax.helpers.DefaultHa...
java使用SAX接口解析xml文件
全栈工程师开发手册（原创）https://github.com/tencentmusic/cube-studio
10-06 4753
全栈工程师开发手册 （作者：栾鹏） java教程全解 java使用SAX接口解析xml文件。实现解析类，从xml解析开始到结尾，每一步均会触发对象的重载函数。测试代码，将book1.xml改成你自己的xml文件名称//主方法，声明解析工厂和加载XML文件 public static void main(String[] argv) { try {
Java&Xml教程（五）使用SAX方式解析XML文件
weixin_34384915的博客
12-13 118
Java SAX解析机制为我们提供了一系列的API来处理XML文件，SAX解析和DOM解析方式不太一样，它并不是將XML文件内容一次性全部加载，而是连续的部分加载。 javax.xml.parsers.SAXParser类提供了一些函数，采用事件处理方式解析XML文档，这个类实现了XMLReader接口，提供了重载的parse()方法从File,InputStream,SAX...
Android XML解析之SAX方式
09-22
3. **解析XML文件**：最后，调用`parse()`方法，传入XML文件的输入流或URL，开始解析过程。 **SAX解析器的主要优点** - **内存效率高**：SAX解析器仅处理当前元素，不保留整个文档结构，适合处理大文件。 - **实时...
xml sax解析
07-29
- 调用解析器的parse()方法，传入XML输入源（如文件路径、URL或流）。 以下是一个简单的SAX解析器使用示例： ```java import org.xml.sax.Attributes; import org.xml.sax.SAXException; import org.xml.sax....
java解析xml数据---sax解析器
04-14
3. 调用SAXParser对象的parse()方法，传入XML文件的输入流和之前创建的事件处理器对象，开始解析过程。 以下是一个简单的SAX解析示例，以处理名为`person.xml`的文件为例： ```java import javax.xml.parsers.*; ...
JSP基于dom解析xml实例详解
10-23
首先，通过`DocumentBuilderFactory`创建`DocumentBuilder`，然后使用`parse()`方法解析XML文件，得到`Document`对象。接下来，我们获取名为"user"的节点列表，并遍历每个节点，通过比较当前节点的"name"和"pwd"属性...
SAX解析XML
03-29
3. **解析XML**：调用`parse()`方法，传入XML文件或输入流，开始解析过程。 4. **处理事件**：解析器在读取XML时，根据遇到的元素触发事件处理器中的相应方法，用户在这些方法内处理数据。 ### 4. 事件处理器的关键...
XML解析之SAX解析
weixin_30734435的博客
07-11 84
参考：http://blog.csdn.net/ydxlt/article/details/50183693 转载于:https://www.cnblogs.com/JAYIT/p/7070132.html
Java使用SAX解析xml文件详解,3.使用sax解析xml文档(我的JavaEE笔记)
weixin_39528994的博客
03-15 506
注意：使用sax编程只能进行查询操作。1、在使用DOM解析XML文档时，需要读取整个XML文档，在内存中构架代表整个DOM树的Document对象，从而再对XML文档进行操作。此中情况下，如果XML文档特别大，就会消耗计算机大量内存，并且容易导致内存溢出。2、 SAX解析允许在读取文档的时候，立即对文档进行处理，而不必等到整个文档装载完才会对文档进行操作。3、SAX采用事件处理的方式解析XML文件...
java利用反射实现Sax实现 xml万能解析器
yuhui77268769的博客
05-22 309
大概思路： 1.首先我们通过输入流来获取要读取的xml文件。 2**.xml是存放一个对象的数据源，具体对象中的属性我们不知道，那么我们就需要利用反射来读取对象中的属性，利用反射来创建对象，给对象赋值。 3.开始解析，执行开始文档的方法，<> 开始标签里面有值就可以利用attributes.getValue()**方法来获取值. 4.读取到属性调用 **characters（）**方...
java 上传读取xml 转实体进行保存
z_victoria123的博客
04-01 857
xml文件转实体 上传xml文件
Java SAX生成和解析XML
热门推荐
p812438109的专栏
08-18 1万+
SAX解析 场景：从上往下线性读取xml时 解析比较大的xml文档时 优点：读取速度快，内存消耗小 缺点：只能知道当前节点的信息，如需知道其它信息，需要自己编码实现 SAX解析步骤 第一步：创建sax转换工厂 SAXTransformerFactory factory = (SAXTransformerFactory)SAXTransf...
java利用反射解析xml到实体类
功不唐捐，玉汝于成。
05-23 1908
定义一个Handler，处理sax解析 package com.jb.f1.scd.service.impl; import java.lang.reflect.Field; import java.util.LinkedList; import java.util.List; import org.xml.sax.Attributes; import org.xml.sax.SAXExce
使用SAX解析将xml的文件保存为java对象
Lxj12306的博客
01-12 400
转载自：http://blog.csdn.net/kingsonyoung/article/details/5199508 在Java使用Sax解析xml文件中，我们介绍了如何用SAX解析xml文件，接下来我们继续学习如何将一个xml文件的内容结构保存到一个java实例对象中 一、xml文件如下 [html] view plain copy
SAX解析XML文件
胖大海的博客
07-17 595
SAX解析简介 SAX（Simple API for XML）是一种以事件驱动的XML API，是XML解析的方式之一。DOM解析会将XML全部加载到内存中，再进行解析。SAX与DOM不同的是它边扫描边解析，自顶向下依次解析，由于边扫描边解析，所以它解析XML具有速度快，占用内存少的优点。 SAX解析步骤 SAX解析的核心步骤有如下几步： 得到xml文件对应的资源，可以是xml的输入流，文件和...
SAX 解析XML文件:将XML转换成Java对象
daozhongyang的专栏
08-04 4579
本博客介绍的是解析本地XML文件，解析网络上的XML 本文写得比较简略，实际上项目应用更多的是解析网上的xml资源 使用SAX 处理XML需要一个Handler 对象,一般继承org.xml.sax,helpers.DefaultHandler 作为Handler 对象 先看示意图      SAX解析XML文件通常需要5个分析事件，也可理解为5步骤:           startDo
Android XML解析：SAX, DOM与PULL解析器实战
"Android编程解析XML方法详解，包括SAX、DOM和PULL解析器的介绍及应用示例" 在Android开发中，XML作为一种轻量级的数据交换格式，被广泛用于存储和传输数据。掌握XML的解析技巧对于Android开发者至关重要。本文主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值